diff --git a/package/CHANGELOG.md b/package/CHANGELOG.md
index c46e98054..951b9b8dd 100755
--- a/package/CHANGELOG.md
+++ b/package/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.0.2] - 2019-03-18
+
+### Changed
+- Fixed issue with population of Syncvar variable on a class derived from a networkbehaviour base class (case 1066429)
+- Fixed issue with IsDynamic not working on .net 3.5 profile (use something else)]
+- Fixed file lock error when building under certain conditions (case 1115492)
+ 
 ## [1.0.1] - 2019-02-14
 
 ### Changed
diff --git a/package/Editor/Tools/Weaver/Helpers.cs b/package/Editor/Tools/Weaver/Helpers.cs
index 15a3cf2a9..5e4b1458c 100755
--- a/package/Editor/Tools/Weaver/Helpers.cs
+++ b/package/Editor/Tools/Weaver/Helpers.cs
@@ -58,7 +58,7 @@ public static ISymbolReaderProvider GetSymbolReaderProvider(string inputFile)
             return null;
         }
 
-        public static bool InheritsFromSyncList(TypeReference typeRef)
+        public static bool InheritsFromSyncList(TypeReference typeRef, Weaver weaver)
         {
             try
             {
@@ -68,14 +68,14 @@ public static bool InheritsFromSyncList(TypeReference typeRef)
                     return false;
                 }
 
-                foreach (var type in ResolveInheritanceHierarchy(typeRef))
+                foreach (var type in ResolveInheritanceHierarchy(typeRef, weaver))
                 {
                     // only need to check for generic instances, as we're looking for SyncList<T>
                     if (type.IsGenericInstance)
                     {
                         // resolves the instance type to it's generic type definition, for example SyncList<Int> to SyncList<T>
                         var typeDef = type.Resolve();
-                        if (typeDef.HasGenericParameters && typeDef.FullName == Weaver.SyncListType.FullName)
+                        if (typeDef.HasGenericParameters && typeDef.FullName == weaver.SyncListType.FullName)
                         {
                             return true;
                         }
@@ -90,19 +90,19 @@ public static bool InheritsFromSyncList(TypeReference typeRef)
             return false;
         }
 
-        public static IEnumerable<TypeReference> ResolveInheritanceHierarchy(TypeReference type)
+        public static IEnumerable<TypeReference> ResolveInheritanceHierarchy(TypeReference type, Weaver weaver)
         {
             // for value types the hierarchy is pre-defined as "<Self> : System.ValueType : System.Object"
             if (type.IsValueType)
             {
                 yield return type;
-                yield return Weaver.valueTypeType;
-                yield return Weaver.objectType;
+                yield return weaver.valueTypeType;
+                yield return weaver.objectType;
                 yield break;
             }
 
             // resolve entire hierarchy from <Self> to System.Object
-            while (type != null && type.FullName != Weaver.objectType.FullName)
+            while (type != null && type.FullName != weaver.objectType.FullName)
             {
                 yield return type;
 
@@ -127,7 +127,7 @@ public static IEnumerable<TypeReference> ResolveInheritanceHierarchy(TypeReferen
             }
 
 
-            yield return Weaver.objectType;
+            yield return weaver.objectType;
         }
 
         public static string DestinationFileFor(string outputDir, string assemblyPath)
diff --git a/package/Editor/Tools/Weaver/MessageClassProcessor.cs b/package/Editor/Tools/Weaver/MessageClassProcessor.cs
index 38184c237..37c1867a1 100755
--- a/package/Editor/Tools/Weaver/MessageClassProcessor.cs
+++ b/package/Editor/Tools/Weaver/MessageClassProcessor.cs
@@ -7,32 +7,34 @@ namespace Unity.UNetWeaver
     class MessageClassProcessor
     {
         TypeDefinition m_td;
+        Weaver m_Weaver;
 
-        public MessageClassProcessor(TypeDefinition td)
+        public MessageClassProcessor(TypeDefinition td, Weaver weaver)
         {
-            Weaver.DLog(td, "MessageClassProcessor for " + td.Name);
             m_td = td;
+            m_Weaver = weaver;
+            m_Weaver.DLog(td, "MessageClassProcessor for " + td.Name);
         }
 
         public void Process()
         {
-            Weaver.DLog(m_td, "MessageClassProcessor Start");
+            m_Weaver.DLog(m_td, "MessageClassProcessor Start");
 
-            Weaver.ResetRecursionCount();
+            m_Weaver.ResetRecursionCount();
 
             GenerateSerialization();
-            if (Weaver.fail)
+            if (m_Weaver.fail)
             {
                 return;
             }
 
             GenerateDeSerialization();
-            Weaver.DLog(m_td, "MessageClassProcessor Done");
+            m_Weaver.DLog(m_td, "MessageClassProcessor Done");
         }
 
         void GenerateSerialization()
         {
-            Weaver.DLog(m_td, "  GenerateSerialization");
+            m_Weaver.DLog(m_td, "  GenerateSerialization");
             foreach (var m in m_td.Methods)
             {
                 if (m.Name == "Serialize")
@@ -49,7 +51,7 @@ void GenerateSerialization()
             {
                 if (field.FieldType.FullName == m_td.FullName)
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_td.Name + " [" + field.FullName + "]. [MessageBase] member cannot be self referencing.");
                     return;
                 }
@@ -58,9 +60,9 @@ void GenerateSerialization()
             MethodDefinition serializeFunc = new MethodDefinition("Serialize", MethodAttributes.Public |
                     MethodAttributes.Virtual |
                     MethodAttributes.HideBySig,
-                    Weaver.voidType);
+                    m_Weaver.voidType);
 
-            serializeFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkWriterType)));
+            serializeFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkWriterType)));
             ILProcessor serWorker = serializeFunc.Body.GetILProcessor();
 
             foreach (var field in m_td.Fields)
@@ -70,19 +72,19 @@ void GenerateSerialization()
 
                 if (field.FieldType.Resolve().HasGenericParameters)
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_td.Name + " [" + field.FieldType + "/" + field.FieldType.FullName + "]. [MessageBase] member cannot have generic parameters.");
                     return;
                 }
 
                 if (field.FieldType.Resolve().IsInterface)
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_td.Name + " [" + field.FieldType + "/" + field.FieldType.FullName + "]. [MessageBase] member cannot be an interface.");
                     return;
                 }
 
-                MethodReference writeFunc = Weaver.GetWriteFunc(field.FieldType);
+                MethodReference writeFunc = m_Weaver.GetWriteFunc(field.FieldType);
                 if (writeFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
@@ -92,7 +94,7 @@ void GenerateSerialization()
                 }
                 else
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_td.Name + " unknown type [" + field.FieldType + "/" + field.FieldType.FullName + "]. [MessageBase] member variables must be basic types.");
                     return;
                 }
@@ -104,7 +106,7 @@ void GenerateSerialization()
 
         void GenerateDeSerialization()
         {
-            Weaver.DLog(m_td, "  GenerateDeserialization");
+            m_Weaver.DLog(m_td, "  GenerateDeserialization");
             foreach (var m in m_td.Methods)
             {
                 if (m.Name == "Deserialize")
@@ -119,9 +121,9 @@ void GenerateDeSerialization()
             MethodDefinition serializeFunc = new MethodDefinition("Deserialize", MethodAttributes.Public |
                     MethodAttributes.Virtual |
                     MethodAttributes.HideBySig,
-                    Weaver.voidType);
+                    m_Weaver.voidType);
 
-            serializeFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkReaderType)));
+            serializeFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkReaderType)));
             ILProcessor serWorker = serializeFunc.Body.GetILProcessor();
 
             foreach (var field in m_td.Fields)
@@ -129,7 +131,7 @@ void GenerateDeSerialization()
                 if (field.IsStatic || field.IsPrivate || field.IsSpecialName)
                     continue;
 
-                MethodReference readerFunc = Weaver.GetReadFunc(field.FieldType);
+                MethodReference readerFunc = m_Weaver.GetReadFunc(field.FieldType);
                 if (readerFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
@@ -139,7 +141,7 @@ void GenerateDeSerialization()
                 }
                 else
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateDeSerialization for " + m_td.Name + " unknown type [" + field.FieldType + "]. [SyncVar] member variables must be basic types.");
                     return;
                 }
