4.6.6

- Fixed UniversalTickSmoother moving incorrectly with non-Vector3.one scales.
- Fixed despawning root NetworkObjects with pooling causing nested NetworkObjects to not respawn automatically.
- Fixed conditional NullReferenceCondition in SceneCondition.
- Fixed nested runtime NetworkObjects not having their parent unset when their runtime parent was pooled.
- Fixed possible NullReferenceException within generated comparers for reference types.
- Fixed prediction reconciles corrupting class instance memory.
- Fixed NetworkTransform.ComponentConfiguration incorrectly making rigidbodies kinematic.
- Fixed limited memory leak on server related to predicted spawning.
- Fixed failed Predicted Spawns potentially pooling on clients, when expected to destroy.
- Fixed DefualtObjectPool now calls ResetState on nested NetworkObjects as well.
- Fixed possibility of nested NetworkObjects with modified InitializationOrder initializing before their parents.
- Fixed nested NetworkObjects not spawning when pooling.

- Improved logging for NetworkObject ObjectId fetching.
- Improved UniversalTickSmoother.SetSmootherProperties now allows specifying if for owner or spectator.
- Improved reduced NetworkBehaviour memory allocations.
- Improved Predicition attributed methods no longer need to be private.
- Improved ReserializenetworkObjects now uses Configuration settings when searching for prefabs.

