refactor!: rename types consistently

CONTRIBUTING.md

@@ -75,7 +75,7 @@ If the change isn't backwards compatible. You have to disclose that in the foote
 ```
 perf(networked-vars): Improved performance by removing duplex functionality
 
-BREAKING CHANGE: Removes duplex functionality from networked vars in order to improve performance
+BREAKING CHANGE: Removes duplex functionality from network variables in order to improve performance
 ```
 Samples:
 

com.unity.multiplayer.mlapi/Editor/CodeGen/CodeGenHelpers.cs

@@ -22,7 +22,7 @@ internal static class CodeGenHelpers
     {
         public const string RuntimeAssemblyName = "Unity.Multiplayer.MLAPI.Runtime";
 
-        public static readonly string NetworkBehaviour_FullName = typeof(NetworkedBehaviour).FullName;
+        public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName;
         public static readonly string ServerRpcAttribute_FullName = typeof(ServerRpcAttribute).FullName;
         public static readonly string ClientRpcAttribute_FullName = typeof(ClientRpcAttribute).FullName;
         public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;

com.unity.multiplayer.mlapi/Editor/CodeGen/RuntimeAccessModifiersILPP.cs

@@ -41,10 +41,10 @@ public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
 
                     switch (typeDefinition.Name)
                     {
-                        case nameof(NetworkingManager):
+                        case nameof(NetworkManager):
                             ProcessNetworkManager(typeDefinition);
                             break;
-                        case nameof(NetworkedBehaviour):
+                        case nameof(NetworkBehaviour):
                             ProcessNetworkBehaviour(typeDefinition);
                             break;
                         case nameof(Messaging.__RpcParams):
@@ -75,7 +75,7 @@ private void ProcessNetworkManager(TypeDefinition typeDefinition)
         {
             foreach (var fieldDefinition in typeDefinition.Fields)
             {
-                if (fieldDefinition.Name == nameof(NetworkingManager.__ntable))
+                if (fieldDefinition.Name == nameof(NetworkManager.__ntable))
                 {
                     fieldDefinition.IsPublic = true;
                 }
@@ -86,15 +86,15 @@ private void ProcessNetworkBehaviour(TypeDefinition typeDefinition)
         {
             foreach (var nestedType in typeDefinition.NestedTypes)
             {
-                if (nestedType.Name == nameof(NetworkedBehaviour.__NExec))
+                if (nestedType.Name == nameof(NetworkBehaviour.__NExec))
                 {
                     nestedType.IsNestedFamily = true;
                 }
             }
 
             foreach (var fieldDefinition in typeDefinition.Fields)
             {
-                if (fieldDefinition.Name == nameof(NetworkedBehaviour.__nexec))
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__nexec))
                 {
                     fieldDefinition.IsFamily = true;
                 }
@@ -104,10 +104,10 @@ private void ProcessNetworkBehaviour(TypeDefinition typeDefinition)
             {
                 switch (methodDefinition.Name)
                 {
-                    case nameof(NetworkedBehaviour.__beginSendServerRpc):
-                    case nameof(NetworkedBehaviour.__endSendServerRpc):
-                    case nameof(NetworkedBehaviour.__beginSendClientRpc):
-                    case nameof(NetworkedBehaviour.__endSendClientRpc):
+                    case nameof(NetworkBehaviour.__beginSendServerRpc):
+                    case nameof(NetworkBehaviour.__endSendServerRpc):
+                    case nameof(NetworkBehaviour.__beginSendClientRpc):
+                    case nameof(NetworkBehaviour.__endSendClientRpc):
                         methodDefinition.IsFamily = true;
                         break;
                 }

com.unity.multiplayer.mlapi/Editor/MLAPIProfiler.cs

@@ -3,7 +3,6 @@
 using MLAPI.Profiling;
 using MLAPI.Serialization;
 using UnityEngine;
-using BitStream = MLAPI.Serialization.BitStream;
 
 namespace UnityEditor
 {
@@ -43,28 +42,28 @@ class ProfilerContainer
 
             public byte[] ToBytes()
 			{
-				BitStream stream = new BitStream();
-				BitWriter writer = new BitWriter(stream);
+				NetworkBuffer buffer = new NetworkBuffer();
+				NetworkWriter writer = new NetworkWriter(buffer);
 				writer.WriteUInt16Packed((ushort)ticks.Length);
 
 				for (int i = 0; i < ticks.Length; i++)
 				{
-					ticks[i].SerializeToStream(stream);
+					ticks[i].SerializeToStream(buffer);
 				}
 
-				return stream.ToArray();
+				return buffer.ToArray();
 			}
 
 			public static ProfilerContainer FromBytes(byte[] bytes)
 			{
 				ProfilerContainer container = new ProfilerContainer();
-				BitStream stream = new BitStream(bytes);
-				BitReader reader = new BitReader(stream);
+				NetworkBuffer buffer = new NetworkBuffer(bytes);
+				NetworkReader reader = new NetworkReader(buffer);
 				ushort count = reader.ReadUInt16Packed();
 				container.ticks = new ProfilerTick[count];
                 for (int i = 0; i < count; i++)
 				{
-					container.ticks[i] = ProfilerTick.FromStream(stream);
+					container.ticks[i] = ProfilerTick.FromStream(buffer);
 				}
 
 				return container;

com.unity.multiplayer.mlapi/Editor/NetworkedAnimatorEditor.cs → com.unity.multiplayer.mlapi/Editor/NetworkAnimatorEditor.cs

@@ -5,11 +5,11 @@
 
 namespace UnityEditor
 {
-    [CustomEditor(typeof(NetworkedAnimator), true)]
+    [CustomEditor(typeof(NetworkAnimator), true)]
     [CanEditMultipleObjects]
     public class NetworkAnimatorEditor : Editor
     {
-        private NetworkedAnimator m_Target;
+        private NetworkAnimator m_Target;
 
         [NonSerialized]
         private bool m_Initialized;
@@ -22,7 +22,7 @@ private void Initialize()
             if (m_Initialized) return;
 
             m_Initialized = true;
-            m_Target = target as NetworkedAnimator;
+            m_Target = target as NetworkAnimator;
 
             m_AnimatorProperty = serializedObject.FindProperty("m_Animator");
             m_AnimatorLabel = new GUIContent("Animator", "The Animator component to synchronize.");
@@ -34,7 +34,7 @@ private void DrawControls()
             EditorGUILayout.PropertyField(m_AnimatorProperty, m_AnimatorLabel);
             if (EditorGUI.EndChangeCheck()) m_Target.ResetTrackedParams();
 
-            var animator = m_Target.animator;
+            var animator = m_Target.Animator;
             if (ReferenceEquals(animator, null)) return;
 
             var animatorController = animator.runtimeAnimatorController as AnimatorController;

com.unity.multiplayer.mlapi/Editor/NetworkedBehaviourEditor.cs → com.unity.multiplayer.mlapi/Editor/NetworkBehaviourEditor.cs

@@ -2,47 +2,47 @@
 using System.Collections.Generic;
 using System.Reflection;
 using MLAPI;
-using MLAPI.NetworkedVar;
+using MLAPI.NetworkVariable;
 using UnityEngine;
 
 namespace UnityEditor
 {
-    [CustomEditor(typeof(NetworkedBehaviour), true)]
+    [CustomEditor(typeof(NetworkBehaviour), true)]
     [CanEditMultipleObjects]
-    public class NetworkedBehaviourEditor : Editor
+    public class NetworkBehaviourEditor : Editor
     {
         private bool initialized;
-        private List<string> networkedVarNames = new List<string>();
-        private Dictionary<string, FieldInfo> networkedVarFields = new Dictionary<string, FieldInfo>();
-        private Dictionary<string, object> networkedVarObjects = new Dictionary<string, object>();
-        
-        private GUIContent networkedVarLabelGuiContent;
+        private readonly List<string> networkVariableNames = new List<string>();
+        private readonly Dictionary<string, FieldInfo> networkVariableFields = new Dictionary<string, FieldInfo>();
+        private readonly Dictionary<string, object> networkVariableObjects = new Dictionary<string, object>();
+
+        private GUIContent networkVariableLabelGuiContent;
 
         private void Init(MonoScript script)
         {
             initialized = true;
 
-            networkedVarNames.Clear();
-            networkedVarFields.Clear();
-            networkedVarObjects.Clear();
+            networkVariableNames.Clear();
+            networkVariableFields.Clear();
+            networkVariableObjects.Clear();
 
-            networkedVarLabelGuiContent = new GUIContent("NetworkedVar", "This variable is a NetworkedVar. It can not be serialized and can only be changed during runtime.");
+            networkVariableLabelGuiContent = new GUIContent("NetworkVariable", "This variable is a NetworkVariable. It can not be serialized and can only be changed during runtime.");
 
             FieldInfo[] fields = script.GetClass().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
             for (int i = 0; i < fields.Length; i++)
             {
                 Type ft = fields[i].FieldType;
-                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkedVar<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkVariable<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
                 {
-                    networkedVarNames.Add(fields[i].Name);
-                    networkedVarFields.Add(fields[i].Name, fields[i]);
+                    networkVariableNames.Add(fields[i].Name);
+                    networkVariableFields.Add(fields[i].Name, fields[i]);
                 }
             }
         }
 
-        void RenderNetworkedVar(int index)
+        void RenderNetworkVariable(int index)
         {
-            if (!networkedVarFields.ContainsKey(networkedVarNames[index]))
+            if (!networkVariableFields.ContainsKey(networkVariableNames[index]))
             {
                 serializedObject.Update();
                 SerializedProperty scriptProperty = serializedObject.FindProperty("m_Script");
@@ -53,45 +53,45 @@ void RenderNetworkedVar(int index)
                 Init(targetScript);
             }
 
-            object value = networkedVarFields[networkedVarNames[index]].GetValue(target);
+            object value = networkVariableFields[networkVariableNames[index]].GetValue(target);
             if (value == null)
             {
-                Type fieldType = networkedVarFields[networkedVarNames[index]].FieldType;
-                INetworkedVar var = (INetworkedVar) Activator.CreateInstance(fieldType, true);
-                networkedVarFields[networkedVarNames[index]].SetValue(target, var);
+                Type fieldType = networkVariableFields[networkVariableNames[index]].FieldType;
+                INetworkVariable var = (INetworkVariable) Activator.CreateInstance(fieldType, true);
+                networkVariableFields[networkVariableNames[index]].SetValue(target, var);
             }
 
-            Type type = networkedVarFields[networkedVarNames[index]].GetValue(target).GetType();
+            Type type = networkVariableFields[networkVariableNames[index]].GetValue(target).GetType();
             Type genericType = type.GetGenericArguments()[0];
 
             EditorGUILayout.BeginHorizontal();
             if (genericType == typeof(string))
             {
-                NetworkedVar<string> var = (NetworkedVar<string>)networkedVarFields[networkedVarNames[index]].GetValue(target);
-                var.Value = EditorGUILayout.TextField(networkedVarNames[index], var.Value);
+                NetworkVariable<string> var = (NetworkVariable<string>)networkVariableFields[networkVariableNames[index]].GetValue(target);
+                var.Value = EditorGUILayout.TextField(networkVariableNames[index], var.Value);
             }
             else if (genericType.IsValueType)
             {
-                MethodInfo method = typeof(NetworkedBehaviourEditor).GetMethod("RenderNetworkedVarValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                MethodInfo method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkVariableValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
                 MethodInfo genericMethod = method.MakeGenericMethod(genericType);
-                genericMethod.Invoke(this, new object[] { (object)index });
+                genericMethod.Invoke(this, new[] { (object)index });
             }
             else
             {
                 EditorGUILayout.LabelField("Type not renderable");
             }
-            GUILayout.Label(networkedVarLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(networkedVarLabelGuiContent).x));
+            GUILayout.Label(networkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(networkVariableLabelGuiContent).x));
             EditorGUILayout.EndHorizontal();
         }
 
-        void RenderNetworkedVarValueType<T>(int index) where T : struct
+        void RenderNetworkVariableValueType<T>(int index) where T : struct
         {
-            NetworkedVar<T> var = (NetworkedVar<T>)networkedVarFields[networkedVarNames[index]].GetValue(target);
+            NetworkVariable<T> var = (NetworkVariable<T>)networkVariableFields[networkVariableNames[index]].GetValue(target);
             Type type = typeof(T);
             object val = var.Value;
-            string name = networkedVarNames[index];
+            string name = networkVariableNames[index];
 
-            if (NetworkingManager.Singleton != null && NetworkingManager.Singleton.IsListening)
+            if (NetworkManager.Singleton != null && NetworkManager.Singleton.IsListening)
             {
                 if (type == typeof(int))
                     val = EditorGUILayout.IntField(name, (int)val);
@@ -143,8 +143,8 @@ public override void OnInspectorGUI()
             EditorGUI.BeginChangeCheck();
             serializedObject.Update();
 
-            for (int i = 0; i < networkedVarNames.Count; i++)
-                RenderNetworkedVar(i);
+            for (int i = 0; i < networkVariableNames.Count; i++)
+                RenderNetworkVariable(i);
 
             SerializedProperty property = serializedObject.GetIterator();
             bool expanded = true;