diff --git a/package/Editor/Tools/Weaver/MonoBehaviourProcessor.cs b/package/Editor/Tools/Weaver/MonoBehaviourProcessor.cs
index 76fe5ac7b..e0770d42d 100755
--- a/package/Editor/Tools/Weaver/MonoBehaviourProcessor.cs
+++ b/package/Editor/Tools/Weaver/MonoBehaviourProcessor.cs
@@ -7,10 +7,12 @@ namespace Unity.UNetWeaver
     class MonoBehaviourProcessor
     {
         TypeDefinition m_td;
+        Weaver m_Weaver;
 
-        public MonoBehaviourProcessor(TypeDefinition td)
+        public MonoBehaviourProcessor(TypeDefinition td, Weaver weaver)
         {
             m_td = td;
+            m_Weaver = weaver;
         }
 
         public void Process()
@@ -26,17 +28,17 @@ void ProcessSyncVars()
             {
                 foreach (var ca in fd.CustomAttributes)
                 {
-                    if (ca.AttributeType.FullName == Weaver.SyncVarType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.SyncVarType.FullName)
                     {
                         Log.Error("Script " + m_td.FullName + " uses [SyncVar] " + fd.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
                 }
 
-                if (Helpers.InheritsFromSyncList(fd.FieldType))
+                if (Helpers.InheritsFromSyncList(fd.FieldType, m_Weaver))
                 {
                     Log.Error(string.Format("Script {0} defines field {1} with type {2}, but it's not a NetworkBehaviour", m_td.FullName, fd.Name, Helpers.PrettyPrintType(fd.FieldType)));
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                 }
             }
         }
@@ -48,22 +50,22 @@ void ProcessMethods()
             {
                 foreach (var ca in md.CustomAttributes)
                 {
-                    if (ca.AttributeType.FullName == Weaver.CommandType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.CommandType.FullName)
                     {
                         Log.Error("Script " + m_td.FullName + " uses [Command] " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
 
-                    if (ca.AttributeType.FullName == Weaver.ClientRpcType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.ClientRpcType.FullName)
                     {
                         Log.Error("Script " + m_td.FullName + " uses [ClientRpc] " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
 
-                    if (ca.AttributeType.FullName == Weaver.TargetRpcType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.TargetRpcType.FullName)
                     {
                         Log.Error("Script " + m_td.FullName + " uses [TargetRpc] " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
 
                     var attrName = ca.Constructor.DeclaringType.ToString();
@@ -71,22 +73,22 @@ void ProcessMethods()
                     if (attrName == "UnityEngine.Networking.ServerAttribute")
                     {
                         Log.Error("Script " + m_td.FullName + " uses the attribute [Server] on the method " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
                     else if (attrName == "UnityEngine.Networking.ServerCallbackAttribute")
                     {
                         Log.Error("Script " + m_td.FullName + " uses the attribute [ServerCallback] on the method " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
                     else if (attrName == "UnityEngine.Networking.ClientAttribute")
                     {
                         Log.Error("Script " + m_td.FullName + " uses the attribute [Client] on the method " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
                     else if (attrName == "UnityEngine.Networking.ClientCallbackAttribute")
                     {
                         Log.Error("Script " + m_td.FullName + " uses the attribute [ClientCallback] on the method " + md.Name + " but is not a NetworkBehaviour.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                     }
                 }
             }
diff --git a/package/Editor/Tools/Weaver/Program.cs b/package/Editor/Tools/Weaver/Program.cs
index 934c4b736..1ab0e63aa 100755
--- a/package/Editor/Tools/Weaver/Program.cs
+++ b/package/Editor/Tools/Weaver/Program.cs
@@ -31,7 +31,8 @@ public static bool Process(string unityEngine, string unetDLL, string outputDire
             CheckAssemblies(assemblies);
             Log.WarningMethod = printWarning;
             Log.ErrorMethod = printError;
-            return Weaver.WeaveAssemblies(assemblies, extraAssemblyPaths, null, outputDirectory, unityEngine, unetDLL);
+            Weaver weaver = new Weaver();
+            return weaver.WeaveAssemblies(assemblies, extraAssemblyPaths, null, outputDirectory, unityEngine, unetDLL);
         }
 
         private static void CheckDLLPath(string path)
diff --git a/package/Editor/Tools/Weaver/SyncListStructProcessor.cs b/package/Editor/Tools/Weaver/SyncListStructProcessor.cs
index a2844adb4..81a457d55 100755
--- a/package/Editor/Tools/Weaver/SyncListStructProcessor.cs
+++ b/package/Editor/Tools/Weaver/SyncListStructProcessor.cs
@@ -8,13 +8,15 @@ class SyncListStructProcessor
     {
         TypeDefinition m_TypeDef;
         TypeReference m_ItemType;
+        Weaver m_Weaver;
         const MethodAttributes kPublicStaticHide = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
         const MethodAttributes kPublicVirtualHide = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig;
 
-        public SyncListStructProcessor(TypeDefinition typeDef)
+        public SyncListStructProcessor(TypeDefinition typeDef, Weaver weaver)
         {
-            Weaver.DLog(typeDef, "SyncListStructProcessor for " + typeDef.Name);
             m_TypeDef = typeDef;
+            m_Weaver = weaver;
+            m_Weaver.DLog(typeDef, "SyncListStructProcessor for " + typeDef.Name);
         }
 
         public void Process()
@@ -23,17 +25,17 @@ public void Process()
             var gt = (GenericInstanceType)m_TypeDef.BaseType;
             if (gt.GenericArguments.Count == 0)
             {
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 Log.Error("SyncListStructProcessor no generic args");
                 return;
             }
-            m_ItemType = Weaver.scriptDef.MainModule.ImportReference(gt.GenericArguments[0]);
+            m_ItemType = m_Weaver.m_ScriptDef.MainModule.ImportReference(gt.GenericArguments[0]);
 
-            Weaver.DLog(m_TypeDef, "SyncListStructProcessor Start item:" + m_ItemType.FullName);
+            m_Weaver.DLog(m_TypeDef, "SyncListStructProcessor Start item:" + m_ItemType.FullName);
 
-            Weaver.ResetRecursionCount();
+            m_Weaver.ResetRecursionCount();
             var writeItemFunc = GenerateSerialization();
-            if (Weaver.fail)
+            if (m_Weaver.fail)
             {
                 return;
             }
@@ -46,7 +48,7 @@ public void Process()
             GenerateReadFunc(readItemFunc);
             GenerateWriteFunc(writeItemFunc);
 
-            Weaver.DLog(m_TypeDef, "SyncListStructProcessor Done");
+            m_Weaver.DLog(m_TypeDef, "SyncListStructProcessor Done");
         }
 
         /* deserialization of entire list. generates code like:
@@ -74,24 +76,24 @@ void GenerateReadFunc(MethodReference readItemFunc)
             }
 
             // create new reader for this type
-            MethodDefinition readerFunc = new MethodDefinition(functionName, kPublicStaticHide, Weaver.voidType);
+            MethodDefinition readerFunc = new MethodDefinition(functionName, kPublicStaticHide, m_Weaver.voidType);
 
-            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkReaderType)));
+            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkReaderType)));
             readerFunc.Parameters.Add(new ParameterDefinition("instance", ParameterAttributes.None, m_TypeDef));
 
-            readerFunc.Body.Variables.Add(new VariableDefinition(Weaver.uint16Type));
-            readerFunc.Body.Variables.Add(new VariableDefinition(Weaver.uint16Type));
+            readerFunc.Body.Variables.Add(new VariableDefinition(m_Weaver.uint16Type));
+            readerFunc.Body.Variables.Add(new VariableDefinition(m_Weaver.uint16Type));
             readerFunc.Body.InitLocals = true;
 
             ILProcessor worker = readerFunc.Body.GetILProcessor();
 
             worker.Append(worker.Create(OpCodes.Ldarg_0));
-            worker.Append(worker.Create(OpCodes.Callvirt, Weaver.NetworkReadUInt16));
+            worker.Append(worker.Create(OpCodes.Callvirt, m_Weaver.NetworkReadUInt16));
             worker.Append(worker.Create(OpCodes.Stloc_0));
 
             // Call Clear() from the base class
             worker.Append(worker.Create(OpCodes.Ldarg_1));
-            MethodReference genericClearMethod = Helpers.MakeHostInstanceGeneric(Weaver.SyncListClear, m_ItemType);
+            MethodReference genericClearMethod = Helpers.MakeHostInstanceGeneric(m_Weaver.SyncListClear, m_ItemType);
             worker.Append(worker.Create(OpCodes.Callvirt, genericClearMethod));
 
             worker.Append(worker.Create(OpCodes.Ldc_I4_0));
@@ -110,7 +112,7 @@ void GenerateReadFunc(MethodReference readItemFunc)
             worker.Append(worker.Create(OpCodes.Callvirt, readItemFunc));
 
             // call the generic AddInternal from the base class
-            var addInternal = Weaver.ResolveMethod(Weaver.SyncListStructType, "AddInternal");
+            var addInternal = m_Weaver.ResolveMethod(m_Weaver.SyncListStructType, "AddInternal");
             var addInternalTyped = Helpers.MakeHostInstanceGeneric(addInternal, m_ItemType);
             worker.Append(worker.Create(OpCodes.Callvirt, addInternalTyped));
 
@@ -130,7 +132,7 @@ void GenerateReadFunc(MethodReference readItemFunc)
             //worker.Append(worker.Create(OpCodes.Ldloc_1));
             worker.Append(worker.Create(OpCodes.Ret));
 
-            Weaver.RegisterReadByReferenceFunc(m_TypeDef.FullName, readerFunc);
+            m_Weaver.RegisterReadByReferenceFunc(m_TypeDef.FullName, readerFunc);
         }
 
         /*serialization of entire list. generates code like:
@@ -158,13 +160,13 @@ void GenerateWriteFunc(MethodReference writeItemFunc)
             }
 
             // create new writer for this type
-            MethodDefinition writerFunc = new MethodDefinition(functionName, kPublicStaticHide, Weaver.voidType);
+            MethodDefinition writerFunc = new MethodDefinition(functionName, kPublicStaticHide, m_Weaver.voidType);
 
-            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkWriterType)));
-            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(m_TypeDef)));
+            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkWriterType)));
+            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_TypeDef)));
 
-            writerFunc.Body.Variables.Add(new VariableDefinition(Weaver.uint16Type));
-            writerFunc.Body.Variables.Add(new VariableDefinition(Weaver.uint16Type));
+            writerFunc.Body.Variables.Add(new VariableDefinition(m_Weaver.uint16Type));
+            writerFunc.Body.Variables.Add(new VariableDefinition(m_Weaver.uint16Type));
             writerFunc.Body.InitLocals = true;
 
             ILProcessor worker = writerFunc.Body.GetILProcessor();
@@ -172,14 +174,14 @@ void GenerateWriteFunc(MethodReference writeItemFunc)
             worker.Append(worker.Create(OpCodes.Ldarg_1));
 
             // call the generic Count from the base class
-            var getCount = Weaver.ResolveMethod(Weaver.SyncListStructType, "get_Count");
+            var getCount = m_Weaver.ResolveMethod(m_Weaver.SyncListStructType, "get_Count");
             var getCountTyped = Helpers.MakeHostInstanceGeneric(getCount, m_ItemType);
             worker.Append(worker.Create(OpCodes.Callvirt, getCountTyped));
 
             worker.Append(worker.Create(OpCodes.Stloc_0));
             worker.Append(worker.Create(OpCodes.Ldarg_0));
             worker.Append(worker.Create(OpCodes.Ldloc_0));
-            worker.Append(worker.Create(OpCodes.Callvirt, Weaver.NetworkWriteUInt16));
+            worker.Append(worker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriteUInt16));
             worker.Append(worker.Create(OpCodes.Ldc_I4_0));
             worker.Append(worker.Create(OpCodes.Stloc_1));
 
@@ -196,7 +198,7 @@ void GenerateWriteFunc(MethodReference writeItemFunc)
             worker.Append(worker.Create(OpCodes.Ldloc_1));
 
             // call the generic [] from the base class
-            var getItem = Weaver.ResolveMethod(Weaver.SyncListStructType, "GetItem");
+            var getItem = m_Weaver.ResolveMethod(m_Weaver.SyncListStructType, "GetItem");
             var getItemTyped = Helpers.MakeHostInstanceGeneric(getItem, m_ItemType);
             worker.Append(worker.Create(OpCodes.Callvirt, getItemTyped));
             worker.Append(worker.Create(OpCodes.Callvirt, writeItemFunc));
@@ -214,28 +216,28 @@ void GenerateWriteFunc(MethodReference writeItemFunc)
 
             worker.Append(worker.Create(OpCodes.Ret));
 
-            Weaver.RegisterWriteFunc(m_TypeDef.FullName, writerFunc);
+            m_Weaver.RegisterWriteFunc(m_TypeDef.FullName, writerFunc);
         }
 
         // serialization of individual element
         MethodReference GenerateSerialization()
         {
-            Weaver.DLog(m_TypeDef, "  GenerateSerialization");
+            m_Weaver.DLog(m_TypeDef, "  GenerateSerialization");
             foreach (var m in m_TypeDef.Methods)
             {
                 if (m.Name == "SerializeItem")
                     return m;
             }
 
-            MethodDefinition serializeFunc = new MethodDefinition("SerializeItem", kPublicVirtualHide, Weaver.voidType);
+            MethodDefinition serializeFunc = new MethodDefinition("SerializeItem", kPublicVirtualHide, m_Weaver.voidType);
 
-            serializeFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkWriterType)));
+            serializeFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkWriterType)));
             serializeFunc.Parameters.Add(new ParameterDefinition("item", ParameterAttributes.None, m_ItemType));
             ILProcessor serWorker = serializeFunc.Body.GetILProcessor();
 
             if (m_ItemType.IsGenericInstance)
             {
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 Log.Error("GenerateSerialization for " + Helpers.PrettyPrintType(m_ItemType) + " failed. Struct passed into SyncListStruct<T> can't have generic parameters");
                 return null;
             }
@@ -245,24 +247,24 @@ MethodReference GenerateSerialization()
                 if (field.IsStatic || field.IsPrivate || field.IsSpecialName)
                     continue;
 
-                var importedField = Weaver.scriptDef.MainModule.ImportReference(field);
+                var importedField = m_Weaver.m_ScriptDef.MainModule.ImportReference(field);
                 var ft = importedField.FieldType.Resolve();
 
                 if (ft.HasGenericParameters)
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_TypeDef.Name + " [" + ft + "/" + ft.FullName + "]. UNet [MessageBase] member cannot have generic parameters.");
                     return null;
                 }
 
                 if (ft.IsInterface)
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_TypeDef.Name + " [" + ft + "/" + ft.FullName + "]. UNet [MessageBase] member cannot be an interface.");
                     return null;
                 }
 
-                MethodReference writeFunc = Weaver.GetWriteFunc(field.FieldType);
+                MethodReference writeFunc = m_Weaver.GetWriteFunc(field.FieldType);
                 if (writeFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
@@ -272,7 +274,7 @@ MethodReference GenerateSerialization()
                 }
                 else
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_TypeDef.Name + " unknown type [" + ft + "/" + ft.FullName + "]. UNet [MessageBase] member variables must be basic types.");
                     return null;
                 }
@@ -285,7 +287,7 @@ MethodReference GenerateSerialization()
 
         MethodReference GenerateDeserialization()
         {
-            Weaver.DLog(m_TypeDef, "  GenerateDeserialization");
+            m_Weaver.DLog(m_TypeDef, "  GenerateDeserialization");
             foreach (var m in m_TypeDef.Methods)
             {
                 if (m.Name == "DeserializeItem")
@@ -294,7 +296,7 @@ MethodReference GenerateDeserialization()
 
             MethodDefinition serializeFunc = new MethodDefinition("DeserializeItem", kPublicVirtualHide, m_ItemType);
 
-            serializeFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkReaderType)));
+            serializeFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkReaderType)));
 
             ILProcessor serWorker = serializeFunc.Body.GetILProcessor();
 
@@ -311,10 +313,10 @@ MethodReference GenerateDeserialization()
                 if (field.IsStatic || field.IsPrivate || field.IsSpecialName)
                     continue;
 
-                var importedField = Weaver.scriptDef.MainModule.ImportReference(field);
+                var importedField = m_Weaver.m_ScriptDef.MainModule.ImportReference(field);
                 var ft = importedField.FieldType.Resolve();
 
-                MethodReference readerFunc = Weaver.GetReadFunc(field.FieldType);
+                MethodReference readerFunc = m_Weaver.GetReadFunc(field.FieldType);
                 if (readerFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldloca, 0));
@@ -324,7 +326,7 @@ MethodReference GenerateDeserialization()
                 }
                 else
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateDeserialization for " + m_TypeDef.Name + " unknown type [" + ft + "]. UNet [SyncVar] member variables must be basic types.");
                     return null;
                 }
diff --git a/package/Editor/Tools/Weaver/UNetBehaviourProcessor.cs b/package/Editor/Tools/Weaver/UNetBehaviourProcessor.cs
index 7977174cc..2c303b68a 100755
--- a/package/Editor/Tools/Weaver/UNetBehaviourProcessor.cs
+++ b/package/Editor/Tools/Weaver/UNetBehaviourProcessor.cs
@@ -29,6 +29,7 @@ class NetworkBehaviourProcessor
         const int k_SyncVarLimit = 32;
         int m_QosChannel;
 
+        Weaver m_Weaver;
         TypeDefinition m_td;
         int m_NetIdFieldCounter;
 
@@ -36,102 +37,103 @@ class NetworkBehaviourProcessor
         const string k_RpcPrefix = "InvokeRpc";
         const string k_TargetRpcPrefix = "InvokeTargetRpc";
 
-        public NetworkBehaviourProcessor(TypeDefinition td)
+        public NetworkBehaviourProcessor(TypeDefinition td, Weaver weaver)
         {
-            Weaver.DLog(td, "NetworkBehaviourProcessor");
             m_td = td;
+            m_Weaver = weaver;
+            m_Weaver.DLog(td, "NetworkBehaviourProcessor");
         }
 
         public void Process()
         {
             if (m_td.HasGenericParameters)
             {
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 Log.Error("NetworkBehaviour " + m_td.Name + " cannot have generic parameters");
                 return;
             }
-            Weaver.DLog(m_td, "Process Start");
+            m_Weaver.DLog(m_td, "Process Start");
             ProcessVersion();
             ProcessSyncVars();
-            Weaver.ResetRecursionCount();
+            m_Weaver.ResetRecursionCount();
 
             ProcessMethods();
 
             ProcessEvents();
-            if (Weaver.fail)
+            if (m_Weaver.fail)
             {
                 return;
             }
             GenerateNetworkSettings();
             GenerateConstants();
 
-            Weaver.ResetRecursionCount();
+            m_Weaver.ResetRecursionCount();
             GenerateSerialization();
-            if (Weaver.fail)
+            if (m_Weaver.fail)
             {
                 return;
             }
 
             GenerateDeSerialization();
             GeneratePreStartClient();
-            Weaver.DLog(m_td, "Process Done");
+            m_Weaver.DLog(m_td, "Process Done");
         }
 
-        static void WriteClientActiveCheck(ILProcessor worker, string mdName, Instruction label, string errString)
+        void WriteClientActiveCheck(ILProcessor worker, string mdName, Instruction label, string errString)
         {
             // client active check
-            worker.Append(worker.Create(OpCodes.Call, Weaver.NetworkClientGetActive));
+            worker.Append(worker.Create(OpCodes.Call, m_Weaver.NetworkClientGetActive));
             worker.Append(worker.Create(OpCodes.Brtrue, label));
 
             worker.Append(worker.Create(OpCodes.Ldstr, errString + " " + mdName + " called on server."));
-            worker.Append(worker.Create(OpCodes.Call, Weaver.logErrorReference));
+            worker.Append(worker.Create(OpCodes.Call, m_Weaver.logErrorReference));
             worker.Append(worker.Create(OpCodes.Ret));
             worker.Append(label);
         }
 
-        static void WriteServerActiveCheck(ILProcessor worker, string mdName, Instruction label, string errString)
+        void WriteServerActiveCheck(ILProcessor worker, string mdName, Instruction label, string errString)
         {
             // server active check
-            worker.Append(worker.Create(OpCodes.Call, Weaver.NetworkServerGetActive));
+            worker.Append(worker.Create(OpCodes.Call, m_Weaver.NetworkServerGetActive));
             worker.Append(worker.Create(OpCodes.Brtrue, label));
 
             worker.Append(worker.Create(OpCodes.Ldstr, errString + " " + mdName + " called on client."));
-            worker.Append(worker.Create(OpCodes.Call, Weaver.logErrorReference));
+            worker.Append(worker.Create(OpCodes.Call, m_Weaver.logErrorReference));
             worker.Append(worker.Create(OpCodes.Ret));
             worker.Append(label);
         }
 
-        static void WriteSetupLocals(ILProcessor worker)
+        void WriteSetupLocals(ILProcessor worker)
         {
             worker.Body.InitLocals = true;
-            worker.Body.Variables.Add(new VariableDefinition(Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkWriterType)));
+            worker.Body.Variables.Add(new VariableDefinition(m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkWriterType)));
         }
 
-        static void WriteCreateWriter(ILProcessor worker)
+        void WriteCreateWriter(ILProcessor worker)
         {
             // create writer
-            worker.Append(worker.Create(OpCodes.Newobj, Weaver.NetworkWriterCtor));
+            worker.Append(worker.Create(OpCodes.Newobj, m_Weaver.NetworkWriterCtor));
             worker.Append(worker.Create(OpCodes.Stloc_0));
             worker.Append(worker.Create(OpCodes.Ldloc_0));
         }
 
-        static void WriteMessageSize(ILProcessor worker)
+        void WriteMessageSize(ILProcessor worker)
         {
             //write size
             worker.Append(worker.Create(OpCodes.Ldc_I4_0));
-            worker.Append(worker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWriteInt16));
+            worker.Append(worker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWriteInt16));
         }
 
-        static void WriteMessageId(ILProcessor worker, int msgId)
+        void WriteMessageId(ILProcessor worker, int msgId)
         {
             // write msg id
             worker.Append(worker.Create(OpCodes.Ldloc_0));
             worker.Append(worker.Create(OpCodes.Ldc_I4, msgId));
             worker.Append(worker.Create(OpCodes.Conv_U2));
-            worker.Append(worker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWriteInt16));
+            worker.Append(worker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWriteInt16));
         }
 
-        static bool WriteArguments(ILProcessor worker, MethodDefinition md, string errString, bool skipFirst)
+        bool WriteArguments(ILProcessor worker, MethodDefinition md, string errString, bool skipFirst)
         {
             // write each argument
             short argNum = 1;
@@ -143,11 +145,11 @@ static bool WriteArguments(ILProcessor worker, MethodDefinition md, string errSt
                     continue;
                 }
 
-                MethodReference writeFunc = Weaver.GetWriteFunc(pd.ParameterType);
+                MethodReference writeFunc = m_Weaver.GetWriteFunc(pd.ParameterType);
                 if (writeFunc == null)
                 {
                     Log.Error("WriteArguments for " + md.Name + " type " + pd.ParameterType + " not supported");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
                 // use built-in writer func on writer object
@@ -169,7 +171,7 @@ void ProcessVersion()
                 }
             }
 
-            MethodDefinition versionMethod = new MethodDefinition("UNetVersion", MethodAttributes.Private, Weaver.voidType);
+            MethodDefinition versionMethod = new MethodDefinition("UNetVersion", MethodAttributes.Private, m_Weaver.voidType);
             ILProcessor worker = versionMethod.Body.GetILProcessor();
             worker.Append(worker.Create(OpCodes.Ret));
             m_td.Methods.Add(versionMethod);
@@ -180,7 +182,7 @@ void GenerateConstants()
             if (m_Cmds.Count == 0 && m_Rpcs.Count == 0 && m_TargetRpcs.Count == 0 && m_Events.Count == 0 && m_SyncLists.Count == 0)
                 return;
 
-            Weaver.DLog(m_td, "  GenerateConstants ");
+            m_Weaver.DLog(m_td, "  GenerateConstants ");
 
             // find static constructor
             MethodDefinition cctor = null;
@@ -206,7 +208,7 @@ void GenerateConstants()
                     else
                     {
                         Log.Error("No cctor for " + m_td.Name);
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         return;
                     }
                 }
@@ -219,7 +221,7 @@ void GenerateConstants()
                     MethodAttributes.SpecialName |
                     MethodAttributes.RTSpecialName |
                     MethodAttributes.Static,
-                    Weaver.voidType);
+                    m_Weaver.voidType);
             }
 
             // find instance constructor
@@ -238,7 +240,7 @@ void GenerateConstants()
                     }
                     else
                     {
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         Log.Error("No ctor for " + m_td.Name);
                         return;
                     }
@@ -249,7 +251,7 @@ void GenerateConstants()
 
             if (ctor == null)
             {
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 Log.Error("No ctor for " + m_td.Name);
                 return;
             }
@@ -260,73 +262,73 @@ void GenerateConstants()
             int cmdIndex = 0;
             foreach (MethodDefinition md in m_Cmds)
             {
-                FieldReference cmdConstant = Weaver.ResolveField(m_td, "kCmd" + md.Name);
+                FieldReference cmdConstant = m_Weaver.ResolveField(m_td, "kCmd" + md.Name);
 
                 int cmdHash = GetHashCode(m_td.Name + ":Cmd:" + md.Name);
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Ldc_I4, cmdHash));
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Stsfld, cmdConstant));
-                //Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Cmd:" + md.Name);
+                //m_Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Cmd:" + md.Name);
 
-                GenerateCommandDelegate(cctorWorker, Weaver.registerCommandDelegateReference, m_CmdInvocationFuncs[cmdIndex], cmdConstant);
+                GenerateCommandDelegate(cctorWorker, m_Weaver.registerCommandDelegateReference, m_CmdInvocationFuncs[cmdIndex], cmdConstant);
                 cmdIndex += 1;
             }
 
             int rpcIndex = 0;
             foreach (MethodDefinition md in m_Rpcs)
             {
-                FieldReference rpcConstant = Weaver.ResolveField(m_td, "kRpc" + md.Name);
+                FieldReference rpcConstant = m_Weaver.ResolveField(m_td, "kRpc" + md.Name);
 
                 int rpcHash = GetHashCode(m_td.Name + ":Rpc:" + md.Name);
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Ldc_I4, rpcHash));
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Stsfld, rpcConstant));
-                //Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Rpc:" + md.Name);
+                //m_Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Rpc:" + md.Name);
 
-                GenerateCommandDelegate(cctorWorker, Weaver.registerRpcDelegateReference, m_RpcInvocationFuncs[rpcIndex], rpcConstant);
+                GenerateCommandDelegate(cctorWorker, m_Weaver.registerRpcDelegateReference, m_RpcInvocationFuncs[rpcIndex], rpcConstant);
                 rpcIndex += 1;
             }
 
             int targetRpcIndex = 0;
             foreach (MethodDefinition md in m_TargetRpcs)
             {
-                FieldReference targetRpcConstant = Weaver.ResolveField(m_td, "kTargetRpc" + md.Name);
+                FieldReference targetRpcConstant = m_Weaver.ResolveField(m_td, "kTargetRpc" + md.Name);
 
                 int targetRpcHash = GetHashCode(m_td.Name + ":TargetRpc:" + md.Name);
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Ldc_I4, targetRpcHash));
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Stsfld, targetRpcConstant));
-                //Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Rpc:" + md.Name);
+                //m_Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Rpc:" + md.Name);
 
-                GenerateCommandDelegate(cctorWorker, Weaver.registerRpcDelegateReference, m_TargetRpcInvocationFuncs[targetRpcIndex], targetRpcConstant);
+                GenerateCommandDelegate(cctorWorker, m_Weaver.registerRpcDelegateReference, m_TargetRpcInvocationFuncs[targetRpcIndex], targetRpcConstant);
                 targetRpcIndex += 1;
             }
 
             int eventIndex = 0;
             foreach (EventDefinition ed in m_Events)
             {
-                FieldReference eventConstant = Weaver.ResolveField(m_td, "kEvent" + ed.Name);
+                FieldReference eventConstant = m_Weaver.ResolveField(m_td, "kEvent" + ed.Name);
 
                 int eventHash = GetHashCode(m_td.Name + ":Event:" + ed.Name);
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Ldc_I4, eventHash));
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Stsfld, eventConstant));
-                //Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Event:" + ed.Name);
+                //m_Weaver.DLog(m_td, "    Constant " + m_td.Name + ":Event:" + ed.Name);
 
-                GenerateCommandDelegate(cctorWorker, Weaver.registerEventDelegateReference, m_EventInvocationFuncs[eventIndex], eventConstant);
+                GenerateCommandDelegate(cctorWorker, m_Weaver.registerEventDelegateReference, m_EventInvocationFuncs[eventIndex], eventConstant);
                 eventIndex += 1;
             }
 
             int syncListIndex = 0;
             foreach (FieldDefinition fd in m_SyncLists)
             {
-                FieldReference listConstant = Weaver.ResolveField(m_td, "kList" + fd.Name);
+                FieldReference listConstant = m_Weaver.ResolveField(m_td, "kList" + fd.Name);
 
                 int listHash = GetHashCode(m_td.Name + ":List:" + fd.Name);
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Ldc_I4, listHash));
                 cctorWorker.Append(cctorWorker.Create(OpCodes.Stsfld, listConstant));
-                //Weaver.DLog(m_td, "    Constant " + m_td.Name + ":List:" + fd.Name);
+                //m_Weaver.DLog(m_td, "    Constant " + m_td.Name + ":List:" + fd.Name);
 
 
                 GenerateSyncListInstanceInitializer(ctorWorker, fd);
 
-                GenerateCommandDelegate(cctorWorker, Weaver.registerSyncListDelegateReference, m_SyncListInvocationFuncs[syncListIndex], listConstant);
+                GenerateCommandDelegate(cctorWorker, m_Weaver.registerSyncListDelegateReference, m_SyncListInvocationFuncs[syncListIndex], listConstant);
                 syncListIndex += 1;
             }
 
@@ -334,7 +336,7 @@ void GenerateConstants()
             // "NetworkCRC.RegisterBehaviour('MyScript', 2);"
             cctorWorker.Append(cctorWorker.Create(OpCodes.Ldstr, m_td.Name));
             cctorWorker.Append(cctorWorker.Create(OpCodes.Ldc_I4, m_QosChannel));
-            cctorWorker.Append(cctorWorker.Create(OpCodes.Call, Weaver.RegisterBehaviourReference));
+            cctorWorker.Append(cctorWorker.Create(OpCodes.Call, m_Weaver.RegisterBehaviourReference));
 
             cctorWorker.Append(cctorWorker.Create(OpCodes.Ret));
             if (!cctorFound)
@@ -375,14 +377,14 @@ void GenerateConstants()
                     else
                     {
                         Log.Error("No awake for " + m_td.Name);
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         return;
                     }
                 }
             }
             else
             {
-                awake = new MethodDefinition("Awake", MethodAttributes.Private, Weaver.voidType);
+                awake = new MethodDefinition("Awake", MethodAttributes.Private, m_Weaver.voidType);
             }
 
             ILProcessor awakeWorker = awake.Body.GetILProcessor();
@@ -413,7 +415,7 @@ void CheckForCustomBaseClassAwakeMethod(ILProcessor awakeWorker)
             var t = m_td.BaseType;
 
             // as long as basetype is not NetworkBehaviour
-            while (t.FullName != Weaver.NetworkBehaviourType.FullName)
+            while (t.FullName != m_Weaver.NetworkBehaviourType.FullName)
             {
                 // check for the first Awake() method in the hierarchy
                 var awake = t.Resolve().Methods.FirstOrDefault<MethodDefinition>(x => x.Name == "Awake" && !x.HasParameters);
@@ -447,7 +449,7 @@ void GenerateSyncListInstanceInitializer(ILProcessor ctorWorker, FieldDefinition
 
             // Not initialized by the user in the field definition, e.g:
             // public SyncListInt Foo;
-            var listCtor = Weaver.scriptDef.MainModule.ImportReference(fd.FieldType.Resolve().Methods.First<MethodDefinition>(x => x.Name == ".ctor" && !x.HasParameters));
+            var listCtor = m_Weaver.m_ScriptDef.MainModule.ImportReference(fd.FieldType.Resolve().Methods.First<MethodDefinition>(x => x.Name == ".ctor" && !x.HasParameters));
 
             ctorWorker.Append(ctorWorker.Create(OpCodes.Ldarg_0));
             ctorWorker.Append(ctorWorker.Create(OpCodes.Newobj, listCtor));
@@ -461,12 +463,12 @@ void GenerateSyncListInstanceInitializer(ILProcessor ctorWorker, FieldDefinition
         void GenerateCommandDelegate(ILProcessor awakeWorker, MethodReference registerMethod, MethodDefinition func, FieldReference field)
         {
             awakeWorker.Append(awakeWorker.Create(OpCodes.Ldtoken, m_td));
-            awakeWorker.Append(awakeWorker.Create(OpCodes.Call, Weaver.getTypeFromHandleReference));
+            awakeWorker.Append(awakeWorker.Create(OpCodes.Call, m_Weaver.getTypeFromHandleReference));
             awakeWorker.Append(awakeWorker.Create(OpCodes.Ldsfld, field));
             awakeWorker.Append(awakeWorker.Create(OpCodes.Ldnull));
             awakeWorker.Append(awakeWorker.Create(OpCodes.Ldftn, func));
 
-            awakeWorker.Append(awakeWorker.Create(OpCodes.Newobj, Weaver.CmdDelegateConstructor));
+            awakeWorker.Append(awakeWorker.Create(OpCodes.Newobj, m_Weaver.CmdDelegateConstructor));
             awakeWorker.Append(awakeWorker.Create(OpCodes.Call, registerMethod));
         }
 
@@ -482,18 +484,18 @@ void GenerateSyncListInitializer(ILProcessor awakeWorker, FieldReference fd, int
             awakeWorker.Append(awakeWorker.Create(OpCodes.Ldsfld, m_SyncListStaticFields[index]));
 
             GenericInstanceType syncListGeneric = (GenericInstanceType)fd.FieldType.Resolve().BaseType;
-            syncListGeneric = (GenericInstanceType)Weaver.scriptDef.MainModule.ImportReference(syncListGeneric);
+            syncListGeneric = (GenericInstanceType)m_Weaver.m_ScriptDef.MainModule.ImportReference(syncListGeneric);
 
             TypeReference listValueType = syncListGeneric.GenericArguments[0];
-            MethodReference genericInitBehaviourMethod = Helpers.MakeHostInstanceGeneric(Weaver.SyncListInitBehaviourReference, listValueType);
+            MethodReference genericInitBehaviourMethod = Helpers.MakeHostInstanceGeneric(m_Weaver.SyncListInitBehaviourReference, listValueType);
             awakeWorker.Append(awakeWorker.Create(OpCodes.Callvirt, genericInitBehaviourMethod));
 
-            Weaver.scriptDef.MainModule.ImportReference(genericInitBehaviourMethod);
+            m_Weaver.m_ScriptDef.MainModule.ImportReference(genericInitBehaviourMethod);
         }
 
         void GenerateSerialization()
         {
-            Weaver.DLog(m_td, "  GenerateSerialization");
+            m_Weaver.DLog(m_td, "  GenerateSerialization");
 
             foreach (var m in m_td.Methods)
             {
@@ -504,26 +506,26 @@ void GenerateSerialization()
             MethodDefinition serialize = new MethodDefinition("OnSerialize", MethodAttributes.Public |
                 MethodAttributes.Virtual |
                 MethodAttributes.HideBySig,
-                Weaver.boolType);
+                m_Weaver.boolType);
 
-            serialize.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkWriterType)));
-            serialize.Parameters.Add(new ParameterDefinition("forceAll", ParameterAttributes.None, Weaver.boolType));
+            serialize.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkWriterType)));
+            serialize.Parameters.Add(new ParameterDefinition("forceAll", ParameterAttributes.None, m_Weaver.boolType));
             ILProcessor serWorker = serialize.Body.GetILProcessor();
 
 
             serialize.Body.InitLocals = true;
-            VariableDefinition dirtyLocal = new VariableDefinition(Weaver.boolType);
+            VariableDefinition dirtyLocal = new VariableDefinition(m_Weaver.boolType);
 
             serialize.Body.Variables.Add(dirtyLocal);
 
             // call base class
             bool baseClassSerialize = false;
-            if (m_td.BaseType.FullName != Weaver.NetworkBehaviourType.FullName)
+            if (m_td.BaseType.FullName != m_Weaver.NetworkBehaviourType.FullName)
             {
-                MethodReference baseSerialize = Weaver.ResolveMethod(m_td.BaseType, "OnSerialize");
+                MethodReference baseSerialize = m_Weaver.ResolveMethod(m_td.BaseType, "OnSerialize");
                 if (baseSerialize != null)
                 {
-                    VariableDefinition baseResult = new VariableDefinition(Weaver.boolType);
+                    VariableDefinition baseResult = new VariableDefinition(m_Weaver.boolType);
                     serialize.Body.Variables.Add(baseResult);
 
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0)); // base
@@ -562,14 +564,14 @@ void GenerateSerialization()
                 serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
                 serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
                 serWorker.Append(serWorker.Create(OpCodes.Ldfld, syncVar));
-                MethodReference writeFunc = Weaver.GetWriteFunc(syncVar.FieldType);
+                MethodReference writeFunc = m_Weaver.GetWriteFunc(syncVar.FieldType);
                 if (writeFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Call, writeFunc));
                 }
                 else
                 {
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     Log.Error("GenerateSerialization for " + m_td.Name + " unknown type [" + syncVar.FieldType + "]. UNet [SyncVar] member variables must be basic types.");
                     return;
                 }
@@ -586,13 +588,13 @@ void GenerateSerialization()
             serWorker.Append(serWorker.Create(OpCodes.Stloc_0));
 
             // write syncvars
-            int dirtyBit = Weaver.GetSyncVarStart(m_td.BaseType.FullName); // start at number of syncvars in parent
+            int dirtyBit = m_Weaver.GetSyncVarStart(m_td.BaseType.FullName); // start at number of syncvars in parent
             foreach (FieldDefinition syncVar in m_SyncVars)
             {
                 Instruction varLabel = serWorker.Create(OpCodes.Nop);
 
                 serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
-                serWorker.Append(serWorker.Create(OpCodes.Call, Weaver.NetworkBehaviourDirtyBitsReference));
+                serWorker.Append(serWorker.Create(OpCodes.Call, m_Weaver.NetworkBehaviourDirtyBitsReference));
                 serWorker.Append(serWorker.Create(OpCodes.Ldc_I4, 1 << dirtyBit));
                 serWorker.Append(serWorker.Create(OpCodes.And));
                 serWorker.Append(serWorker.Create(OpCodes.Brfalse, varLabel));
@@ -603,7 +605,7 @@ void GenerateSerialization()
                 serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
                 serWorker.Append(serWorker.Create(OpCodes.Ldfld, syncVar));
 
-                MethodReference writeFunc = Weaver.GetWriteFunc(syncVar.FieldType);
+                MethodReference writeFunc = m_Weaver.GetWriteFunc(syncVar.FieldType);
                 if (writeFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Call, writeFunc));
@@ -611,7 +613,7 @@ void GenerateSerialization()
                 else
                 {
                     Log.Error("GenerateSerialization for " + m_td.Name + " unknown type [" + syncVar.FieldType + "]. UNet [SyncVar] member variables must be basic types.");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return;
                 }
                 serWorker.Append(varLabel);
@@ -620,10 +622,10 @@ void GenerateSerialization()
 
             WriteDirtyCheck(serWorker, false);
 
-            if (Weaver.generateLogErrors)
+            if (m_Weaver.generateLogErrors)
             {
                 serWorker.Append(serWorker.Create(OpCodes.Ldstr, "Injected Serialize " + m_td.Name));
-                serWorker.Append(serWorker.Create(OpCodes.Call, Weaver.logErrorReference));
+                serWorker.Append(serWorker.Create(OpCodes.Call, m_Weaver.logErrorReference));
             }
 
             if (baseClassSerialize)
@@ -640,9 +642,9 @@ void GenerateSerialization()
             m_td.Methods.Add(serialize);
         }
 
-        static void WriteDirtyCheck(ILProcessor serWorker, bool reset)
+        void WriteDirtyCheck(ILProcessor serWorker, bool reset)
         {
-            //Weaver.DLog(m_td, "    GenerateSerialization dirtyCheck");
+            //m_Weaver.DLog(m_td, "    GenerateSerialization dirtyCheck");
 
             // Generates: if (!dirty) { write dirty bits, set dirty bool }
             Instruction dirtyLabel = serWorker.Create(OpCodes.Nop);
@@ -653,8 +655,8 @@ static void WriteDirtyCheck(ILProcessor serWorker, bool reset)
             // write dirty bits
             serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
             serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
-            serWorker.Append(serWorker.Create(OpCodes.Call, Weaver.NetworkBehaviourDirtyBitsReference));
-            serWorker.Append(serWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWritePacked32));
+            serWorker.Append(serWorker.Create(OpCodes.Call, m_Weaver.NetworkBehaviourDirtyBitsReference));
+            serWorker.Append(serWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWritePacked32));
             if (reset)
             {
                 serWorker.Append(serWorker.Create(OpCodes.Ldc_I4_1));
@@ -665,12 +667,12 @@ static void WriteDirtyCheck(ILProcessor serWorker, bool reset)
             serWorker.Append(dirtyLabel);
         }
 
-        static int GetChannelId(FieldDefinition field)
+        int GetChannelId(FieldDefinition field)
         {
             int channel = 0;
             foreach (var ca in field.CustomAttributes)
             {
-                if (ca.AttributeType.FullName == Weaver.SyncVarType.FullName)
+                if (ca.AttributeType.FullName == m_Weaver.SyncVarType.FullName)
                 {
                     foreach (CustomAttributeNamedArgument customField in ca.Fields)
                     {
@@ -691,7 +693,7 @@ bool CheckForHookFunction(FieldDefinition syncVar, out MethodDefinition foundMet
             foundMethod = null;
             foreach (var ca in syncVar.CustomAttributes)
             {
-                if (ca.AttributeType.FullName == Weaver.SyncVarType.FullName)
+                if (ca.AttributeType.FullName == m_Weaver.SyncVarType.FullName)
                 {
                     foreach (CustomAttributeNamedArgument customField in ca.Fields)
                     {
@@ -708,19 +710,19 @@ bool CheckForHookFunction(FieldDefinition syncVar, out MethodDefinition foundMet
                                         if (m.Parameters[0].ParameterType != syncVar.FieldType)
                                         {
                                             Log.Error("SyncVar Hook function " + hookFunctionName + " has wrong type signature for " + m_td.Name);
-                                            Weaver.fail = true;
+                                            m_Weaver.fail = true;
                                             return false;
                                         }
                                         foundMethod = m;
                                         return true;
                                     }
                                     Log.Error("SyncVar Hook function " + hookFunctionName + " must have one argument " + m_td.Name);
-                                    Weaver.fail = true;
+                                    m_Weaver.fail = true;
                                     return false;
                                 }
                             }
                             Log.Error("SyncVar Hook function " + hookFunctionName + " not found for " + m_td.Name);
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return false;
                         }
                     }
@@ -734,7 +736,7 @@ void GenerateNetworkChannelSetting(int channel)
             MethodDefinition meth = new MethodDefinition("GetNetworkChannel", MethodAttributes.Public |
                 MethodAttributes.Virtual |
                 MethodAttributes.HideBySig,
-                Weaver.int32Type);
+                m_Weaver.int32Type);
 
             ILProcessor worker = meth.Body.GetILProcessor();
 
@@ -748,7 +750,7 @@ void GenerateNetworkIntervalSetting(float interval)
             MethodDefinition meth = new MethodDefinition("GetNetworkSendInterval", MethodAttributes.Public |
                 MethodAttributes.Virtual |
                 MethodAttributes.HideBySig,
-                Weaver.singleType);
+                m_Weaver.singleType);
 
             ILProcessor worker = meth.Body.GetILProcessor();
 
@@ -762,7 +764,7 @@ void GenerateNetworkSettings()
             // look for custom attribute
             foreach (var ca in m_td.CustomAttributes)
             {
-                if (ca.AttributeType.FullName == Weaver.NetworkSettingsType.FullName)
+                if (ca.AttributeType.FullName == m_Weaver.NetworkSettingsType.FullName)
                 {
                     // generate virtual functions
                     foreach (var field in ca.Fields)
@@ -777,7 +779,7 @@ void GenerateNetworkSettings()
                             {
                                 Log.Error(
                                     "GetNetworkChannel, is already implemented, please make sure you either use NetworkSettings or GetNetworkChannel");
-                                Weaver.fail = true;
+                                m_Weaver.fail = true;
                                 return;
                             }
                             m_QosChannel = (int)field.Argument.Value;
@@ -795,7 +797,7 @@ void GenerateNetworkSettings()
                             {
                                 Log.Error(
                                     "GetNetworkSendInterval, is already implemented, please make sure you either use NetworkSettings or GetNetworkSendInterval");
-                                Weaver.fail = true;
+                                m_Weaver.fail = true;
                                 return;
                             }
                             GenerateNetworkIntervalSetting((float)field.Argument.Value);
@@ -817,20 +819,33 @@ void GeneratePreStartClient()
                     return;
             }
 
-            foreach (FieldDefinition syncVar in m_SyncVars)
+            preStartMethod = new MethodDefinition("PreStartClient", MethodAttributes.Public |
+                MethodAttributes.Virtual |
+                MethodAttributes.HideBySig,
+                m_Weaver.voidType);
+            serWorker = preStartMethod.Body.GetILProcessor();
+            //Add base class
+            if (m_td.BaseType.FullName != m_Weaver.NetworkBehaviourType.FullName)
             {
-                if (syncVar.FieldType.FullName == Weaver.gameObjectType.FullName)
+                MethodReference basePreStartMethod = m_Weaver.ResolveMethod(m_td.BaseType, "PreStartClient");
+                if (basePreStartMethod != null)
                 {
-                    if (preStartMethod == null)
-                    {
-                        preStartMethod = new MethodDefinition("PreStartClient", MethodAttributes.Public |
-                            MethodAttributes.Virtual |
-                            MethodAttributes.HideBySig,
-                            Weaver.voidType);
+                    serWorker.Append(serWorker.Create(OpCodes.Ldarg_0)); // base
 
-                        serWorker = preStartMethod.Body.GetILProcessor();
-                    }
+                    serWorker.Append(serWorker.Create(OpCodes.Call, basePreStartMethod));
+                }
+            }
+            if (m_SyncVars.Count == 0)
+            {
+                serWorker.Append(serWorker.Create(OpCodes.Ret));
+                m_td.Methods.Add(preStartMethod);
+                return;
+            }
 
+            foreach (FieldDefinition syncVar in m_SyncVars)
+            {
+                if (syncVar.FieldType.FullName == m_Weaver.gameObjectType.FullName)
+                {
                     FieldDefinition netIdField = m_SyncVarNetIds[m_NetIdFieldCounter];
                     m_NetIdFieldCounter += 1;
 
@@ -838,13 +853,13 @@ void GeneratePreStartClient()
                     Instruction nullLabel = serWorker.Create(OpCodes.Nop);
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
                     serWorker.Append(serWorker.Create(OpCodes.Ldflda, netIdField));
-                    serWorker.Append(serWorker.Create(OpCodes.Call, Weaver.NetworkInstanceIsEmpty));
+                    serWorker.Append(serWorker.Create(OpCodes.Call, m_Weaver.NetworkInstanceIsEmpty));
                     serWorker.Append(serWorker.Create(OpCodes.Brtrue, nullLabel));
 
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
                     serWorker.Append(serWorker.Create(OpCodes.Ldfld, netIdField));
-                    serWorker.Append(serWorker.Create(OpCodes.Call, Weaver.FindLocalObjectReference));
+                    serWorker.Append(serWorker.Create(OpCodes.Call, m_Weaver.FindLocalObjectReference));
 
                     // return value of FindLocalObjectReference is on stack, assign it to the syncvar
                     serWorker.Append(serWorker.Create(OpCodes.Stfld, syncVar));
@@ -862,7 +877,7 @@ void GeneratePreStartClient()
 
         void GenerateDeSerialization()
         {
-            Weaver.DLog(m_td, "  GenerateDeSerialization");
+            m_Weaver.DLog(m_td, "  GenerateDeSerialization");
             m_NetIdFieldCounter  = 0;
 
             foreach (var m in m_td.Methods)
@@ -874,16 +889,16 @@ void GenerateDeSerialization()
             MethodDefinition serialize = new MethodDefinition("OnDeserialize", MethodAttributes.Public |
                 MethodAttributes.Virtual |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
-            serialize.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkReaderType)));
-            serialize.Parameters.Add(new ParameterDefinition("initialState", ParameterAttributes.None, Weaver.boolType));
+            serialize.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkReaderType)));
+            serialize.Parameters.Add(new ParameterDefinition("initialState", ParameterAttributes.None, m_Weaver.boolType));
             ILProcessor serWorker = serialize.Body.GetILProcessor();
 
             // call base class
-            if (m_td.BaseType.FullName != Weaver.NetworkBehaviourType.FullName)
+            if (m_td.BaseType.FullName != m_Weaver.NetworkBehaviourType.FullName)
             {
-                MethodReference baseDeserialize = Weaver.ResolveMethod(m_td.BaseType, "OnDeserialize");
+                MethodReference baseDeserialize = m_Weaver.ResolveMethod(m_td.BaseType, "OnDeserialize");
                 if (baseDeserialize != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0)); // base
@@ -908,7 +923,7 @@ void GenerateDeSerialization()
 
             foreach (var syncVar in m_SyncVars)
             {
-                MethodReference readByReferenceFunc = Weaver.GetReadByReferenceFunc(syncVar.FieldType);
+                MethodReference readByReferenceFunc = m_Weaver.GetReadByReferenceFunc(syncVar.FieldType);
                 if (readByReferenceFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
@@ -922,18 +937,18 @@ void GenerateDeSerialization()
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_0));
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
 
-                    if (syncVar.FieldType.FullName == Weaver.gameObjectType.FullName)
+                    if (syncVar.FieldType.FullName == m_Weaver.gameObjectType.FullName)
                     {
                         // GameObject SyncVar - assign to generated netId var
                         FieldDefinition netIdField = m_SyncVarNetIds[m_NetIdFieldCounter];
                         m_NetIdFieldCounter += 1;
 
-                        serWorker.Append(serWorker.Create(OpCodes.Callvirt, Weaver.NetworkReaderReadNetworkInstanceId));
+                        serWorker.Append(serWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkReaderReadNetworkInstanceId));
                         serWorker.Append(serWorker.Create(OpCodes.Stfld, netIdField));
                     }
                     else
                     {
-                        MethodReference readFunc = Weaver.GetReadFunc(syncVar.FieldType);
+                        MethodReference readFunc = m_Weaver.GetReadFunc(syncVar.FieldType);
                         if (readFunc != null)
                         {
                             serWorker.Append(serWorker.Create(OpCodes.Call, readFunc));
@@ -941,7 +956,7 @@ void GenerateDeSerialization()
                         else
                         {
                             Log.Error("GenerateDeSerialization for " + m_td.Name + " unknown type [" + syncVar.FieldType + "]. UNet [SyncVar] member variables must be basic types.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
                         serWorker.Append(serWorker.Create(OpCodes.Stfld, syncVar));
@@ -957,16 +972,16 @@ void GenerateDeSerialization()
 
             // setup local for dirty bits
             serialize.Body.InitLocals = true;
-            VariableDefinition dirtyBitsLocal = new VariableDefinition(Weaver.int32Type);
+            VariableDefinition dirtyBitsLocal = new VariableDefinition(m_Weaver.int32Type);
             serialize.Body.Variables.Add(dirtyBitsLocal);
 
             // get dirty bits
             serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
-            serWorker.Append(serWorker.Create(OpCodes.Callvirt, Weaver.NetworkReaderReadPacked32));
+            serWorker.Append(serWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkReaderReadPacked32));
             serWorker.Append(serWorker.Create(OpCodes.Stloc_0));
 
             // conditionally read each syncvar
-            int dirtyBit = Weaver.GetSyncVarStart(m_td.BaseType.FullName); // start at number of syncvars in parent
+            int dirtyBit = m_Weaver.GetSyncVarStart(m_td.BaseType.FullName); // start at number of syncvars in parent
             foreach (FieldDefinition syncVar in m_SyncVars)
             {
                 Instruction varLabel = serWorker.Create(OpCodes.Nop);
@@ -977,7 +992,7 @@ void GenerateDeSerialization()
                 serWorker.Append(serWorker.Create(OpCodes.And));
                 serWorker.Append(serWorker.Create(OpCodes.Brfalse, varLabel));
 
-                MethodReference readByReferenceFunc = Weaver.GetReadByReferenceFunc(syncVar.FieldType);
+                MethodReference readByReferenceFunc = m_Weaver.GetReadByReferenceFunc(syncVar.FieldType);
                 if (readByReferenceFunc != null)
                 {
                     serWorker.Append(serWorker.Create(OpCodes.Ldarg_1));
@@ -987,11 +1002,11 @@ void GenerateDeSerialization()
                 }
                 else
                 {
-                    MethodReference readFunc = Weaver.GetReadFunc(syncVar.FieldType);
+                    MethodReference readFunc = m_Weaver.GetReadFunc(syncVar.FieldType);
                     if (readFunc == null)
                     {
                         Log.Error("GenerateDeSerialization for " + m_td.Name + " unknown type [" + syncVar.FieldType + "]. UNet [SyncVar] member variables must be basic types.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         return;
                     }
 
@@ -1023,10 +1038,10 @@ void GenerateDeSerialization()
                 dirtyBit += 1;
             }
 
-            if (Weaver.generateLogErrors)
+            if (m_Weaver.generateLogErrors)
             {
                 serWorker.Append(serWorker.Create(OpCodes.Ldstr, "Injected Deserialize " + m_td.Name));
-                serWorker.Append(serWorker.Create(OpCodes.Call, Weaver.logErrorReference));
+                serWorker.Append(serWorker.Create(OpCodes.Call, m_Weaver.logErrorReference));
             }
 
             serWorker.Append(serWorker.Create(OpCodes.Ret));
@@ -1044,7 +1059,7 @@ bool ProcessNetworkReaderParameters(MethodDefinition md, ILProcessor worker, boo
                 {
                     continue;
                 }
-                MethodReference readFunc = Weaver.GetReadFunc(arg.ParameterType); //?
+                MethodReference readFunc = m_Weaver.GetReadFunc(arg.ParameterType); //?
 
                 if (readFunc != null)
                 {
@@ -1052,11 +1067,11 @@ bool ProcessNetworkReaderParameters(MethodDefinition md, ILProcessor worker, boo
                     worker.Append(worker.Create(OpCodes.Call, readFunc));
 
                     // conversion.. is this needed?
-                    if (arg.ParameterType.FullName == Weaver.singleType.FullName)
+                    if (arg.ParameterType.FullName == m_Weaver.singleType.FullName)
                     {
                         worker.Append(worker.Create(OpCodes.Conv_R4));
                     }
-                    else if (arg.ParameterType.FullName == Weaver.doubleType.FullName)
+                    else if (arg.ParameterType.FullName == m_Weaver.doubleType.FullName)
                     {
                         worker.Append(worker.Create(OpCodes.Conv_R8));
                     }
@@ -1064,7 +1079,7 @@ bool ProcessNetworkReaderParameters(MethodDefinition md, ILProcessor worker, boo
                 else
                 {
                     Log.Error("ProcessNetworkReaderParameters for " + m_td.Name + ":" + md.Name + " type " + arg.ParameterType + " not supported");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
             }
@@ -1087,7 +1102,7 @@ MethodDefinition ProcessCommandInvoke(MethodDefinition md)
             MethodDefinition cmd = new MethodDefinition(k_CmdPrefix + md.Name, MethodAttributes.Family |
                 MethodAttributes.Static |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             ILProcessor cmdWorker = cmd.Body.GetILProcessor();
             Instruction label = cmdWorker.Create(OpCodes.Nop);
@@ -1110,10 +1125,10 @@ MethodDefinition ProcessCommandInvoke(MethodDefinition md)
             return cmd;
         }
 
-        static void AddInvokeParameters(ICollection<ParameterDefinition> collection)
+        void AddInvokeParameters(ICollection<ParameterDefinition> collection)
         {
-            collection.Add(new ParameterDefinition("obj", ParameterAttributes.None, Weaver.NetworkBehaviourType2));
-            collection.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.scriptDef.MainModule.ImportReference(Weaver.NetworkReaderType)));
+            collection.Add(new ParameterDefinition("obj", ParameterAttributes.None, m_Weaver.NetworkBehaviourType2));
+            collection.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_Weaver.m_ScriptDef.MainModule.ImportReference(m_Weaver.NetworkReaderType)));
         }
 
         /*
@@ -1148,7 +1163,7 @@ MethodDefinition ProcessCommandCall(MethodDefinition md, CustomAttribute ca)
         {
             MethodDefinition cmd = new MethodDefinition("Call" +  md.Name, MethodAttributes.Public |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             // add paramters
             foreach (ParameterDefinition pd in md.Parameters)
@@ -1161,10 +1176,10 @@ MethodDefinition ProcessCommandCall(MethodDefinition md, CustomAttribute ca)
 
             WriteSetupLocals(cmdWorker);
 
-            if (Weaver.generateLogErrors)
+            if (m_Weaver.generateLogErrors)
             {
                 cmdWorker.Append(cmdWorker.Create(OpCodes.Ldstr, "Call Command function " + md.Name));
-                cmdWorker.Append(cmdWorker.Create(OpCodes.Call, Weaver.logErrorReference));
+                cmdWorker.Append(cmdWorker.Create(OpCodes.Call, m_Weaver.logErrorReference));
             }
 
             WriteClientActiveCheck(cmdWorker, md.Name, label, "Command function");
@@ -1173,7 +1188,7 @@ MethodDefinition ProcessCommandCall(MethodDefinition md, CustomAttribute ca)
 
             Instruction localClientLabel = cmdWorker.Create(OpCodes.Nop);
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldarg_0));
-            cmdWorker.Append(cmdWorker.Create(OpCodes.Call, Weaver.UBehaviourIsServer));
+            cmdWorker.Append(cmdWorker.Create(OpCodes.Call, m_Weaver.UBehaviourIsServer));
             cmdWorker.Append(cmdWorker.Create(OpCodes.Brfalse, localClientLabel));
 
             // call the cmd function directly.
@@ -1195,23 +1210,23 @@ MethodDefinition ProcessCommandCall(MethodDefinition md, CustomAttribute ca)
             // create the command id constant
             FieldDefinition cmdConstant = new FieldDefinition("kCmd" + md.Name,
                 FieldAttributes.Static | FieldAttributes.Private,
-                Weaver.int32Type);
+                m_Weaver.int32Type);
             m_td.Fields.Add(cmdConstant);
 
             // write command constant
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldloc_0));
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldsfld, cmdConstant));
-            cmdWorker.Append(cmdWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWritePacked32));
+            cmdWorker.Append(cmdWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWritePacked32));
 
             // write playerId from this NetworkBehaviour
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldloc_0));
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldarg_0));
             // load unetviewfield
-            cmdWorker.Append(cmdWorker.Create(OpCodes.Call, Weaver.getComponentReference));
+            cmdWorker.Append(cmdWorker.Create(OpCodes.Call, m_Weaver.getComponentReference));
             // load and write netId field
-            cmdWorker.Append(cmdWorker.Create(OpCodes.Callvirt, Weaver.getUNetIdReference));
+            cmdWorker.Append(cmdWorker.Create(OpCodes.Callvirt, m_Weaver.getUNetIdReference));
 
-            var writeFunc = Weaver.GetWriteFunc(Weaver.NetworkInstanceIdType);
+            var writeFunc = m_Weaver.GetWriteFunc(m_Weaver.NetworkInstanceIdType);
             cmdWorker.Append(cmdWorker.Create(OpCodes.Callvirt, writeFunc));
 
             if (!WriteArguments(cmdWorker, md, "Command", false))
@@ -1239,7 +1254,7 @@ MethodDefinition ProcessCommandCall(MethodDefinition md, CustomAttribute ca)
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldloc_0));
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldc_I4, channel)); // QoS transport channel (reliable/unreliable)
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldstr, cmdName));
-            cmdWorker.Append(cmdWorker.Create(OpCodes.Call, Weaver.sendCommandInternal));
+            cmdWorker.Append(cmdWorker.Create(OpCodes.Call, m_Weaver.sendCommandInternal));
 
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ret));
 
@@ -1251,7 +1266,7 @@ MethodDefinition ProcessTargetRpcInvoke(MethodDefinition md)
             MethodDefinition rpc = new MethodDefinition(k_RpcPrefix + md.Name, MethodAttributes.Family |
                 MethodAttributes.Static |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             ILProcessor rpcWorker = rpc.Body.GetILProcessor();
             Instruction label = rpcWorker.Create(OpCodes.Nop);
@@ -1263,7 +1278,7 @@ MethodDefinition ProcessTargetRpcInvoke(MethodDefinition md)
             rpcWorker.Append(rpcWorker.Create(OpCodes.Castclass, m_td));
 
             //ClientScene.readyconnection
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, Weaver.ReadyConnectionReference));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, m_Weaver.ReadyConnectionReference));
 
             if (!ProcessNetworkReaderParameters(md, rpcWorker, true))
                 return null;
@@ -1282,7 +1297,7 @@ MethodDefinition ProcessRpcInvoke(MethodDefinition md)
             MethodDefinition rpc = new MethodDefinition(k_RpcPrefix + md.Name, MethodAttributes.Family |
                 MethodAttributes.Static |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             ILProcessor rpcWorker = rpc.Body.GetILProcessor();
             Instruction label = rpcWorker.Create(OpCodes.Nop);
@@ -1309,7 +1324,7 @@ MethodDefinition ProcessTargetRpcCall(MethodDefinition md, CustomAttribute ca)
         {
             MethodDefinition rpc = new MethodDefinition("Call" +  md.Name, MethodAttributes.Public |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             // add paramters
             foreach (ParameterDefinition pd in md.Parameters)
@@ -1329,10 +1344,10 @@ MethodDefinition ProcessTargetRpcCall(MethodDefinition md, CustomAttribute ca)
             // check specifically for ULocalConnectionToServer so a host is not trying to send
             // an TargetRPC to the "server" from it's local client.
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldarg_1));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Isinst, Weaver.ULocalConnectionToServerType));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Isinst, m_Weaver.ULocalConnectionToServerType));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Brfalse, labelConnectionCheck));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldstr, string.Format("TargetRPC Function {0} called on connection to server", md.Name)));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, Weaver.logErrorReference));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, m_Weaver.logErrorReference));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ret));
             rpcWorker.Append(labelConnectionCheck);
 
@@ -1345,22 +1360,22 @@ MethodDefinition ProcessTargetRpcCall(MethodDefinition md, CustomAttribute ca)
             // create the command id constant
             FieldDefinition rpcConstant = new FieldDefinition("kTargetRpc" + md.Name,
                 FieldAttributes.Static | FieldAttributes.Private,
-                Weaver.int32Type);
+                m_Weaver.int32Type);
             m_td.Fields.Add(rpcConstant);
 
             // write command constant
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldloc_0));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldsfld, rpcConstant));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWritePacked32));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWritePacked32));
 
             // write this.unetView.netId
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldloc_0));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldarg_0));
             // load unetviewfield
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, Weaver.getComponentReference));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, m_Weaver.getComponentReference));
             // load and write netId field
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.getUNetIdReference));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWriteNetworkInstanceId));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.getUNetIdReference));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWriteNetworkInstanceId));
 
             if (!WriteArguments(rpcWorker, md, "TargetRPC", true))
                 return null;
@@ -1388,7 +1403,7 @@ MethodDefinition ProcessTargetRpcCall(MethodDefinition md, CustomAttribute ca)
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldloc_0)); // writer
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldc_I4, channel)); // QoS transport channel (reliable/unreliable)
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldstr, rpcName));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.sendTargetRpcInternal));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.sendTargetRpcInternal));
 
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ret));
 
@@ -1399,7 +1414,7 @@ MethodDefinition ProcessRpcCall(MethodDefinition md, CustomAttribute ca)
         {
             MethodDefinition rpc = new MethodDefinition("Call" +  md.Name, MethodAttributes.Public |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             // add paramters
             foreach (ParameterDefinition pd in md.Parameters)
@@ -1423,22 +1438,22 @@ MethodDefinition ProcessRpcCall(MethodDefinition md, CustomAttribute ca)
             // create the command id constant
             FieldDefinition rpcConstant = new FieldDefinition("kRpc" + md.Name,
                 FieldAttributes.Static | FieldAttributes.Private,
-                Weaver.int32Type);
+                m_Weaver.int32Type);
             m_td.Fields.Add(rpcConstant);
 
             // write command constant
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldloc_0));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldsfld, rpcConstant));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWritePacked32));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWritePacked32));
 
             // write this.unetView.netId
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldloc_0));
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldarg_0));
             // load unetviewfield
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, Weaver.getComponentReference));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Call, m_Weaver.getComponentReference));
             // load and write netId field
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.getUNetIdReference));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWriteNetworkInstanceId));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.getUNetIdReference));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWriteNetworkInstanceId));
 
             if (!WriteArguments(rpcWorker, md, "RPC", false))
                 return null;
@@ -1465,7 +1480,7 @@ MethodDefinition ProcessRpcCall(MethodDefinition md, CustomAttribute ca)
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldloc_0)); // writer
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldc_I4, channel)); // QoS transport channel (reliable/unreliable)
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ldstr, rpcName));
-            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, Weaver.sendRpcInternal));
+            rpcWorker.Append(rpcWorker.Create(OpCodes.Callvirt, m_Weaver.sendRpcInternal));
 
             rpcWorker.Append(rpcWorker.Create(OpCodes.Ret));
 
@@ -1474,22 +1489,22 @@ MethodDefinition ProcessRpcCall(MethodDefinition md, CustomAttribute ca)
 
         bool ProcessMethodsValidateFunction(MethodReference md, CustomAttribute ca, string actionType)
         {
-            if (md.ReturnType.FullName == Weaver.IEnumeratorType.FullName)
+            if (md.ReturnType.FullName == m_Weaver.IEnumeratorType.FullName)
             {
                 Log.Error(actionType + " function [" + m_td.FullName + ":" + md.Name + "] cannot be a coroutine");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
-            if (md.ReturnType.FullName != Weaver.voidType.FullName)
+            if (md.ReturnType.FullName != m_Weaver.voidType.FullName)
             {
                 Log.Error(actionType + " function [" + m_td.FullName + ":" + md.Name + "] must have a void return type.");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
             if (md.HasGenericParameters)
             {
                 Log.Error(actionType + " [" + m_td.FullName + ":" + md.Name + "] cannot have generic parameters");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
             return true;
@@ -1503,45 +1518,45 @@ bool ProcessMethodsValidateParameters(MethodReference md, CustomAttribute ca, st
                 if (p.IsOut)
                 {
                     Log.Error(actionType + " function [" + m_td.FullName + ":" + md.Name + "] cannot have out parameters");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
                 if (p.IsOptional)
                 {
                     Log.Error(actionType + "function [" + m_td.FullName + ":" + md.Name + "] cannot have optional parameters");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
                 if (p.ParameterType.Resolve().IsAbstract)
                 {
                     Log.Error(actionType + " function [" + m_td.FullName + ":" + md.Name + "] cannot have abstract parameters");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
                 if (p.ParameterType.IsByReference)
                 {
                     Log.Error(actionType + " function [" + m_td.FullName + ":" + md.Name + "] cannot have ref parameters");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
                 // TargetRPC is an exception to this rule and can have a NetworkConnection as first parameter
-                if (p.ParameterType.FullName == Weaver.NetworkConnectionType.FullName &&
-                    !(ca.AttributeType.FullName == Weaver.TargetRpcType.FullName && i == 0))
+                if (p.ParameterType.FullName == m_Weaver.NetworkConnectionType.FullName &&
+                    !(ca.AttributeType.FullName == m_Weaver.TargetRpcType.FullName && i == 0))
                 {
                     Log.Error(actionType + " [" + m_td.FullName + ":" + md.Name + "] cannot use a NetworkConnection as a parameter. To access a player object's connection on the server use connectionToClient");
                     Log.Error("Name: " + ca.AttributeType.FullName + " parameter: " + md.Parameters[0].ParameterType.FullName);
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return false;
                 }
-                if (Weaver.IsDerivedFrom(p.ParameterType.Resolve(), Weaver.ComponentType))
+                if (m_Weaver.IsDerivedFrom(p.ParameterType.Resolve(), m_Weaver.ComponentType))
                 {
-                    if (p.ParameterType.FullName != Weaver.NetworkIdentityType.FullName)
+                    if (p.ParameterType.FullName != m_Weaver.NetworkIdentityType.FullName)
                     {
                         Log.Error(actionType + " function [" + m_td.FullName + ":" + md.Name + "] parameter [" + p.Name +
                             "] is of the type [" +
                             p.ParameterType.Name +
                             "] which is a Component. You cannot pass a Component to a remote call. Try passing data from within the component.");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         return false;
                     }
                 }
@@ -1554,14 +1569,14 @@ private bool ProcessMethodsValidateCommand(MethodDefinition md, CustomAttribute
             if (md.Name.Length > 2 && md.Name.Substring(0, 3) != "Cmd")
             {
                 Log.Error("Command function [" + m_td.FullName + ":" + md.Name + "] doesnt have 'Cmd' prefix");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
             if (md.IsStatic)
             {
                 Log.Error("Command function [" + m_td.FullName + ":" + md.Name + "] cant be a static method");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
@@ -1585,14 +1600,14 @@ bool ProcessMethodsValidateTargetRpc(MethodDefinition md, CustomAttribute ca)
             if (md.Name.Length > prefixLen && md.Name.Substring(0, prefixLen) != targetPrefix)
             {
                 Log.Error("Target Rpc function [" + m_td.FullName + ":" + md.Name + "] doesnt have 'Target' prefix");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
             if (md.IsStatic)
             {
                 Log.Error("TargetRpc function [" + m_td.FullName + ":" + md.Name + "] cant be a static method");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
@@ -1604,14 +1619,14 @@ bool ProcessMethodsValidateTargetRpc(MethodDefinition md, CustomAttribute ca)
             if (md.Parameters.Count < 1)
             {
                 Log.Error("Target Rpc function [" + m_td.FullName + ":" + md.Name + "] must have a NetworkConnection as the first parameter");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
-            if (md.Parameters[0].ParameterType.FullName != Weaver.NetworkConnectionType.FullName)
+            if (md.Parameters[0].ParameterType.FullName != m_Weaver.NetworkConnectionType.FullName)
             {
                 Log.Error("Target Rpc function [" + m_td.FullName + ":" + md.Name + "] first parameter must be a NetworkConnection");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
@@ -1627,14 +1642,14 @@ bool ProcessMethodsValidateRpc(MethodDefinition md, CustomAttribute ca)
             if (md.Name.Length > 2 && md.Name.Substring(0, 3) != "Rpc")
             {
                 Log.Error("Rpc function [" + m_td.FullName + ":" + md.Name + "] doesnt have 'Rpc' prefix");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
             if (md.IsStatic)
             {
                 Log.Error("ClientRpc function [" + m_td.FullName + ":" + md.Name + "] cant be a static method");
-                Weaver.fail = true;
+                m_Weaver.fail = true;
                 return false;
             }
 
@@ -1657,10 +1672,10 @@ void ProcessMethods()
             // find command and RPC functions
             foreach (MethodDefinition md in m_td.Methods)
             {
-                Weaver.ResetRecursionCount();
+                m_Weaver.ResetRecursionCount();
                 foreach (var ca in md.CustomAttributes)
                 {
-                    if (ca.AttributeType.FullName == Weaver.CommandType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.CommandType.FullName)
                     {
                         if (!ProcessMethodsValidateCommand(md, ca))
                             return;
@@ -1668,7 +1683,7 @@ void ProcessMethods()
                         if (names.Contains(md.Name))
                         {
                             Log.Error("Duplicate Command name [" + m_td.FullName + ":" + md.Name + "]");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
                         names.Add(md.Name);
@@ -1684,13 +1699,13 @@ void ProcessMethods()
                         if (cmdCallFunc != null)
                         {
                             m_CmdCallFuncs.Add(cmdCallFunc);
-                            Weaver.lists.replacedMethods.Add(md);
-                            Weaver.lists.replacementMethods.Add(cmdCallFunc);
+                            m_Weaver.lists.replacedMethods.Add(md);
+                            m_Weaver.lists.replacementMethods.Add(cmdCallFunc);
                         }
                         break;
                     }
 
-                    if (ca.AttributeType.FullName == Weaver.TargetRpcType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.TargetRpcType.FullName)
                     {
                         if (!ProcessMethodsValidateTargetRpc(md, ca))
                             return;
@@ -1698,7 +1713,7 @@ void ProcessMethods()
                         if (names.Contains(md.Name))
                         {
                             Log.Error("Duplicate Target Rpc name [" + m_td.FullName + ":" + md.Name + "]");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
                         names.Add(md.Name);
@@ -1714,13 +1729,13 @@ void ProcessMethods()
                         if (rpcCallFunc != null)
                         {
                             m_TargetRpcCallFuncs.Add(rpcCallFunc);
-                            Weaver.lists.replacedMethods.Add(md);
-                            Weaver.lists.replacementMethods.Add(rpcCallFunc);
+                            m_Weaver.lists.replacedMethods.Add(md);
+                            m_Weaver.lists.replacementMethods.Add(rpcCallFunc);
                         }
                         break;
                     }
 
-                    if (ca.AttributeType.FullName == Weaver.ClientRpcType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.ClientRpcType.FullName)
                     {
                         if (!ProcessMethodsValidateRpc(md, ca))
                             return;
@@ -1728,7 +1743,7 @@ void ProcessMethods()
                         if (names.Contains(md.Name))
                         {
                             Log.Error("Duplicate ClientRpc name [" + m_td.FullName + ":" + md.Name + "]");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
                         names.Add(md.Name);
@@ -1744,8 +1759,8 @@ void ProcessMethods()
                         if (rpcCallFunc != null)
                         {
                             m_RpcCallFuncs.Add(rpcCallFunc);
-                            Weaver.lists.replacedMethods.Add(md);
-                            Weaver.lists.replacementMethods.Add(rpcCallFunc);
+                            m_Weaver.lists.replacedMethods.Add(md);
+                            m_Weaver.lists.replacementMethods.Add(rpcCallFunc);
                         }
                         break;
                     }
@@ -1795,15 +1810,15 @@ MethodDefinition ProcessEventInvoke(EventDefinition ed)
             }
             if (eventField == null)
             {
-                Weaver.DLog(m_td, "ERROR: no event field?!");
-                Weaver.fail = true;
+                m_Weaver.DLog(m_td, "ERROR: no event field?!");
+                m_Weaver.fail = true;
                 return null;
             }
 
             MethodDefinition cmd = new MethodDefinition("InvokeSyncEvent" + ed.Name, MethodAttributes.Family |
                 MethodAttributes.Static |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             ILProcessor cmdWorker = cmd.Body.GetILProcessor();
             Instruction label1 = cmdWorker.Create(OpCodes.Nop);
@@ -1825,7 +1840,7 @@ MethodDefinition ProcessEventInvoke(EventDefinition ed)
             cmdWorker.Append(cmdWorker.Create(OpCodes.Ldfld, eventField));
 
             // read the event arguments
-            MethodReference invoke = Weaver.ResolveMethod(eventField.FieldType, "Invoke");
+            MethodReference invoke = m_Weaver.ResolveMethod(eventField.FieldType, "Invoke");
             if (!ProcessNetworkReaderParameters(invoke.Resolve(), cmdWorker, false))
                 return null;
 
@@ -1840,10 +1855,10 @@ MethodDefinition ProcessEventInvoke(EventDefinition ed)
 
         MethodDefinition ProcessEventCall(EventDefinition ed, CustomAttribute ca)
         {
-            MethodReference invoke = Weaver.ResolveMethod(ed.EventType, "Invoke");
+            MethodReference invoke = m_Weaver.ResolveMethod(ed.EventType, "Invoke");
             MethodDefinition evt = new MethodDefinition("Call" +  ed.Name, MethodAttributes.Public |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
             // add paramters
             foreach (ParameterDefinition pd in invoke.Parameters)
             {
@@ -1866,21 +1881,21 @@ MethodDefinition ProcessEventCall(EventDefinition ed, CustomAttribute ca)
             // create the command id constant
             FieldDefinition evtConstant = new FieldDefinition("kEvent" + ed.Name,
                 FieldAttributes.Static | FieldAttributes.Private,
-                Weaver.int32Type);
+                m_Weaver.int32Type);
             m_td.Fields.Add(evtConstant);
 
             // write command constant
             evtWorker.Append(evtWorker.Create(OpCodes.Ldloc_0)); // networkWriter
             evtWorker.Append(evtWorker.Create(OpCodes.Ldsfld, evtConstant));
-            evtWorker.Append(evtWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWritePacked32));
+            evtWorker.Append(evtWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWritePacked32));
 
             // write this.unetView.netId
             evtWorker.Append(evtWorker.Create(OpCodes.Ldloc_0)); // networkWriter
             evtWorker.Append(evtWorker.Create(OpCodes.Ldarg_0)); // this
-            evtWorker.Append(evtWorker.Create(OpCodes.Call, Weaver.getComponentReference)); // unetView
+            evtWorker.Append(evtWorker.Create(OpCodes.Call, m_Weaver.getComponentReference)); // unetView
             // load and write netId field
-            evtWorker.Append(evtWorker.Create(OpCodes.Callvirt, Weaver.getUNetIdReference)); // netId
-            evtWorker.Append(evtWorker.Create(OpCodes.Callvirt, Weaver.NetworkWriterWriteNetworkInstanceId));   // networkWriter.Write(this.unetView.netId)
+            evtWorker.Append(evtWorker.Create(OpCodes.Callvirt, m_Weaver.getUNetIdReference)); // netId
+            evtWorker.Append(evtWorker.Create(OpCodes.Callvirt, m_Weaver.NetworkWriterWriteNetworkInstanceId));   // networkWriter.Write(this.unetView.netId)
 
             if (!WriteArguments(evtWorker, invoke.Resolve(), "SyncEvent", false))
                 return null;
@@ -1900,7 +1915,7 @@ MethodDefinition ProcessEventCall(EventDefinition ed, CustomAttribute ca)
             evtWorker.Append(evtWorker.Create(OpCodes.Ldloc_0)); // writer
             evtWorker.Append(evtWorker.Create(OpCodes.Ldc_I4, channel)); // QoS transport channel (reliable/unreliable)
             evtWorker.Append(evtWorker.Create(OpCodes.Ldstr, ed.Name));
-            evtWorker.Append(evtWorker.Create(OpCodes.Call, Weaver.sendEventInternal));
+            evtWorker.Append(evtWorker.Create(OpCodes.Call, m_Weaver.sendEventInternal));
 
             evtWorker.Append(evtWorker.Create(OpCodes.Ret));
 
@@ -1914,19 +1929,19 @@ void ProcessEvents()
             {
                 foreach (var ca in ed.CustomAttributes)
                 {
-                    if (ca.AttributeType.FullName == Weaver.SyncEventType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.SyncEventType.FullName)
                     {
                         if (ed.Name.Length > 4 && ed.Name.Substring(0, 5) != "Event")
                         {
                             Log.Error("Event  [" + m_td.FullName + ":" + ed.FullName + "] doesnt have 'Event' prefix");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
                         if (ed.EventType.Resolve().HasGenericParameters)
                         {
                             Log.Error("Event  [" + m_td.FullName + ":" + ed.FullName + "] cannot have generic parameters");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
@@ -1940,15 +1955,15 @@ void ProcessEvents()
                         m_td.Methods.Add(eventFunc);
                         m_EventInvocationFuncs.Add(eventFunc);
 
-                        Weaver.DLog(m_td, "ProcessEvent " + ed);
+                        m_Weaver.DLog(m_td, "ProcessEvent " + ed);
 
                         MethodDefinition eventCallFunc = ProcessEventCall(ed, ca);
                         m_td.Methods.Add(eventCallFunc);
 
-                        Weaver.lists.replacedEvents.Add(ed);
-                        Weaver.lists.replacementEvents.Add(eventCallFunc);
+                        m_Weaver.lists.replacedEvents.Add(ed);
+                        m_Weaver.lists.replacementEvents.Add(eventCallFunc);
 
-                        Weaver.DLog(m_td, "  Event: " + ed.Name);
+                        m_Weaver.DLog(m_td, "  Event: " + ed.Name);
                         break;
                     }
                 }
@@ -1983,7 +1998,7 @@ MethodDefinition ProcessSyncVarSet(FieldDefinition fd, string originalName, int
             MethodDefinition set = new MethodDefinition("set_Network" + originalName, MethodAttributes.Public |
                 MethodAttributes.SpecialName |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             ILProcessor setWorker = set.Body.GetILProcessor();
 
@@ -2007,16 +2022,16 @@ MethodDefinition ProcessSyncVarSet(FieldDefinition fd, string originalName, int
             {
                 //if (NetworkServer.localClientActive && !syncVarHookGuard)
                 Instruction label = setWorker.Create(OpCodes.Nop);
-                setWorker.Append(setWorker.Create(OpCodes.Call, Weaver.NetworkServerGetLocalClientActive));
+                setWorker.Append(setWorker.Create(OpCodes.Call, m_Weaver.NetworkServerGetLocalClientActive));
                 setWorker.Append(setWorker.Create(OpCodes.Brfalse, label));
                 setWorker.Append(setWorker.Create(OpCodes.Ldarg_0));
-                setWorker.Append(setWorker.Create(OpCodes.Call, Weaver.getSyncVarHookGuard));
+                setWorker.Append(setWorker.Create(OpCodes.Call, m_Weaver.getSyncVarHookGuard));
                 setWorker.Append(setWorker.Create(OpCodes.Brtrue, label));
 
                 // syncVarHookGuard = true;
                 setWorker.Append(setWorker.Create(OpCodes.Ldarg_0));
                 setWorker.Append(setWorker.Create(OpCodes.Ldc_I4_1));
-                setWorker.Append(setWorker.Create(OpCodes.Call, Weaver.setSyncVarHookGuard));
+                setWorker.Append(setWorker.Create(OpCodes.Call, m_Weaver.setSyncVarHookGuard));
 
                 // call hook
                 setWorker.Append(setWorker.Create(OpCodes.Ldarg_0));
@@ -2026,23 +2041,23 @@ MethodDefinition ProcessSyncVarSet(FieldDefinition fd, string originalName, int
                 // syncVarHookGuard = false;
                 setWorker.Append(setWorker.Create(OpCodes.Ldarg_0));
                 setWorker.Append(setWorker.Create(OpCodes.Ldc_I4_0));
-                setWorker.Append(setWorker.Create(OpCodes.Call, Weaver.setSyncVarHookGuard));
+                setWorker.Append(setWorker.Create(OpCodes.Call, m_Weaver.setSyncVarHookGuard));
 
                 setWorker.Append(label);
             }
 
-            if (fd.FieldType.FullName == Weaver.gameObjectType.FullName)
+            if (fd.FieldType.FullName == m_Weaver.gameObjectType.FullName)
             {
                 // reference to netId Field to set
                 setWorker.Append(setWorker.Create(OpCodes.Ldarg_0));
                 setWorker.Append(setWorker.Create(OpCodes.Ldflda, netFieldId));
 
-                setWorker.Append(setWorker.Create(OpCodes.Call, Weaver.setSyncVarGameObjectReference));
+                setWorker.Append(setWorker.Create(OpCodes.Call, m_Weaver.setSyncVarGameObjectReference));
             }
             else
             {
                 // make generic version of SetSyncVar with field type
-                GenericInstanceMethod gm = new GenericInstanceMethod(Weaver.setSyncVarReference);
+                GenericInstanceMethod gm = new GenericInstanceMethod(m_Weaver.setSyncVarReference);
                 gm.GenericArguments.Add(fd.FieldType);
 
                 // invoke SetSyncVar
@@ -2061,19 +2076,19 @@ void ProcessSyncVar(FieldDefinition fd, int dirtyBit)
         {
             string originalName = fd.Name;
 
-            Weaver.lists.replacedFields.Add(fd);
-            Weaver.DLog(m_td, "Sync Var " + fd.Name + " " + fd.FieldType + " " + Weaver.gameObjectType);
+            m_Weaver.lists.replacedFields.Add(fd);
+            m_Weaver.DLog(m_td, "Sync Var " + fd.Name + " " + fd.FieldType + " " + m_Weaver.gameObjectType);
 
             // GameObject SyncVars have a new field for netId
             FieldDefinition netFieldId = null;
-            if (fd.FieldType.FullName == Weaver.gameObjectType.FullName)
+            if (fd.FieldType.FullName == m_Weaver.gameObjectType.FullName)
             {
                 netFieldId = new FieldDefinition("___" + fd.Name + "NetId",
                     FieldAttributes.Private,
-                    Weaver.NetworkInstanceIdType);
+                    m_Weaver.NetworkInstanceIdType);
 
                 m_SyncVarNetIds.Add(netFieldId);
-                Weaver.lists.netIdFields.Add(netFieldId);
+                m_Weaver.lists.netIdFields.Add(netFieldId);
             }
 
             var get = ProcessSyncVarGet(fd, originalName);
@@ -2090,7 +2105,7 @@ void ProcessSyncVar(FieldDefinition fd, int dirtyBit)
             m_td.Methods.Add(get);
             m_td.Methods.Add(set);
             m_td.Properties.Add(propertyDefinition);
-            Weaver.lists.replacementProperties.Add(set);
+            m_Weaver.lists.replacementProperties.Add(set);
         }
 
         /*
@@ -2106,12 +2121,12 @@ protected static void InvokeSyncListm_ints(NetworkBehaviour obj, NetworkReader r
                 ((SyncListTestPlayerBehaviour)obj).m_ints.HandleMsg(reader);
             }
         */
-        static MethodDefinition ProcessSyncListInvoke(FieldDefinition fd)
+        MethodDefinition ProcessSyncListInvoke(FieldDefinition fd)
         {
             MethodDefinition cmd = new MethodDefinition("InvokeSyncList" + fd.Name, MethodAttributes.Family |
                 MethodAttributes.Static |
                 MethodAttributes.HideBySig,
-                Weaver.voidType);
+                m_Weaver.voidType);
 
             ILProcessor syncList = cmd.Body.GetILProcessor();
             Instruction label = syncList.Create(OpCodes.Nop);
@@ -2127,9 +2142,9 @@ static MethodDefinition ProcessSyncListInvoke(FieldDefinition fd)
 
             // make specialized version of HandleMsg
             GenericInstanceType syncListGeneric = (GenericInstanceType)fd.FieldType.Resolve().BaseType;
-            syncListGeneric = (GenericInstanceType)Weaver.scriptDef.MainModule.ImportReference(syncListGeneric);
+            syncListGeneric = (GenericInstanceType)m_Weaver.m_ScriptDef.MainModule.ImportReference(syncListGeneric);
             TypeReference listValueType = syncListGeneric.GenericArguments[0];
-            MethodReference genericHandleMsgMethod = Helpers.MakeHostInstanceGeneric(Weaver.SyncListInitHandleMsg, listValueType);
+            MethodReference genericHandleMsgMethod = Helpers.MakeHostInstanceGeneric(m_Weaver.SyncListInitHandleMsg, listValueType);
             syncList.Append(syncList.Create(OpCodes.Callvirt, genericHandleMsgMethod));
 
             syncList.Append(syncList.Create(OpCodes.Ret));
@@ -2147,7 +2162,7 @@ FieldDefinition ProcessSyncList(FieldDefinition fd, int dirtyBit)
             // create the command id constant
             return new FieldDefinition("kList" + fd.Name,
                 FieldAttributes.Static | FieldAttributes.Private,
-                Weaver.int32Type);
+                m_Weaver.int32Type);
         }
 
         void ProcessSyncVars()
@@ -2156,7 +2171,7 @@ void ProcessSyncVars()
 
             // 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
-            int dirtyBitCounter = Weaver.GetSyncVarStart(m_td.BaseType.FullName);
+            int dirtyBitCounter = m_Weaver.GetSyncVarStart(m_td.BaseType.FullName);
 
             m_SyncVarNetIds.Clear();
             List<FieldDefinition> listFields = new List<FieldDefinition>();
@@ -2166,67 +2181,67 @@ void ProcessSyncVars()
             {
                 foreach (var ca in fd.CustomAttributes)
                 {
-                    if (ca.AttributeType.FullName == Weaver.SyncVarType.FullName)
+                    if (ca.AttributeType.FullName == m_Weaver.SyncVarType.FullName)
                     {
                         var resolvedField = fd.FieldType.Resolve();
 
-                        if (Weaver.IsDerivedFrom(resolvedField, Weaver.NetworkBehaviourType))
+                        if (m_Weaver.IsDerivedFrom(resolvedField, m_Weaver.NetworkBehaviourType))
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] cannot be derived from NetworkBehaviour.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
-                        if (Weaver.IsDerivedFrom(resolvedField, Weaver.ScriptableObjectType))
+                        if (m_Weaver.IsDerivedFrom(resolvedField, m_Weaver.ScriptableObjectType))
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] cannot be derived from ScriptableObject.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
                         if ((fd.Attributes & FieldAttributes.Static) != 0)
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] cannot be static.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
                         if (resolvedField.HasGenericParameters)
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] cannot have generic parameters.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
                         if (resolvedField.IsInterface)
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] cannot be an interface.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
                         var fieldModuleName = resolvedField.Module.Name;
-                        if (fieldModuleName != Weaver.scriptDef.MainModule.Name &&
-                            fieldModuleName != Weaver.m_UnityAssemblyDefinition.MainModule.Name &&
-                            fieldModuleName != Weaver.m_UNetAssemblyDefinition.MainModule.Name &&
-                            fieldModuleName != Weaver.corLib.Name &&
+                        if (fieldModuleName != m_Weaver.m_ScriptDef.MainModule.Name &&
+                            fieldModuleName != m_Weaver.m_UnityAssemblyDefinition.MainModule.Name &&
+                            fieldModuleName != m_Weaver.m_UNetAssemblyDefinition.MainModule.Name &&
+                            fieldModuleName != m_Weaver.m_CorLib.Name &&
                             fieldModuleName != "netstandard.dll" &&
                             fieldModuleName != "System.Runtime.dll" // this is only for Metro, built-in types are not in corlib on metro
                         )
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] from " + resolvedField.Module.ToString() + " cannot be a different module.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
                         if (fd.FieldType.IsArray)
                         {
                             Log.Error("SyncVar [" + fd.FullName + "] cannot be an array. Use a SyncList instead.");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
 
-                        if (Helpers.InheritsFromSyncList(fd.FieldType))
+                        if (Helpers.InheritsFromSyncList(fd.FieldType, m_Weaver))
                         {
                             Log.Warning(string.Format("Script class [{0}] has [SyncVar] attribute on SyncList field {1}, SyncLists should not be marked with SyncVar.", m_td.FullName, fd.Name));
                             break;
@@ -2241,7 +2256,7 @@ void ProcessSyncVars()
                         if (dirtyBitCounter == k_SyncVarLimit)
                         {
                             Log.Error("Script class [" + m_td.FullName + "] has too many SyncVars (" + k_SyncVarLimit + "). (This could include base classes)");
-                            Weaver.fail = true;
+                            m_Weaver.fail = true;
                             return;
                         }
                         break;
@@ -2251,16 +2266,16 @@ void ProcessSyncVars()
                 if (fd.FieldType.FullName.Contains("UnityEngine.Networking.SyncListStruct"))
                 {
                     Log.Error("SyncListStruct member variable [" + fd.FullName + "] must use a dervied class, like \"class MySyncList : SyncListStruct<MyStruct> {}\".");
-                    Weaver.fail = true;
+                    m_Weaver.fail = true;
                     return;
                 }
 
-                if (Weaver.IsDerivedFrom(fd.FieldType.Resolve(), Weaver.SyncListType))
+                if (m_Weaver.IsDerivedFrom(fd.FieldType.Resolve(), m_Weaver.SyncListType))
                 {
                     if (fd.IsStatic)
                     {
                         Log.Error("SyncList [" + m_td.FullName + ":" + fd.FullName + "] cannot be a static");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         return;
                     }
 
@@ -2273,7 +2288,7 @@ void ProcessSyncVars()
                     if (dirtyBitCounter == k_SyncVarLimit)
                     {
                         Log.Error("Script class [" + m_td.FullName + "] has too many SyncVars (" + k_SyncVarLimit + "). (This could include base classes)");
-                        Weaver.fail = true;
+                        m_Weaver.fail = true;
                         return;
                     }
                 }
@@ -2295,7 +2310,7 @@ void ProcessSyncVars()
                 m_td.Methods.Add(func);
             }
 
-            Weaver.SetNumSyncVars(m_td.FullName, numSyncVars);
+            m_Weaver.SetNumSyncVars(m_td.FullName, numSyncVars);
         }
 
         // Copy of Mono string.GetHashCode(), so that we generate same hashes regardless of runtime (mono/MS .NET)
diff --git a/package/Editor/Tools/Weaver/UNetWeaver.cs b/package/Editor/Tools/Weaver/UNetWeaver.cs
index c26dbbf0b..61e2d234a 100755
--- a/package/Editor/Tools/Weaver/UNetWeaver.cs
+++ b/package/Editor/Tools/Weaver/UNetWeaver.cs
@@ -53,181 +53,183 @@ class WeaverLists
     class Weaver
     {
         // UNetwork types
-        public static TypeReference NetworkBehaviourType;
-        public static TypeReference NetworkBehaviourType2;
-        public static TypeReference MonoBehaviourType;
-        public static TypeReference ScriptableObjectType;
-        public static TypeReference NetworkConnectionType;
-        public static TypeReference ULocalConnectionToServerType;
-        public static TypeReference ULocalConnectionToClientType;
-
-        public static TypeReference MessageBaseType;
-        public static TypeReference SyncListStructType;
-
-        public static MethodReference NetworkBehaviourDirtyBitsReference;
-        public static TypeReference NetworkClientType;
-        public static TypeReference NetworkServerType;
-        public static TypeReference NetworkCRCType;
-
-        public static TypeReference NetworkReaderType;
-        public static TypeDefinition NetworkReaderDef;
-
-        public static TypeReference NetworkWriterType;
-        public static TypeDefinition NetworkWriterDef;
-
-        public static MethodReference NetworkWriterCtor;
-        public static MethodReference NetworkReaderCtor;
-        public static TypeReference MemoryStreamType;
-        public static MethodReference MemoryStreamCtor;
-        public static MethodReference getComponentReference;
-        public static MethodReference getUNetIdReference;
-        public static MethodReference getPlayerIdReference;
-        public static TypeReference NetworkIdentityType;
-        public static TypeReference NetworkInstanceIdType;
-        public static TypeReference NetworkSceneIdType;
-        public static TypeReference IEnumeratorType;
-
-        public static TypeReference ClientSceneType;
-        public static MethodReference FindLocalObjectReference;
-        public static MethodReference RegisterBehaviourReference;
-        public static MethodReference ReadyConnectionReference;
-
-        public static TypeReference ComponentType;
-
-        public static TypeReference CmdDelegateReference;
-        public static MethodReference CmdDelegateConstructor;
-
-        public static MethodReference NetworkReaderReadInt32;
-
-        public static MethodReference NetworkWriterWriteInt32;
-        public static MethodReference NetworkWriterWriteInt16;
-
-        public static MethodReference NetworkServerGetActive;
-        public static MethodReference NetworkServerGetLocalClientActive;
-        public static MethodReference NetworkClientGetActive;
-        public static MethodReference UBehaviourIsServer;
-        public static MethodReference NetworkReaderReadPacked32;
-        public static MethodReference NetworkReaderReadPacked64;
-        public static MethodReference NetworkReaderReadByte;
-        public static MethodReference NetworkWriterWritePacked32;
-        public static MethodReference NetworkWriterWritePacked64;
-
-        public static MethodReference NetworkWriterWriteNetworkInstanceId;
-        public static MethodReference NetworkWriterWriteNetworkSceneId;
-
-        public static MethodReference NetworkReaderReadNetworkInstanceId;
-        public static MethodReference NetworkReaderReadNetworkSceneId;
-        public static MethodReference NetworkInstanceIsEmpty;
-
-        public static MethodReference NetworkReadUInt16;
-        public static MethodReference NetworkWriteUInt16;
+        public TypeReference NetworkBehaviourType;
+        public TypeReference NetworkBehaviourType2;
+        public TypeReference MonoBehaviourType;
+        public TypeReference ScriptableObjectType;
+        public TypeReference NetworkConnectionType;
+        public TypeReference ULocalConnectionToServerType;
+        public TypeReference ULocalConnectionToClientType;
+
+        public TypeReference MessageBaseType;
+        public TypeReference SyncListStructType;
+
+        public MethodReference NetworkBehaviourDirtyBitsReference;
+        public TypeReference NetworkClientType;
+        public TypeReference NetworkServerType;
+        public TypeReference NetworkCRCType;
+
+        public TypeReference NetworkReaderType;
+        public TypeDefinition NetworkReaderDef;
+
+        public TypeReference NetworkWriterType;
+        public TypeDefinition NetworkWriterDef;
+
+        public MethodReference NetworkWriterCtor;
+        public MethodReference NetworkReaderCtor;
+        public TypeReference MemoryStreamType;
+        public MethodReference MemoryStreamCtor;
+        public MethodReference getComponentReference;
+        public MethodReference getUNetIdReference;
+        public MethodReference getPlayerIdReference;
+        public TypeReference NetworkIdentityType;
+        public TypeReference NetworkInstanceIdType;
+        public TypeReference NetworkSceneIdType;
+        public TypeReference IEnumeratorType;
+
+        public TypeReference ClientSceneType;
+        public MethodReference FindLocalObjectReference;
+        public MethodReference RegisterBehaviourReference;
+        public MethodReference ReadyConnectionReference;
+
+        public TypeReference ComponentType;
+
+        public TypeReference CmdDelegateReference;
+        public MethodReference CmdDelegateConstructor;
+
+        public MethodReference NetworkReaderReadInt32;
+
+        public MethodReference NetworkWriterWriteInt32;
+        public MethodReference NetworkWriterWriteInt16;
+
+        public MethodReference NetworkServerGetActive;
+        public MethodReference NetworkServerGetLocalClientActive;
+        public MethodReference NetworkClientGetActive;
+        public MethodReference UBehaviourIsServer;
+        public MethodReference NetworkReaderReadPacked32;
+        public MethodReference NetworkReaderReadPacked64;
+        public MethodReference NetworkReaderReadByte;
+        public MethodReference NetworkWriterWritePacked32;
+        public MethodReference NetworkWriterWritePacked64;
+
+        public MethodReference NetworkWriterWriteNetworkInstanceId;
+        public MethodReference NetworkWriterWriteNetworkSceneId;
+
+        public MethodReference NetworkReaderReadNetworkInstanceId;
+        public MethodReference NetworkReaderReadNetworkSceneId;
+        public MethodReference NetworkInstanceIsEmpty;
+
+        public MethodReference NetworkReadUInt16;
+        public MethodReference NetworkWriteUInt16;
 
         // custom attribute types
-        public static TypeReference SyncVarType;
-        public static TypeReference CommandType;
-        public static TypeReference ClientRpcType;
-        public static TypeReference TargetRpcType;
-        public static TypeReference SyncEventType;
-        public static TypeReference SyncListType;
-        public static MethodReference SyncListInitBehaviourReference;
-        public static MethodReference SyncListInitHandleMsg;
-        public static MethodReference SyncListClear;
-        public static TypeReference NetworkSettingsType;
+        public TypeReference SyncVarType;
+        public TypeReference CommandType;
+        public TypeReference ClientRpcType;
+        public TypeReference TargetRpcType;
+        public TypeReference SyncEventType;
+        public TypeReference SyncListType;
+        public MethodReference SyncListInitBehaviourReference;
+        public MethodReference SyncListInitHandleMsg;
+        public MethodReference SyncListClear;
+        public TypeReference NetworkSettingsType;
 
         // sync list types
-        public static TypeReference SyncListFloatType;
-        public static TypeReference SyncListIntType;
-        public static TypeReference SyncListUIntType;
-        public static TypeReference SyncListBoolType;
-        public static TypeReference SyncListStringType;
-
-        public static MethodReference SyncListFloatReadType;
-        public static MethodReference SyncListIntReadType;
-        public static MethodReference SyncListUIntReadType;
-        public static MethodReference SyncListStringReadType;
-        public static MethodReference SyncListBoolReadType;
-
-        public static MethodReference SyncListFloatWriteType;
-        public static MethodReference SyncListIntWriteType;
-        public static MethodReference SyncListUIntWriteType;
-        public static MethodReference SyncListBoolWriteType;
-        public static MethodReference SyncListStringWriteType;
+        public TypeReference SyncListFloatType;
+        public TypeReference SyncListIntType;
+        public TypeReference SyncListUIntType;
+        public TypeReference SyncListBoolType;
+        public TypeReference SyncListStringType;
+
+        public MethodReference SyncListFloatReadType;
+        public MethodReference SyncListIntReadType;
+        public MethodReference SyncListUIntReadType;
+        public MethodReference SyncListStringReadType;
+        public MethodReference SyncListBoolReadType;
+
+        public MethodReference SyncListFloatWriteType;
+        public MethodReference SyncListIntWriteType;
+        public MethodReference SyncListUIntWriteType;
+        public MethodReference SyncListBoolWriteType;
+        public MethodReference SyncListStringWriteType;
 
         // system types
-        public static TypeReference voidType;
-        public static TypeReference singleType;
-        public static TypeReference doubleType;
-        public static TypeReference decimalType;
-        public static TypeReference boolType;
-        public static TypeReference stringType;
-        public static TypeReference int64Type;
-        public static TypeReference uint64Type;
-        public static TypeReference int32Type;
-        public static TypeReference uint32Type;
-        public static TypeReference int16Type;
-        public static TypeReference uint16Type;
-        public static TypeReference byteType;
-        public static TypeReference sbyteType;
-        public static TypeReference charType;
-        public static TypeReference objectType;
-        public static TypeReference valueTypeType;
-        public static TypeReference vector2Type;
-        public static TypeReference vector3Type;
-        public static TypeReference vector4Type;
-        public static TypeReference colorType;
-        public static TypeReference color32Type;
-        public static TypeReference quaternionType;
-        public static TypeReference rectType;
-        public static TypeReference rayType;
-        public static TypeReference planeType;
-        public static TypeReference matrixType;
-        public static TypeReference hashType;
-        public static TypeReference typeType;
-        public static TypeReference gameObjectType;
-        public static TypeReference transformType;
-        public static TypeReference unityObjectType;
-        public static MethodReference gameObjectInequality;
-
-        public static MethodReference setSyncVarReference;
-        public static MethodReference setSyncVarHookGuard;
-        public static MethodReference getSyncVarHookGuard;
-        public static MethodReference setSyncVarGameObjectReference;
-        public static MethodReference registerCommandDelegateReference;
-        public static MethodReference registerRpcDelegateReference;
-        public static MethodReference registerEventDelegateReference;
-        public static MethodReference registerSyncListDelegateReference;
-        public static MethodReference getTypeReference;
-        public static MethodReference getTypeFromHandleReference;
-        public static MethodReference logErrorReference;
-        public static MethodReference logWarningReference;
-        public static MethodReference sendCommandInternal;
-        public static MethodReference sendRpcInternal;
-        public static MethodReference sendTargetRpcInternal;
-        public static MethodReference sendEventInternal;
-
-        public static WeaverLists lists;
-
-        public static AssemblyDefinition scriptDef;
-        public static ModuleDefinition corLib;
-        public static AssemblyDefinition m_UnityAssemblyDefinition;
-        public static AssemblyDefinition m_UNetAssemblyDefinition;
-
-        static bool m_DebugFlag = true;
-
-        public static bool fail;
-        public static bool generateLogErrors = false;
+        public TypeReference voidType;
+        public TypeReference singleType;
+        public TypeReference doubleType;
+        public TypeReference decimalType;
+        public TypeReference boolType;
+        public TypeReference stringType;
+        public TypeReference int64Type;
+        public TypeReference uint64Type;
+        public TypeReference int32Type;
+        public TypeReference uint32Type;
+        public TypeReference int16Type;
+        public TypeReference uint16Type;
+        public TypeReference byteType;
+        public TypeReference sbyteType;
+        public TypeReference charType;
+        public TypeReference objectType;
+        public TypeReference valueTypeType;
+        public TypeReference vector2Type;
+        public TypeReference vector3Type;
+        public TypeReference vector4Type;
+        public TypeReference colorType;
+        public TypeReference color32Type;
+        public TypeReference quaternionType;
+        public TypeReference rectType;
+        public TypeReference rayType;
+        public TypeReference planeType;
+        public TypeReference matrixType;
+        public TypeReference hashType;
+        public TypeReference typeType;
+        public TypeReference gameObjectType;
+        public TypeReference transformType;
+        public TypeReference unityObjectType;
+        public MethodReference gameObjectInequality;
+
+        public MethodReference setSyncVarReference;
+        public MethodReference setSyncVarHookGuard;
+        public MethodReference getSyncVarHookGuard;
+        public MethodReference setSyncVarGameObjectReference;
+        public MethodReference registerCommandDelegateReference;
+        public MethodReference registerRpcDelegateReference;
+        public MethodReference registerEventDelegateReference;
+        public MethodReference registerSyncListDelegateReference;
+        public MethodReference getTypeReference;
+        public MethodReference getTypeFromHandleReference;
+        public MethodReference logErrorReference;
+        public MethodReference logWarningReference;
+        public MethodReference sendCommandInternal;
+        public MethodReference sendRpcInternal;
+        public MethodReference sendTargetRpcInternal;
+        public MethodReference sendEventInternal;
+
+        public WeaverLists lists;
+
+        public AssemblyDefinition m_ScriptDef;
+        public ModuleDefinition m_CorLib;
+        public AssemblyDefinition m_UnityAssemblyDefinition;
+        public AssemblyDefinition m_UNetAssemblyDefinition;
+
+        bool m_DebugFlag = true;
+
+        public bool fail;
+        public bool generateLogErrors = false;
 
         // this is used to prevent stack overflows when generating serialization code when there are self-referencing types.
         // All the utility classes use GetWriteFunc() to generate serialization code, so the recursion check is implemented there instead of in each utility class.
         // A NetworkBehaviour with the max SyncVars (32) can legitimately increment this value to 65 - so max must be higher than that
         const int MaxRecursionCount = 128;
-        static int s_RecursionCount;
-        public static void ResetRecursionCount()
+        int s_RecursionCount;
+
+        public Weaver() { }
+        public void ResetRecursionCount()
         {
             s_RecursionCount = 0;
         }
 
-        public static bool CanBeResolved(TypeReference parent)
+        public bool CanBeResolved(TypeReference parent)
         {
             while (parent != null)
             {
@@ -254,7 +256,7 @@ public static bool CanBeResolved(TypeReference parent)
             return true;
         }
 
-        public static bool IsArrayType(TypeReference variable)
+        public bool IsArrayType(TypeReference variable)
         {
             if ((variable.IsArray && ((ArrayType)variable).ElementType.IsArray) || // jagged array
                 (variable.IsArray && ((ArrayType)variable).Rank > 1)) // multidimensional array
@@ -262,7 +264,7 @@ public static bool IsArrayType(TypeReference variable)
             return true;
         }
 
-        public static void DLog(TypeDefinition td, string fmt, params object[] args)
+        public void DLog(TypeDefinition td, string fmt, params object[] args)
         {
             if (!m_DebugFlag)
                 return;
@@ -270,7 +272,7 @@ public static void DLog(TypeDefinition td, string fmt, params object[] args)
             Console.WriteLine("[" + td.Name + "] " + String.Format(fmt, args));
         }
 
-        public static int GetSyncVarStart(string className)
+        public int GetSyncVarStart(string className)
         {
             if (lists.numSyncVars.ContainsKey(className))
             {
@@ -281,12 +283,12 @@ public static int GetSyncVarStart(string className)
             return 0;
         }
 
-        public static void SetNumSyncVars(string className, int num)
+        public void SetNumSyncVars(string className, int num)
         {
             lists.numSyncVars[className] = num;
         }
 
-        public static MethodReference GetWriteFunc(TypeReference variable)
+        public MethodReference GetWriteFunc(TypeReference variable)
         {
             if (s_RecursionCount++ > MaxRecursionCount)
             {
@@ -342,16 +344,16 @@ public static MethodReference GetWriteFunc(TypeReference variable)
             return newWriterFunc;
         }
 
-        static public void RegisterWriteFunc(string name, MethodDefinition newWriterFunc)
+        public void RegisterWriteFunc(string name, MethodDefinition newWriterFunc)
         {
             lists.writeFuncs[name] = newWriterFunc;
             lists.generatedWriteFunctions.Add(newWriterFunc);
 
-            ConfirmGeneratedCodeClass(scriptDef.MainModule);
+            ConfirmGeneratedCodeClass(m_ScriptDef.MainModule);
             lists.generateContainerClass.Methods.Add(newWriterFunc);
         }
 
-        public static MethodReference GetReadByReferenceFunc(TypeReference variable)
+        public MethodReference GetReadByReferenceFunc(TypeReference variable)
         {
             if (lists.readByReferenceFuncs.ContainsKey(variable.FullName))
             {
@@ -360,7 +362,7 @@ public static MethodReference GetReadByReferenceFunc(TypeReference variable)
             return null;
         }
 
-        public static MethodReference GetReadFunc(TypeReference variable)
+        public MethodReference GetReadFunc(TypeReference variable)
         {
             if (lists.readFuncs.ContainsKey(variable.FullName))
             {
@@ -416,25 +418,25 @@ public static MethodReference GetReadFunc(TypeReference variable)
             return newReaderFunc;
         }
 
-        static public void RegisterReadByReferenceFunc(string name, MethodDefinition newReaderFunc)
+        public void RegisterReadByReferenceFunc(string name, MethodDefinition newReaderFunc)
         {
             lists.readByReferenceFuncs[name] = newReaderFunc;
             lists.generatedReadFunctions.Add(newReaderFunc);
 
-            ConfirmGeneratedCodeClass(scriptDef.MainModule);
+            ConfirmGeneratedCodeClass(m_ScriptDef.MainModule);
             lists.generateContainerClass.Methods.Add(newReaderFunc);
         }
 
-        static public void RegisterReadFunc(string name, MethodDefinition newReaderFunc)
+        public void RegisterReadFunc(string name, MethodDefinition newReaderFunc)
         {
             lists.readFuncs[name] = newReaderFunc;
             lists.generatedReadFunctions.Add(newReaderFunc);
 
-            ConfirmGeneratedCodeClass(scriptDef.MainModule);
+            ConfirmGeneratedCodeClass(m_ScriptDef.MainModule);
             lists.generateContainerClass.Methods.Add(newReaderFunc);
         }
 
-        static MethodDefinition GenerateArrayReadFunc(TypeReference variable, MethodReference elementReadFunc)
+        MethodDefinition GenerateArrayReadFunc(TypeReference variable, MethodReference elementReadFunc)
         {
             if (!IsArrayType(variable))
             {
@@ -458,7 +460,7 @@ static MethodDefinition GenerateArrayReadFunc(TypeReference variable, MethodRefe
                 MethodAttributes.HideBySig,
                 variable);
 
-            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, scriptDef.MainModule.ImportReference(NetworkReaderType)));
+            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_ScriptDef.MainModule.ImportReference(NetworkReaderType)));
 
             readerFunc.Body.Variables.Add(new VariableDefinition(int32Type));
             readerFunc.Body.Variables.Add(new VariableDefinition(variable));
@@ -517,7 +519,7 @@ static MethodDefinition GenerateArrayReadFunc(TypeReference variable, MethodRefe
             return readerFunc;
         }
 
-        static MethodDefinition GenerateArrayWriteFunc(TypeReference variable, MethodReference elementWriteFunc)
+        MethodDefinition GenerateArrayWriteFunc(TypeReference variable, MethodReference elementWriteFunc)
         {
             if (!IsArrayType(variable))
             {
@@ -541,8 +543,8 @@ static MethodDefinition GenerateArrayWriteFunc(TypeReference variable, MethodRef
                 MethodAttributes.HideBySig,
                 voidType);
 
-            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, scriptDef.MainModule.ImportReference(NetworkWriterType)));
-            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, scriptDef.MainModule.ImportReference(variable)));
+            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, m_ScriptDef.MainModule.ImportReference(NetworkWriterType)));
+            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, m_ScriptDef.MainModule.ImportReference(variable)));
 
             writerFunc.Body.Variables.Add(new VariableDefinition(uint16Type));
             writerFunc.Body.Variables.Add(new VariableDefinition(uint16Type));
@@ -606,7 +608,7 @@ static MethodDefinition GenerateArrayWriteFunc(TypeReference variable, MethodRef
             return writerFunc;
         }
 
-        static MethodDefinition GenerateWriterFunction(TypeReference variable)
+        MethodDefinition GenerateWriterFunction(TypeReference variable)
         {
             if (!IsValidTypeToGenerate(variable.Resolve()))
             {
@@ -629,8 +631,8 @@ static MethodDefinition GenerateWriterFunction(TypeReference variable)
                 MethodAttributes.HideBySig,
                 voidType);
 
-            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, scriptDef.MainModule.ImportReference(NetworkWriterType)));
-            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, scriptDef.MainModule.ImportReference(variable)));
+            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, m_ScriptDef.MainModule.ImportReference(NetworkWriterType)));
+            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, m_ScriptDef.MainModule.ImportReference(variable)));
 
             ILProcessor worker = writerFunc.Body.GetILProcessor();
 
@@ -672,13 +674,13 @@ static MethodDefinition GenerateWriterFunction(TypeReference variable)
             }
             if (fields == 0)
             {
-                Log.Warning("The class / struct " + variable.Name + " has no public or non-static fields to serialize");
+                Log.Warning("The class / struct " + variable.Name + " has no public or non-fields to serialize");
             }
             worker.Append(worker.Create(OpCodes.Ret));
             return writerFunc;
         }
 
-        static MethodDefinition GenerateReadFunction(TypeReference variable)
+        MethodDefinition GenerateReadFunction(TypeReference variable)
         {
             if (!IsValidTypeToGenerate(variable.Resolve()))
             {
@@ -706,7 +708,7 @@ static MethodDefinition GenerateReadFunction(TypeReference variable)
             readerFunc.Body.Variables.Add(new VariableDefinition(variable));
             readerFunc.Body.InitLocals = true;
 
-            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, scriptDef.MainModule.ImportReference(NetworkReaderType)));
+            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, m_ScriptDef.MainModule.ImportReference(NetworkReaderType)));
 
             ILProcessor worker = readerFunc.Body.GetILProcessor();
 
