Added SyncVar hooks

TwoTenPvP · TwoTenPvP · commit 965d644fb7f0 · 2018-03-13T08:58:41.000+01:00
diff --git a/MLAPI/Attributes/SyncedVar.cs b/MLAPI/Attributes/SyncedVar.cs
@@ -5,6 +5,11 @@ namespace MLAPI.Attributes
     [AttributeUsage(AttributeTargets.Field)]
     public class SyncedVar : Attribute
     {
+        public string hook;
 
+        public SyncedVar()
+        {
+            
+        }
     }
 }
diff --git a/MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs b/MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs
@@ -133,6 +133,7 @@ private void OnDestroy()
         private List<FieldInfo> syncedFields = new List<FieldInfo>();
         internal List<FieldType> syncedFieldTypes = new List<FieldType>();
         private List<object> syncedFieldValues = new List<object>();
+        private List<MethodInfo> syncedVarHooks = new List<MethodInfo>();
         //A dirty field is a field that's not synced.
         public bool[] dirtyFields;
         internal void SyncVarInit()
@@ -142,107 +143,134 @@ internal void SyncVarInit()
             {
                 if(sortedFields[i].IsDefined(typeof(SyncedVar), true))
                 {
+                    object[] syncedVarAttributes = sortedFields[i].GetCustomAttributes(typeof(SyncedVar), true);
+                    MethodInfo method = null;
+                    for (int j = 0; j < syncedVarAttributes.Length; j++)
+                    {
+                        if(!string.IsNullOrEmpty(((SyncedVar)syncedVarAttributes[j]).hook))
+                        {
+                            method = GetType().GetMethod(((SyncedVar)syncedVarAttributes[j]).hook, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
+                            break;
+                        }
+                    }
                     if (sortedFields[i].FieldType == typeof(bool))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Bool);
+                        syncedVarHooks.Add(method);
                     }
                     else if(sortedFields[i].FieldType == typeof(byte))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Byte);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(char))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Char);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(double))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Double);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(float))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Single);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(int))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Int);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(long))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Long);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(sbyte))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.SByte);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(short))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Short);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(uint))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.UInt);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(ulong))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.ULong);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(ushort))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.UShort);
+                        syncedVarHooks.Add(method);
                     }
                     else if(sortedFields[i].FieldType == typeof(string))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.String);
+                        syncedVarHooks.Add(method);
                     }
                     else if(sortedFields[i].FieldType == typeof(Vector3))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Vector3);
+                        syncedVarHooks.Add(method);
                     }
                     else if(sortedFields[i].FieldType == typeof(Vector2))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Vector2);
+                        syncedVarHooks.Add(method);
                     }
                     else if (sortedFields[i].FieldType == typeof(Quaternion))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.Quaternion);