- Added LoadSceneParameters to supported automatically serialized types.
- Added ObjectPool.AddPrefabObjects which returns added objects (#863).
- Added DefaultObjectPool.ClearPool(NetworkObject) to clear cache for specified NetworkObject type.

- Changed reverted NetworkObjects despawning when disabled.
- Changed restructured file paths; this may require you to delete FishNet before importing this version.
- Changed Tugboat.StopSocketsOnThread now defaulted to false.

Author: FirstGearGames

Assets/FishNet/CodeGenerating/Helpers/Extension/TypeDefinitionExtensions.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
+using UnityEngine.SceneManagement;
 
 namespace FishNet.CodeGenerating.Helping.Extension
 {
@@ -100,6 +101,9 @@ public static IEnumerable<PropertyDefinition> FindAllPublicProperties(this TypeD
         /// </summary>
         private static bool IsExcluded(TypeDefinition typeDef, System.Type[] excludedBaseTypes = null, string[] excludedAssemblyPrefixes = null)
         {
+            if (typeDef.FullName == typeof(LoadSceneParameters).FullName)
+                return false;
+            
             if (excludedBaseTypes != null)
             {
                 foreach (System.Type t in excludedBaseTypes)

Assets/FishNet/CodeGenerating/Helpers/GeneralHelper.cs

@@ -1188,7 +1188,58 @@ void CreateGenericInstanceComparer()
                 void CreateClassOrStructComparer()
                 {
                     //Class or struct.
-                    Instruction exitMethodInst = processor.Create(OpCodes.Ldc_I4_0);
+                    Instruction falseLdcInst = processor.Create(OpCodes.Ldc_I4_0);
+
+                    //Non-value type null check.
+                    if (!dataTr.IsValueType)
+                    {
+                        GeneralHelper gh = base.GetClass<GeneralHelper>();
+
+                        Instruction checkNullAndNotNullInst = Instruction.Create(OpCodes.Nop);
+
+                        VariableDefinition isNullV0 = gh.CreateVariable(comparerMd, typeof(bool));
+                        VariableDefinition isNullV1 = gh.CreateVariable(comparerMd, typeof(bool));
+                        
+                        //isNull0 = (value0 == null);
+                        processor.Emit(OpCodes.Ldarg, v0Pd);
+                        processor.Emit(OpCodes.Ldnull);
+                        processor.Emit(OpCodes.Ceq);
+                        processor.Emit(OpCodes.Stloc, isNullV0);
+                        //isNull1 = (value1 == null);
+                        processor.Emit(OpCodes.Ldarg, v1Pd);
+                        processor.Emit(OpCodes.Ldnull);
+                        processor.Emit(OpCodes.Ceq);
+                        processor.Emit(OpCodes.Stloc, isNullV1);
+
+                        //If (isNull0 && isNull1) return true;
+                        processor.Emit(OpCodes.Ldloc, isNullV0);
+                        processor.Emit(OpCodes.Ldloc, isNullV1);
+                        processor.Emit(OpCodes.And);
+                        processor.Emit(OpCodes.Brfalse, checkNullAndNotNullInst);
+                        processor.Emit(OpCodes.Ldc_I4_1);
+                        processor.Emit(OpCodes.Ret);
+                        //Skip past ret here.
+                        processor.Append(checkNullAndNotNullInst);
+
+                        //bool isNullOpposing = (isNull0 != isNull1);
+                        VariableDefinition isNullOpposingVd = gh.CreateVariable(comparerMd, typeof(bool));
+                        processor.Emit(OpCodes.Ldloc, isNullV0);
+                        processor.Emit(OpCodes.Ldloc, isNullV1);
+                        processor.Emit(OpCodes.Ceq);
+                        processor.Emit(OpCodes.Ldc_I4_0);
+                        processor.Emit(OpCodes.Ceq);
+                        processor.Emit(OpCodes.Stloc, isNullOpposingVd);
+                        
+                                                
+                        Instruction checkPropertiesInst = Instruction.Create(OpCodes.Nop);
+                        //if (isNullOpposing) return false;
+                        processor.Emit(OpCodes.Ldloc, isNullOpposingVd);
+                        processor.Emit(OpCodes.Brfalse, checkPropertiesInst);
+                        processor.Emit(OpCodes.Ldc_I4_0);
+                        processor.Emit(OpCodes.Ret);
+                        //Skip past ret here.
+                        processor.Append(checkPropertiesInst);
+                    }
 
                     //Fields.
                     foreach (FieldDefinition fieldDef in dataTr.FindAllSerializableFields(base.Session, null, WriterProcessor.EXCLUDED_ASSEMBLY_PREFIXES))
@@ -1203,7 +1254,7 @@ void CreateClassOrStructComparer()
                         processor.Emit(OpCodes.Ldfld, fr);
                         FinishTypeReferenceCompare(fieldDef.FieldType);
                     }
-
+                    
                     //Properties.
                     foreach (PropertyDefinition propertyDef in dataTr.FindAllSerializableProperties(base.Session, null, WriterProcessor.EXCLUDED_ASSEMBLY_PREFIXES))
                     {
@@ -1217,14 +1268,14 @@ void CreateClassOrStructComparer()
                         processor.Emit(OpCodes.Call, getMr);
                         FinishTypeReferenceCompare(propertyDef.PropertyType);
                     }
-
+                    
                     //Return true;
                     processor.Emit(OpCodes.Ldc_I4_1);
                     processor.Emit(OpCodes.Ret);
-                    processor.Append(exitMethodInst);
+                    processor.Append(falseLdcInst);
                     processor.Emit(OpCodes.Ret);
 
-
+                    
                     void FinishTypeReferenceCompare(TypeReference tr)
                     {
                         /* If a class or struct see if it already has a comparer
@@ -1240,7 +1291,7 @@ void FinishTypeReferenceCompare(TypeReference tr)
                             {
                                 MethodDefinition cMd = CreateEqualityComparer(tr);
                                 processor.Emit(OpCodes.Call, cMd);
-                                processor.Emit(OpCodes.Brfalse, exitMethodInst);
+                                processor.Emit(OpCodes.Brfalse, falseLdcInst);
                             }
                             //Call existing.
                             else
@@ -1255,14 +1306,14 @@ void FinishTypeReferenceCompare(TypeReference tr)
                                 {
                                     MethodReference mr = base.ImportReference(cMd);
                                     processor.Emit(OpCodes.Call, mr);
-                                    processor.Emit(OpCodes.Brfalse, exitMethodInst);
+                                    processor.Emit(OpCodes.Brfalse, falseLdcInst);
                                 }
                             }
                         }
                         //Value types do not need to check custom comparers.
                         else
                         {
-                            processor.Emit(OpCodes.Bne_Un, exitMethodInst);
+                            processor.Emit(OpCodes.Bne_Un, falseLdcInst);
                         }
                     }
                 }

Assets/FishNet/CodeGenerating/Helpers/NetworkBehaviourHelper.cs

@@ -33,7 +33,7 @@ internal class NetworkBehaviourHelper : CodegenBase
         public MethodReference Replicate_Replay_Start_MethodRef;
         public MethodReference Replicate_Current_MethodRef;
         public MethodReference Reconcile_Client_MethodRef;
-        public MethodReference Reconcile_Client_Local_MethodRef;
+        public MethodReference Reconcile_Current_MethodRef;
         public MethodReference ClearReplicateCache_Internal_MethodRef;
         public MethodReference Replicate_Replay_MethodRef;
         public MethodReference Reconcile_Reader_MethodRef;
@@ -136,10 +136,10 @@ public override bool ImportReferences()
                     Reconcile_Reader_MethodRef = base.ImportReference(mi);
                 else if (mi.Name == nameof(NetworkBehaviour.Reconcile_Server))
                     Reconcile_Server_MethodRef = base.ImportReference(mi);
-                else if (mi.Name == nameof(NetworkBehaviour.Reconcile_Client))
+                else if (mi.Name == nameof(NetworkBehaviour.Reconcile_Client)) 
                     Reconcile_Client_MethodRef = base.ImportReference(mi);
-                else if (mi.Name == nameof(NetworkBehaviour.Reconcile_Client_Local))
-                    Reconcile_Client_Local_MethodRef = base.ImportReference(mi);
+                else if (mi.Name == nameof(NetworkBehaviour.Reconcile_Current))
+                    Reconcile_Current_MethodRef = base.ImportReference(mi);
                 else if (mi.Name == nameof(NetworkBehaviour.ClearReplicateCache_Internal))
                     ClearReplicateCache_Internal_MethodRef = base.ImportReference(mi);
             }

Assets/FishNet/CodeGenerating/ILCore/FishNetILPP.cs

@@ -5,8 +5,6 @@
 using FishNet.CodeGenerating.Processing;
 using FishNet.CodeGenerating.Processing.Rpc;
 using FishNet.Configuring;
-using FishNet.Editing.Upgrading;
-using FishNet.Serializing.Helping;
 using MonoFN.Cecil;
 using MonoFN.Cecil.Cil;
 using System;
@@ -122,8 +120,6 @@ public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
             }
             else
             {
-                TryLogV3ToV4Helpers(session);
-
                 MemoryStream pe = new();
                 MemoryStream pdb = new();
                 WriterParameters writerParameters = new()
@@ -136,24 +132,7 @@ public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
                 return new(new(pe.ToArray(), pdb.ToArray()), session.Diagnostics);
             }
         }
-
-        /// <summary>
-        /// Logs warning if v3 to v4 helpers are enabled.
-        /// </summary>
-        private void TryLogV3ToV4Helpers(CodegenSession session)
-        {
-#if !FISHNET_DISABLE_V3TOV4_HELPERS
-            /* There is no way to check if this has run already once per codegen
-             * so the only option is to print per session, which means
-             * a print will occur every time an assembly compiles. This means
-             * several prints will potentially occur per script change.
-             * 
-             * However, these warnings typically only print when all errors are gone.
-             * When this is true the user may go ahead and disable this warning
-             * as instructed. */
-            session.LogWarning(UpgradeFromV3ToV4Menu.EnabledWarning);
-#endif
-        }
+        
 
         /// <summary>
         /// Makees methods public scope which use CodegenMakePublic attribute.

Assets/FishNet/CodeGenerating/Processing/Prediction/PredictionProcessor.cs

@@ -263,18 +263,21 @@ bool CheckCreateReconcile(MethodDefinition reconcileMd)
                         }
                     }
 
-                    base.LogError($"{reconcileMd.DeclaringType.Name} implements {crName} but does not call reconcile method {reconcileMd.Name}.");
+                    base.LogError($"{reconcileMd.DeclaringType.Name} implements {crName} but does not call reconcile method {reconcileMd.Name}. If you are calling CreateReconcile from another type please make a new method to call in {reconcileMd.DeclaringType.Name}, which in return calls CreateReconcile.");
                     //Fallthrough.
                     return false;
                 }
             }
 
             bool MethodIsPrivate(MethodDefinition md)
             {
-                bool isPrivate = md.Attributes.HasFlag(MethodAttributes.Private);
-                if (!isPrivate)
-                    base.LogError($"Method {md.Name} within {typeDef.Name} is a prediction method and must be private.");
-                return isPrivate;
+                //Do we actually need private checks anymore?
+                return true;
+
+                // bool isPrivate = md.Attributes.HasFlag(MethodAttributes.Private);
+                // if (!isPrivate)
+                //     base.LogError($"Method {md.Name} within {typeDef.Name} is a prediction method and must be private.");
+                // return isPrivate;
             }
 
             bool AlreadyFound(MethodDefinition md)
@@ -382,7 +385,7 @@ internal bool Process(TypeDefinition typeDef)
         private bool TickFieldIsNonSerializable(TypeDefinition dataTd, bool replicate)
         {
             string methodName = (replicate) ? IReplicateData_GetTick_MethodRef.Name : IReconcileData_GetTick_MethodRef.Name;
-            MethodDefinition getMd = dataTd.GetMethod(methodName);
+            MethodDefinition getMd = dataTd.GetMethodDefinitionInAnyBase(base.Session, methodName);
 
             //Try to find ldFld.
             Instruction ldFldInst = null;
@@ -398,18 +401,16 @@ private bool TickFieldIsNonSerializable(TypeDefinition dataTd, bool replicate)
             //If ldFld not found.
             if (ldFldInst == null)
             {
-                base.LogError($"{dataTd.FullName} method {getMd.Name} does not return a field type for the Tick. Make a new private field of uint type and return it's value within {getMd.Name}.");
+                base.LogError($"{dataTd.FullName} method {getMd.Name} does not return a field type for the Tick. Make a new private or protected field of uint type and return it's value within {getMd.Name}.");
                 return false;
             }
-            //Make sure the field is private.
-            else
+
+            //Make sure the field is correct accessibility
+            FieldDefinition fd = (FieldDefinition)ldFldInst.Operand;
+            if (!fd.Attributes.HasFlag(FieldAttributes.Private) && !fd.Attributes.HasFlag(FieldAttributes.Family))
             {
-                FieldDefinition fd = (FieldDefinition)ldFldInst.Operand;
-                if (!fd.Attributes.HasFlag(FieldAttributes.Private))
-                {
-                    base.LogError($"{dataTd.FullName} method {getMd.Name} returns a tick field but it's not marked as private. Make the field {fd.Name} private.");
-                    return false;
-                }
+                base.LogError($"{dataTd.FullName} method {getMd.Name} returns a tick field it does not have the correct accessibility. Make the field {fd.Name} private or protected.");
+                return false;
             }
 
             //All checks pass.
@@ -1014,24 +1015,23 @@ private void ServerCreateReconcile(MethodDefinition reconcileMd, CreatedPredicti
             NetworkBehaviourHelper nbh = base.GetClass<NetworkBehaviourHelper>();
             GenericInstanceMethod methodGim;
 
-            /* Reconcile_Client_Local. */
-            methodGim = nbh.Reconcile_Client_Local_MethodRef.MakeGenericMethod(new TypeReference[] { reconcileDataPd.ParameterType });
-
-            processor.Emit(OpCodes.Ldarg_0);
-            processor.Emit(OpCodes.Ldarg_0);
-            processor.Emit(OpCodes.Ldfld, predictionFields.LocalReconciles);
-            processor.Emit(OpCodes.Ldarg, reconcileDataPd);
-            processor.Emit(OpCodes.Call, methodGim);
-
-            /* Reconcile_Server. */
-            methodGim = nbh.Reconcile_Server_MethodRef.MakeGenericMethod(new TypeReference[] { reconcileDataPd.ParameterType });
+            /* Reconcile_Current. */
+            methodGim = nbh.Reconcile_Current_MethodRef.MakeGenericMethod(new TypeReference[] { reconcileDataPd.ParameterType });
 
+            //Hash.
             processor.Emit(OpCodes.Ldarg_0);
             processor.Emit(OpCodes.Ldc_I4, (int)rpcCount);
+            //Last reconcile data.
             processor.Emit(OpCodes.Ldarg_0);
             processor.Emit(OpCodes.Ldflda, predictionFields.LastReadReconcile);
+            //Reconciles history (local reconciles).
+            processor.Emit(OpCodes.Ldarg_0);
+            processor.Emit(OpCodes.Ldfld, predictionFields.LocalReconciles);
+            //Data.
             processor.Emit(OpCodes.Ldarg, reconcileDataPd);
+            //Channel.
             processor.Emit(OpCodes.Ldarg, channelPd);
+            
             processor.Emit(OpCodes.Call, methodGim);
 
             rpcCount++;