@@ -765,7 +767,7 @@ static MethodDefinition GenerateReadFunction(TypeReference variable)
             }
             if (fields == 0)
             {
-                Log.Warning("The class / struct " + variable.Name + " has no public or non-static fields to serialize");
+                Log.Warning("The class / struct " + variable.Name + " has no public or non-fields to serialize");
             }
 
             worker.Append(worker.Create(OpCodes.Ldloc_0));
@@ -773,7 +775,7 @@ static MethodDefinition GenerateReadFunction(TypeReference variable)
             return readerFunc;
         }
 
-        static Instruction GetEventLoadInstruction(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, int iCount, FieldReference foundEventField)
+        Instruction GetEventLoadInstruction(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, int iCount, FieldReference foundEventField)
         {
             // go backwards until find a ldfld instruction for this event field
             while (iCount > 0)
@@ -792,7 +794,7 @@ static Instruction GetEventLoadInstruction(ModuleDefinition moduleDef, TypeDefin
             return null;
         }
 
-        static void ProcessInstructionMethod(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, Instruction instr, MethodReference opMethodRef, int iCount)
+        void ProcessInstructionMethod(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, Instruction instr, MethodReference opMethodRef, int iCount)
         {
             //DLog(td, "ProcessInstructionMethod " + opMethod.Name);
             if (opMethodRef.Name == "Invoke")
@@ -846,7 +848,7 @@ static void ProcessInstructionMethod(ModuleDefinition moduleDef, TypeDefinition
             }
         }
 
-        static void ConfirmGeneratedCodeClass(ModuleDefinition moduleDef)
+        void ConfirmGeneratedCodeClass(ModuleDefinition moduleDef)
         {
             if (lists.generateContainerClass == null)
             {
@@ -864,7 +866,7 @@ static void ConfirmGeneratedCodeClass(ModuleDefinition moduleDef)
             }
         }
 
-        static void ProcessInstructionField(TypeDefinition td, MethodDefinition md, Instruction i, FieldDefinition opField)
+        void ProcessInstructionField(TypeDefinition td, MethodDefinition md, Instruction i, FieldDefinition opField)
         {
             // dont replace property call sites in constructors or deserialize
             if (md.Name == ".ctor" || md.Name == "OnDeserialize")
@@ -886,7 +888,7 @@ static void ProcessInstructionField(TypeDefinition td, MethodDefinition md, Inst
             }
         }
 
-        static void ProcessInstruction(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, Instruction i, int iCount)
+        void ProcessInstruction(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, Instruction i, int iCount)
         {
             if (i.OpCode == OpCodes.Call || i.OpCode == OpCodes.Callvirt)
             {
@@ -909,7 +911,7 @@ static void ProcessInstruction(ModuleDefinition moduleDef, TypeDefinition td, Me
         }
 
         // this is required to early-out from a function with "ref" or "out" parameters
-        static void InjectGuardParameters(MethodDefinition md, ILProcessor worker, Instruction top)
+        void InjectGuardParameters(MethodDefinition md, ILProcessor worker, Instruction top)
         {
             int offset = md.Resolve().IsStatic ? 0 : 1;
             for (int index = 0; index < md.Parameters.Count; index++)
@@ -940,7 +942,7 @@ static void InjectGuardParameters(MethodDefinition md, ILProcessor worker, Instr
         }
 
         // this is required to early-out from a function with a return value.
-        static void InjectGuardReturnValue(MethodDefinition md, ILProcessor worker, Instruction top)
+        void InjectGuardReturnValue(MethodDefinition md, ILProcessor worker, Instruction top)
         {
             if (md.ReturnType.FullName != voidType.FullName)
             {
@@ -960,7 +962,7 @@ static void InjectGuardReturnValue(MethodDefinition md, ILProcessor worker, Inst
             }
         }
 
-        static void InjectServerGuard(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, bool logWarning)
+        void InjectServerGuard(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, bool logWarning)
         {
             if (!IsNetworkBehaviour(td))
             {
@@ -982,7 +984,7 @@ static void InjectServerGuard(ModuleDefinition moduleDef, TypeDefinition td, Met
             worker.InsertBefore(top, worker.Create(OpCodes.Ret));
         }
 
-        static void InjectClientGuard(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, bool logWarning)
+        void InjectClientGuard(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md, bool logWarning)
         {
             if (!IsNetworkBehaviour(td))
             {
@@ -1005,7 +1007,7 @@ static void InjectClientGuard(ModuleDefinition moduleDef, TypeDefinition td, Met
             worker.InsertBefore(top, worker.Create(OpCodes.Ret));
         }
 
-        static void ProcessSiteMethod(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md)
+        void ProcessSiteMethod(ModuleDefinition moduleDef, TypeDefinition td, MethodDefinition md)
         {
             // process all references to replaced members with properties
             //Weaver.DLog(td, "      ProcessSiteMethod " + md);
@@ -1057,7 +1059,7 @@ static void ProcessSiteMethod(ModuleDefinition moduleDef, TypeDefinition td, Met
             }
         }
 
-        static void ProcessSiteClass(ModuleDefinition moduleDef, TypeDefinition td)
+        void ProcessSiteClass(ModuleDefinition moduleDef, TypeDefinition td)
         {
             //Console.WriteLine("    ProcessSiteClass " + td);
             foreach (MethodDefinition md in td.Methods)
@@ -1071,7 +1073,7 @@ static void ProcessSiteClass(ModuleDefinition moduleDef, TypeDefinition td)
             }
         }
 
-        static void ProcessSitesModule(ModuleDefinition moduleDef)
+        void ProcessSitesModule(ModuleDefinition moduleDef)
         {
             var startTime = System.DateTime.Now;
 
@@ -1086,47 +1088,47 @@ static void ProcessSitesModule(ModuleDefinition moduleDef)
             if (lists.generateContainerClass != null)
             {
                 moduleDef.Types.Add(lists.generateContainerClass);
-                scriptDef.MainModule.ImportReference(lists.generateContainerClass);
+                m_ScriptDef.MainModule.ImportReference(lists.generateContainerClass);
 
                 foreach (var f in lists.generatedReadFunctions)
                 {
-                    scriptDef.MainModule.ImportReference(f);
+                    m_ScriptDef.MainModule.ImportReference(f);
                 }
 
                 foreach (var f in lists.generatedWriteFunctions)
                 {
-                    scriptDef.MainModule.ImportReference(f);
+                    m_ScriptDef.MainModule.ImportReference(f);
                 }
             }
             Console.WriteLine("  ProcessSitesModule " + moduleDef.Name + " elapsed time:" + (System.DateTime.Now - startTime));
         }
 
-        static void ProcessPropertySites()
+        void ProcessPropertySites()
         {
-            ProcessSitesModule(scriptDef.MainModule);
+            ProcessSitesModule(m_ScriptDef.MainModule);
         }
 
-        static bool ProcessMessageType(TypeDefinition td)
+        bool ProcessMessageType(TypeDefinition td)
         {
-            var proc = new MessageClassProcessor(td);
+            var proc = new MessageClassProcessor(td, this);
             proc.Process();
             return true;
         }
 
-        static bool ProcessSyncListStructType(TypeDefinition td)
+        bool ProcessSyncListStructType(TypeDefinition td)
         {
-            var proc = new SyncListStructProcessor(td);
+            var proc = new SyncListStructProcessor(td, this);
             proc.Process();
             return true;
         }
 
-        static void ProcessMonoBehaviourType(TypeDefinition td)
+        void ProcessMonoBehaviourType(TypeDefinition td)
         {
-            var proc = new MonoBehaviourProcessor(td);
+            var proc = new MonoBehaviourProcessor(td, this);
             proc.Process();
         }
 
-        static bool ProcessNetworkBehaviourType(TypeDefinition td)
+        bool ProcessNetworkBehaviourType(TypeDefinition td)
         {
             foreach (var md in td.Resolve().Methods)
             {
@@ -1138,12 +1140,12 @@ static bool ProcessNetworkBehaviourType(TypeDefinition td)
             }
             DLog(td, "Found NetworkBehaviour " + td.FullName);
 
-            NetworkBehaviourProcessor proc = new NetworkBehaviourProcessor(td);
+            NetworkBehaviourProcessor proc = new NetworkBehaviourProcessor(td, this);
             proc.Process();
             return true;
         }
 
-        public static MethodReference ResolveMethod(TypeReference t, string name)
+        public MethodReference ResolveMethod(TypeReference t, string name)
         {
             //Console.WriteLine("ResolveMethod " + t.ToString () + " " + name);
             if (t == null)
@@ -1156,7 +1158,7 @@ public static MethodReference ResolveMethod(TypeReference t, string name)
             {
                 if (methodRef.Name == name)
                 {
-                    return scriptDef.MainModule.ImportReference(methodRef);
+                    return m_ScriptDef.MainModule.ImportReference(methodRef);
                 }
             }
             Log.Error("ResolveMethod failed " + t.Name + "::" + name + " " + t.Resolve());
@@ -1171,7 +1173,7 @@ public static MethodReference ResolveMethod(TypeReference t, string name)
             return null;
         }
 
-        static MethodReference ResolveMethodWithArg(TypeReference t, string name, TypeReference argType)
+        MethodReference ResolveMethodWithArg(TypeReference t, string name, TypeReference argType)
         {
             foreach (var methodRef in t.Resolve().Methods)
             {
@@ -1181,7 +1183,7 @@ static MethodReference ResolveMethodWithArg(TypeReference t, string name, TypeRe
                     {
                         if (methodRef.Parameters[0].ParameterType.FullName == argType.FullName)
                         {
-                            return scriptDef.MainModule.ImportReference(methodRef);
+                            return m_ScriptDef.MainModule.ImportReference(methodRef);
                         }
                     }
                 }
@@ -1191,7 +1193,7 @@ static MethodReference ResolveMethodWithArg(TypeReference t, string name, TypeRe
             return null;
         }
 
-        static MethodDefinition ResolveDefaultPublicCtor(TypeReference variable)
+        MethodDefinition ResolveDefaultPublicCtor(TypeReference variable)
         {
             foreach (MethodDefinition methodRef in variable.Resolve().Methods)
             {
@@ -1205,7 +1207,7 @@ static MethodDefinition ResolveDefaultPublicCtor(TypeReference variable)
             return null;
         }
 
-        static GenericInstanceMethod ResolveMethodGeneric(TypeReference t, string name, TypeReference genericType)
+        GenericInstanceMethod ResolveMethodGeneric(TypeReference t, string name, TypeReference genericType)
         {
             foreach (var methodRef in t.Resolve().Methods)
             {
@@ -1215,7 +1217,7 @@ static GenericInstanceMethod ResolveMethodGeneric(TypeReference t, string name,
                     {
                         if (methodRef.GenericParameters.Count == 1)
                         {
-                            MethodReference tmp = scriptDef.MainModule.ImportReference(methodRef);
+                            MethodReference tmp = m_ScriptDef.MainModule.ImportReference(methodRef);
                             GenericInstanceMethod gm = new GenericInstanceMethod(tmp);
                             gm.GenericArguments.Add(genericType);
                             if (gm.GenericArguments[0].FullName == genericType.FullName)
@@ -1232,31 +1234,31 @@ static GenericInstanceMethod ResolveMethodGeneric(TypeReference t, string name,
             return null;
         }
 
-        public static FieldReference ResolveField(TypeReference t, string name)
+        public FieldReference ResolveField(TypeReference t, string name)
         {
             foreach (FieldDefinition fd in t.Resolve().Fields)
             {
                 if (fd.Name == name)
                 {
-                    return scriptDef.MainModule.ImportReference(fd);
+                    return m_ScriptDef.MainModule.ImportReference(fd);
                 }
             }
             return null;
         }
 
-        public static MethodReference ResolveProperty(TypeReference t, string name)
+        public MethodReference ResolveProperty(TypeReference t, string name)
         {
             foreach (var fd in t.Resolve().Properties)
             {
                 if (fd.Name == name)
                 {
-                    return scriptDef.MainModule.ImportReference(fd.GetMethod);
+                    return m_ScriptDef.MainModule.ImportReference(fd.GetMethod);
                 }
             }
             return null;
         }
 
-        static void SetupUnityTypes()
+        void SetupUnityTypes()
         {
             vector2Type = m_UnityAssemblyDefinition.MainModule.GetType("UnityEngine.Vector2");
             vector3Type = m_UnityAssemblyDefinition.MainModule.GetType("UnityEngine.Vector3");
@@ -1292,23 +1294,23 @@ static void SetupUnityTypes()
             SyncListStringType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.SyncListString");
         }
 
-        static void SetupCorLib()
+        void SetupCorLib()
         {
             var name = AssemblyNameReference.Parse("mscorlib");
             var parameters = new ReaderParameters
             {
-                AssemblyResolver = scriptDef.MainModule.AssemblyResolver,
+                AssemblyResolver = m_ScriptDef.MainModule.AssemblyResolver,
             };
-            corLib = scriptDef.MainModule.AssemblyResolver.Resolve(name, parameters).MainModule;
+            m_CorLib = m_ScriptDef.MainModule.AssemblyResolver.Resolve(name, parameters).MainModule;
         }
 
-        static TypeReference ImportCorLibType(string fullName)
+        TypeReference ImportCorLibType(string fullName)
         {
-            var type = corLib.GetType(fullName) ?? corLib.ExportedTypes.First(t => t.FullName == fullName).Resolve();
-            return scriptDef.MainModule.ImportReference(type);
+            var type = m_CorLib.GetType(fullName) ?? m_CorLib.ExportedTypes.First(t => t.FullName == fullName).Resolve();
+            return m_ScriptDef.MainModule.ImportReference(type);
         }
 
-        static void SetupTargetTypes()
+        void SetupTargetTypes()
         {
             // system types
             SetupCorLib();
@@ -1379,13 +1381,13 @@ static void SetupTargetTypes()
 
             CmdDelegateReference = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.NetworkBehaviour/CmdDelegate");
             CmdDelegateConstructor = ResolveMethod(CmdDelegateReference, ".ctor");
-            scriptDef.MainModule.ImportReference(gameObjectType);
-            scriptDef.MainModule.ImportReference(transformType);
+            m_ScriptDef.MainModule.ImportReference(gameObjectType);
+            m_ScriptDef.MainModule.ImportReference(transformType);
 
             TypeReference unetViewTmp = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.NetworkIdentity");
-            NetworkIdentityType = scriptDef.MainModule.ImportReference(unetViewTmp);
+            NetworkIdentityType = m_ScriptDef.MainModule.ImportReference(unetViewTmp);
 
-            NetworkInstanceIdType = scriptDef.MainModule.ImportReference(NetworkInstanceIdType);
+            NetworkInstanceIdType = m_ScriptDef.MainModule.ImportReference(NetworkInstanceIdType);
 
             SyncListFloatReadType = ResolveMethod(SyncListFloatType, "ReadReference");
             SyncListIntReadType = ResolveMethod(SyncListIntType, "ReadReference");
@@ -1401,20 +1403,20 @@ static void SetupTargetTypes()
 
 
             NetworkBehaviourType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.NetworkBehaviour");
-            NetworkBehaviourType2 = scriptDef.MainModule.ImportReference(NetworkBehaviourType);
+            NetworkBehaviourType2 = m_ScriptDef.MainModule.ImportReference(NetworkBehaviourType);
             NetworkConnectionType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.NetworkConnection");
 
             MonoBehaviourType = m_UnityAssemblyDefinition.MainModule.GetType("UnityEngine.MonoBehaviour");
             ScriptableObjectType = m_UnityAssemblyDefinition.MainModule.GetType("UnityEngine.ScriptableObject");
 
             NetworkConnectionType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.NetworkConnection");
-            NetworkConnectionType = scriptDef.MainModule.ImportReference(NetworkConnectionType);
+            NetworkConnectionType = m_ScriptDef.MainModule.ImportReference(NetworkConnectionType);
 
             ULocalConnectionToServerType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.ULocalConnectionToServer");
-            ULocalConnectionToServerType = scriptDef.MainModule.ImportReference(ULocalConnectionToServerType);
+            ULocalConnectionToServerType = m_ScriptDef.MainModule.ImportReference(ULocalConnectionToServerType);
 
             ULocalConnectionToClientType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.ULocalConnectionToClient");
-            ULocalConnectionToClientType = scriptDef.MainModule.ImportReference(ULocalConnectionToClientType);
+            ULocalConnectionToClientType = m_ScriptDef.MainModule.ImportReference(ULocalConnectionToClientType);
 
             MessageBaseType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.MessageBase");
             SyncListStructType = m_UNetAssemblyDefinition.MainModule.GetType("UnityEngine.Networking.SyncListStruct`1");
@@ -1454,13 +1456,13 @@ static void SetupTargetTypes()
             sendTargetRpcInternal = ResolveMethod(NetworkBehaviourType, "SendTargetRPCInternal");
             sendEventInternal = ResolveMethod(NetworkBehaviourType, "SendEventInternal");
 
-            SyncListType = scriptDef.MainModule.ImportReference(SyncListType);
+            SyncListType = m_ScriptDef.MainModule.ImportReference(SyncListType);
             SyncListInitBehaviourReference = ResolveMethod(SyncListType, "InitializeBehaviour");
             SyncListInitHandleMsg = ResolveMethod(SyncListType, "HandleMsg");
             SyncListClear = ResolveMethod(SyncListType, "Clear");
         }
 
-        static void SetupReadFunctions()
+        void SetupReadFunctions()
         {
             lists.readFuncs = new Dictionary<string, MethodReference>
             {
@@ -1507,7 +1509,7 @@ static void SetupReadFunctions()
             };
         }
 
-        static void SetupWriteFunctions()
+        void SetupWriteFunctions()
         {
             lists.writeFuncs = new Dictionary<string, MethodReference>
             {
@@ -1550,7 +1552,7 @@ static void SetupWriteFunctions()
             };
         }
 
-        static bool IsNetworkBehaviour(TypeDefinition td)
+        bool IsNetworkBehaviour(TypeDefinition td)
         {
             if (!td.IsClass)
                 return false;
@@ -1577,7 +1579,7 @@ static bool IsNetworkBehaviour(TypeDefinition td)
             return false;
         }
 
-        static public bool IsDerivedFrom(TypeDefinition td, TypeReference baseClass)
+        public bool IsDerivedFrom(TypeDefinition td, TypeReference baseClass)
         {
             if (!td.IsClass)
                 return false;
@@ -1613,12 +1615,12 @@ static public bool IsDerivedFrom(TypeDefinition td, TypeReference baseClass)
             return false;
         }
 
-        public static bool IsValidTypeToGenerate(TypeDefinition variable)
+        public bool IsValidTypeToGenerate(TypeDefinition variable)
         {
             // a valid type is a simple class or struct. so we generate only code for types we dont know, and if they are not inside
             // this assembly it must mean that we are trying to serialize a variable outside our scope. and this will fail.
 
-            string assembly = scriptDef.MainModule.Name;
+            string assembly = m_ScriptDef.MainModule.Name;
             if (variable.Module.Name == assembly)
                 return true;
 
@@ -1630,7 +1632,7 @@ public static bool IsValidTypeToGenerate(TypeDefinition variable)
             return false;
         }
 
-        static void CheckMonoBehaviour(TypeDefinition td)
+        void CheckMonoBehaviour(TypeDefinition td)
         {
             if (IsDerivedFrom(td, MonoBehaviourType))
             {
@@ -1638,7 +1640,7 @@ static void CheckMonoBehaviour(TypeDefinition td)
             }
         }
 
-        static bool CheckNetworkBehaviour(TypeDefinition td)
+        bool CheckNetworkBehaviour(TypeDefinition td)
         {
             if (!td.IsClass)
                 return false;
@@ -1681,7 +1683,7 @@ static bool CheckNetworkBehaviour(TypeDefinition td)
             return didWork;
         }
 
-        static bool CheckMessageBase(TypeDefinition td)
+        bool CheckMessageBase(TypeDefinition td)
         {
             if (!td.IsClass)
                 return false;
@@ -1718,7 +1720,7 @@ static bool CheckMessageBase(TypeDefinition td)
             return didWork;
         }
 
-        static bool CheckSyncListStruct(TypeDefinition td)
+        bool CheckSyncListStruct(TypeDefinition td)
         {
             if (!td.IsClass)
                 return false;
@@ -1755,18 +1757,21 @@ static bool CheckSyncListStruct(TypeDefinition td)
             return didWork;
         }
 
-        static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyResolver assemblyResolver, string unityEngineDLLPath, string unityUNetDLLPath, string outputDir)
+        bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyResolver assemblyResolver, string unityEngineDLLPath, string unityUNetDLLPath, string outputDir)
         {
             var readParams = Helpers.ReaderParameters(assName, dependencies, assemblyResolver, unityEngineDLLPath, unityUNetDLLPath);
 
             string pdbToDelete = null;
-            using (scriptDef = AssemblyDefinition.ReadAssembly(assName, readParams))
+            using (m_UnityAssemblyDefinition = AssemblyDefinition.ReadAssembly(unityEngineDLLPath))
+            using (m_ScriptDef = AssemblyDefinition.ReadAssembly(assName, readParams))
+            using (m_UNetAssemblyDefinition = AssemblyDefinition.ReadAssembly(unityUNetDLLPath))
             {
+                SetupUnityTypes();
                 SetupTargetTypes();
                 SetupReadFunctions();
                 SetupWriteFunctions();
 
-                ModuleDefinition moduleDefinition = scriptDef.MainModule;
+                ModuleDefinition moduleDefinition = m_ScriptDef.MainModule;
                 Console.WriteLine("Script Module: {0}", moduleDefinition.Name);
 
                 // Process each NetworkBehaviour
@@ -1794,8 +1799,8 @@ static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyRes
                             }
                             catch (Exception ex)
                             {
-                                if (scriptDef.MainModule.SymbolReader != null)
-                                    scriptDef.MainModule.SymbolReader.Dispose();
+                                if (m_ScriptDef.MainModule.SymbolReader != null)
+                                    m_ScriptDef.MainModule.SymbolReader.Dispose();
                                 fail = true;
                                 throw ex;
                             }
@@ -1803,8 +1808,8 @@ static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyRes
 
                         if (fail)
                         {
-                            if (scriptDef.MainModule.SymbolReader != null)
-                                scriptDef.MainModule.SymbolReader.Dispose();
+                            if (m_ScriptDef.MainModule.SymbolReader != null)
+                                m_ScriptDef.MainModule.SymbolReader.Dispose();
                             return false;
                         }
                     }
@@ -1829,8 +1834,8 @@ static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyRes
                     catch (Exception e)
                     {
                         Log.Error("ProcessPropertySites exception: " + e);
-                        if (scriptDef.MainModule.SymbolReader != null)
-                            scriptDef.MainModule.SymbolReader.Dispose();
+                        if (m_ScriptDef.MainModule.SymbolReader != null)
+                            m_ScriptDef.MainModule.SymbolReader.Dispose();
                         return false;
                     }
 
@@ -1838,8 +1843,8 @@ static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyRes
                     if (fail)
                     {
                         //Log.Error("Failed phase II.");
-                        if (scriptDef.MainModule.SymbolReader != null)
-                            scriptDef.MainModule.SymbolReader.Dispose();
+                        if (m_ScriptDef.MainModule.SymbolReader != null)
+                            m_ScriptDef.MainModule.SymbolReader.Dispose();
                         return false;
                     }
 
@@ -1861,11 +1866,11 @@ static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyRes
                         pdbToDelete = Path.ChangeExtension(assName, ".pdb");
                     }
                     
-                    scriptDef.Write(writeParams);
+                    m_ScriptDef.Write(writeParams);
                 }
                 
-                if (scriptDef.MainModule.SymbolReader != null)
-                    scriptDef.MainModule.SymbolReader.Dispose();
+                if (m_ScriptDef.MainModule.SymbolReader != null)
+                    m_ScriptDef.MainModule.SymbolReader.Dispose();
             }
 
             if (pdbToDelete != null)
@@ -1874,16 +1879,11 @@ static bool Weave(string assName, IEnumerable<string> dependencies, IAssemblyRes
             return true;
         }
 
-        public static bool WeaveAssemblies(IEnumerable<string> assemblies, IEnumerable<string> dependencies, IAssemblyResolver assemblyResolver, string outputDir, string unityEngineDLLPath, string unityUNetDLLPath)
+        public bool WeaveAssemblies(IEnumerable<string> assemblies, IEnumerable<string> dependencies, IAssemblyResolver assemblyResolver, string outputDir, string unityEngineDLLPath, string unityUNetDLLPath)
         {
             fail = false;
             lists = new WeaverLists();
 
-            m_UnityAssemblyDefinition = AssemblyDefinition.ReadAssembly(unityEngineDLLPath);
-            m_UNetAssemblyDefinition = AssemblyDefinition.ReadAssembly(unityUNetDLLPath);
-
-            SetupUnityTypes();
-
             try
             {
                 foreach (string ass in assemblies)
@@ -1899,7 +1899,7 @@ public static bool WeaveAssemblies(IEnumerable<string> assemblies, IEnumerable<s
                 Log.Error("Exception :" + e);
                 return false;
             }
-            corLib = null;
+            //corLib = null;
             return true;
         }
     }
diff --git a/package/Editor/WeaverRunner.cs b/package/Editor/WeaverRunner.cs
index 954e4962d..6d1383a14 100755
--- a/package/Editor/WeaverRunner.cs
+++ b/package/Editor/WeaverRunner.cs
@@ -37,7 +37,7 @@ static void OnCompilationFinished(string targetAssembly, CompilerMessage[] messa
             {
                 return;
             }
-            
+
             // Should not run on own assembly
             if (targetAssembly.Contains(k_HlapiRuntimeAssemblyName))
             {
@@ -101,7 +101,7 @@ static void OnCompilationFinished(string targetAssembly, CompilerMessage[] messa
                 {
                     try
                     {
-                        if (!assembly.IsDynamic)
+                        if (!(assembly.ManifestModule is System.Reflection.Emit.ModuleBuilder))
                             depenencyPaths.Add(Path.GetDirectoryName(Assembly.Load(assembly.GetName().Name).Location));
                     }
                     catch (FileNotFoundException) { }
diff --git a/package/Tests/Editor/WeaverILGenerationTests/WeaverILGenerationTests.cs b/package/Tests/Editor/WeaverILGenerationTests/WeaverILGenerationTests.cs
index ee62ea0e1..84fa32466 100755
--- a/package/Tests/Editor/WeaverILGenerationTests/WeaverILGenerationTests.cs
+++ b/package/Tests/Editor/WeaverILGenerationTests/WeaverILGenerationTests.cs
@@ -74,4 +74,13 @@ public void SyncListsNetworkBehaviourWithSyncListCallsBaseClassAwakeMethod()
             new MockInstruction(OpCodes.Call, "System.Void WeaverILGenerationTests_SyncLists_Base::Awake()")
             );
     }
+
+    [Test]
+    public void SyncNetworkBehaviourBaseClassPreStartClientMethodFromSubclass()
+    {
+        WeaverILMatcher.MatchMethodIL(typeof(WeaverILGenerationTests_SyncLists), "PreStartClient", false, 0, 1,
+            new MockInstruction(OpCodes.Ldarg_0),
+            new MockInstruction(OpCodes.Call, "System.Void WeaverILGenerationTests_SyncLists_Base::PreStartClient()")
+        );
+    }
 }
diff --git a/package/Tests/Runtime/WeaverILGenerationTests_Classes/WeaverILGenerationTests_SyncLists.cs b/package/Tests/Runtime/WeaverILGenerationTests_Classes/WeaverILGenerationTests_SyncLists.cs
index f6b135172..eb8576b1b 100755
--- a/package/Tests/Runtime/WeaverILGenerationTests_Classes/WeaverILGenerationTests_SyncLists.cs
+++ b/package/Tests/Runtime/WeaverILGenerationTests_Classes/WeaverILGenerationTests_SyncLists.cs
@@ -6,6 +6,7 @@
 #pragma warning disable 618
 public class WeaverILGenerationTests_SyncLists_Base : NetworkBehaviour
 {
+    [SyncVar] public GameObject baseSyncObject;
     void Awake()
     {
         Debug.Log("just here so compiler does not optimize away this");
@@ -16,10 +17,13 @@ public class WeaverILGenerationTests_SyncLists : WeaverILGenerationTests_SyncLis
 {
     public SyncListInt Inited = new SyncListInt();
 
-	// This can't be enabled by default as it will issue a warning from the weaver at compile time. This 
-	// warning will appear in all projects including the package and can mess with CI or automation which checks for output
-	// in the editor log.
+    // This can't be enabled by default as it will issue a warning from the weaver at compile time. This 
+    // warning will appear in all projects including the package and can mess with CI or automation which checks for output
+    // in the editor log.
     //[SyncVar]
     //public SyncListInt NotInited;
+
+    [SyncVar]
+    public GameObject syncObject;
 }
 #pragma warning restore 618
diff --git a/package/package.json b/package/package.json
index ff058d27a..cb08a104f 100755
--- a/package/package.json
+++ b/package/package.json
@@ -1,7 +1,7 @@
 {
   "name": "com.unity.multiplayer-hlapi",
   "displayName": "Multiplayer HLAPI",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "unity": "2019.1",
   "description": "The high level API component of the Unity Multiplayer system.",
   "keywords": [
@@ -17,6 +17,6 @@
   "repository": {
     "type": "git",
     "url": "https://gitlab.cds.internal.unity3d.com/upm-packages/multiplayer/com.unity.multiplayer-hlapi.git",
-    "revision": "4ef5b1ebf651f9e9455416b036b912d5871830f4"
+    "revision": "a46e55980cbb98565c4634779a8f7b98cce67736"
   }
 }
diff --git a/versions.txt b/versions.txt
index 3d32d383f..9b53b6514 100755
--- a/versions.txt
+++ b/versions.txt
@@ -14,3 +14,4 @@
 0.2.6-preview
 1.0.0
 1.0.1
+1.0.2