+                        syncedVarHooks.Add(method);
                     }
                     else if(sortedFields[i].FieldType == typeof(byte[]))
                     {
                         syncedFields.Add(sortedFields[i]);
                         syncedFieldValues.Add(sortedFields[i].GetValue(this));
                         syncedFieldTypes.Add(FieldType.ByteArray);
+                        syncedVarHooks.Add(method);
                     }
                     else
                     {
@@ -260,6 +288,8 @@ internal void SyncVarInit()
         internal void OnSyncVarUpdate(object value, byte fieldIndex)
         {
             syncedFields[fieldIndex].SetValue(this, value);
+            if (syncedVarHooks[fieldIndex] != null)
+                syncedVarHooks[fieldIndex].Invoke(this, null);
         }
 
         internal void FlushToClient(int clientId)

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,11 @@ namespace MLAPI.Attributes`
`5`	`5`	`[AttributeUsage(AttributeTargets.Field)]`
`6`	`6`	`public class SyncedVar : Attribute`
`7`	`7`	`{`
	`8`	`+ public string hook;`
`8`	`9`
	`10`	`+ public SyncedVar()`
	`11`	`+ {`
	`12`	`+`
	`13`	`+ }`
`9`	`14`	`}`
`10`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,7 @@ private void OnDestroy()`
`133`	`133`	`private List<FieldInfo> syncedFields = new List<FieldInfo>();`
`134`	`134`	`internal List<FieldType> syncedFieldTypes = new List<FieldType>();`
`135`	`135`	`private List<object> syncedFieldValues = new List<object>();`
	`136`	`+ private List<MethodInfo> syncedVarHooks = new List<MethodInfo>();`
`136`	`137`	`//A dirty field is a field that's not synced.`
`137`	`138`	`public bool[] dirtyFields;`
`138`	`139`	`internal void SyncVarInit()`
`@@ -142,107 +143,134 @@ internal void SyncVarInit()`
`142`	`143`	`{`
`143`	`144`	`if(sortedFields[i].IsDefined(typeof(SyncedVar), true))`
`144`	`145`	`{`
	`146`	`+ object[] syncedVarAttributes = sortedFields[i].GetCustomAttributes(typeof(SyncedVar), true);`
	`147`	`+ MethodInfo method = null;`
	`148`	`+ for (int j = 0; j < syncedVarAttributes.Length; j++)`
	`149`	`+ {`
	`150`	`+ if(!string.IsNullOrEmpty(((SyncedVar)syncedVarAttributes[j]).hook))`
	`151`	`+ {`
	`152`	`+ method = GetType().GetMethod(((SyncedVar)syncedVarAttributes[j]).hook, BindingFlags.NonPublic \| BindingFlags.Public \| BindingFlags.Instance);`
	`153`	`+ break;`
	`154`	`+ }`
	`155`	`+ }`
`145`	`156`	`if (sortedFields[i].FieldType == typeof(bool))`
`146`	`157`	`{`
`147`	`158`	`syncedFields.Add(sortedFields[i]);`
`148`	`159`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`149`	`160`	`syncedFieldTypes.Add(FieldType.Bool);`
	`161`	`+ syncedVarHooks.Add(method);`
`150`	`162`	`}`
`151`	`163`	`else if(sortedFields[i].FieldType == typeof(byte))`
`152`	`164`	`{`
`153`	`165`	`syncedFields.Add(sortedFields[i]);`
`154`	`166`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`155`	`167`	`syncedFieldTypes.Add(FieldType.Byte);`
	`168`	`+ syncedVarHooks.Add(method);`
`156`	`169`	`}`
`157`	`170`	`else if (sortedFields[i].FieldType == typeof(char))`
`158`	`171`	`{`
`159`	`172`	`syncedFields.Add(sortedFields[i]);`
`160`	`173`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`161`	`174`	`syncedFieldTypes.Add(FieldType.Char);`
	`175`	`+ syncedVarHooks.Add(method);`
`162`	`176`	`}`
`163`	`177`	`else if (sortedFields[i].FieldType == typeof(double))`
`164`	`178`	`{`
`165`	`179`	`syncedFields.Add(sortedFields[i]);`
`166`	`180`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`167`	`181`	`syncedFieldTypes.Add(FieldType.Double);`
	`182`	`+ syncedVarHooks.Add(method);`
`168`	`183`	`}`
`169`	`184`	`else if (sortedFields[i].FieldType == typeof(float))`
`170`	`185`	`{`
`171`	`186`	`syncedFields.Add(sortedFields[i]);`
`172`	`187`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`173`	`188`	`syncedFieldTypes.Add(FieldType.Single);`
	`189`	`+ syncedVarHooks.Add(method);`
`174`	`190`	`}`
`175`	`191`	`else if (sortedFields[i].FieldType == typeof(int))`
`176`	`192`	`{`
`177`	`193`	`syncedFields.Add(sortedFields[i]);`
`178`	`194`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`179`	`195`	`syncedFieldTypes.Add(FieldType.Int);`
	`196`	`+ syncedVarHooks.Add(method);`
`180`	`197`	`}`
`181`	`198`	`else if (sortedFields[i].FieldType == typeof(long))`
`182`	`199`	`{`
`183`	`200`	`syncedFields.Add(sortedFields[i]);`
`184`	`201`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`185`	`202`	`syncedFieldTypes.Add(FieldType.Long);`
	`203`	`+ syncedVarHooks.Add(method);`
`186`	`204`	`}`
`187`	`205`	`else if (sortedFields[i].FieldType == typeof(sbyte))`
`188`	`206`	`{`
`189`	`207`	`syncedFields.Add(sortedFields[i]);`
`190`	`208`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`191`	`209`	`syncedFieldTypes.Add(FieldType.SByte);`
	`210`	`+ syncedVarHooks.Add(method);`
`192`	`211`	`}`
`193`	`212`	`else if (sortedFields[i].FieldType == typeof(short))`
`194`	`213`	`{`
`195`	`214`	`syncedFields.Add(sortedFields[i]);`
`196`	`215`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`197`	`216`	`syncedFieldTypes.Add(FieldType.Short);`
	`217`	`+ syncedVarHooks.Add(method);`
`198`	`218`	`}`
`199`	`219`	`else if (sortedFields[i].FieldType == typeof(uint))`
`200`	`220`	`{`
`201`	`221`	`syncedFields.Add(sortedFields[i]);`
`202`	`222`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`203`	`223`	`syncedFieldTypes.Add(FieldType.UInt);`
	`224`	`+ syncedVarHooks.Add(method);`
`204`	`225`	`}`
`205`	`226`	`else if (sortedFields[i].FieldType == typeof(ulong))`
`206`	`227`	`{`
`207`	`228`	`syncedFields.Add(sortedFields[i]);`
`208`	`229`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`209`	`230`	`syncedFieldTypes.Add(FieldType.ULong);`
	`231`	`+ syncedVarHooks.Add(method);`
`210`	`232`	`}`
`211`	`233`	`else if (sortedFields[i].FieldType == typeof(ushort))`
`212`	`234`	`{`
`213`	`235`	`syncedFields.Add(sortedFields[i]);`
`214`	`236`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`215`	`237`	`syncedFieldTypes.Add(FieldType.UShort);`
	`238`	`+ syncedVarHooks.Add(method);`
`216`	`239`	`}`
`217`	`240`	`else if(sortedFields[i].FieldType == typeof(string))`
`218`	`241`	`{`
`219`	`242`	`syncedFields.Add(sortedFields[i]);`
`220`	`243`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`221`	`244`	`syncedFieldTypes.Add(FieldType.String);`
	`245`	`+ syncedVarHooks.Add(method);`
`222`	`246`	`}`
`223`	`247`	`else if(sortedFields[i].FieldType == typeof(Vector3))`
`224`	`248`	`{`
`225`	`249`	`syncedFields.Add(sortedFields[i]);`
`226`	`250`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`227`	`251`	`syncedFieldTypes.Add(FieldType.Vector3);`
	`252`	`+ syncedVarHooks.Add(method);`
`228`	`253`	`}`
`229`	`254`	`else if(sortedFields[i].FieldType == typeof(Vector2))`
`230`	`255`	`{`
`231`	`256`	`syncedFields.Add(sortedFields[i]);`
`232`	`257`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`233`	`258`	`syncedFieldTypes.Add(FieldType.Vector2);`
	`259`	`+ syncedVarHooks.Add(method);`
`234`	`260`	`}`
`235`	`261`	`else if (sortedFields[i].FieldType == typeof(Quaternion))`
`236`	`262`	`{`
`237`	`263`	`syncedFields.Add(sortedFields[i]);`
`238`	`264`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`239`	`265`	`syncedFieldTypes.Add(FieldType.Quaternion);`
	`266`	`+ syncedVarHooks.Add(method);`
`240`	`267`	`}`
`241`	`268`	`else if(sortedFields[i].FieldType == typeof(byte[]))`
`242`	`269`	`{`
`243`	`270`	`syncedFields.Add(sortedFields[i]);`
`244`	`271`	`syncedFieldValues.Add(sortedFields[i].GetValue(this));`
`245`	`272`	`syncedFieldTypes.Add(FieldType.ByteArray);`
	`273`	`+ syncedVarHooks.Add(method);`
`246`	`274`	`}`
`247`	`275`	`else`
`248`	`276`	`{`
`@@ -260,6 +288,8 @@ internal void SyncVarInit()`
`260`	`288`	`internal void OnSyncVarUpdate(object value, byte fieldIndex)`
`261`	`289`	`{`
`262`	`290`	`syncedFields[fieldIndex].SetValue(this, value);`
	`291`	`+ if (syncedVarHooks[fieldIndex] != null)`
	`292`	`+ syncedVarHooks[fieldIndex].Invoke(this, null);`
`263`	`293`	`}`
`264`	`294`
`265`	`295`	`internal void FlushToClient(int clientId)`