Add option to delay entity change publish and remove reflection stuff

Neither of them work actually
Added some delay between tests

TechbloxModdingAPI/Blocks/BlockTests.cs

@@ -82,7 +82,7 @@ namespace TechbloxModdingAPI.Blocks
 		        yield break;
 	        for (var index = 0; index < blocks.Length; index++)
 	        {
-		        if (index % 50 == 0) yield return Yield.It; //The material or flipped status can only be changed 130 times per submission
+		        if (index % 50 == 0) yield return new WaitForSecondsEnumerator(0.2f).Continue(); //The material or flipped status can only be changed 130 times per submission
 		        var block = blocks[index];
 		        if (!block.Exists) continue;
 		        foreach (var property in block.GetType().GetProperties())

TechbloxModdingAPI/Blocks/Engines/BlockEngine.cs

@@ -99,16 +99,19 @@ namespace TechbloxModdingAPI.Blocks.Engines
 
 		internal object GetBlockInfo(Block block, Type type, string name)
 		{
-			var str = AccessTools.Method(typeof(BlockEngine), "GetBlockInfo", generics: new[] { type })
+			/*var opt = AccessTools.Method(typeof(BlockEngine), "GetBlockInfoOptional", generics: new[] { type })
-				.Invoke(this, new object[] { block });
+				.Invoke(this, new object[] { block }); - TODO: Cannot call method with by-ref return value
-			return AccessTools.Field(str.GetType(), name).GetValue(str);
+			var str = AccessTools.Method(opt.GetType(), "Get").Invoke(opt, Array.Empty<object>());
+			return AccessTools.Field(str.GetType(), name).GetValue(str);*/
+			return AccessTools.Field(type, name).GetValue(Activator.CreateInstance(type));
 		}
 
 		internal void SetBlockInfo(Block block, Type type, string name, object value)
 		{
-			var str = AccessTools.Method(typeof(BlockEngine), "GetBlockInfo", generics: new[] { type })
+			/*var opt = AccessTools.Method(typeof(BlockEngine), "GetBlockInfoOptional", generics: new[] { type })
 				.Invoke(this, new object[] { block });
-			AccessTools.Field(str.GetType(), name).SetValue(str, value);
+			var str = AccessTools.Method(opt.GetType(), "Get").Invoke(opt, Array.Empty<object>());
+			AccessTools.Field(str.GetType(), name).SetValue(str, value);*/
 		}
 
 		public void UpdateDisplayedBlock(EGID id)
@@ -120,7 +123,7 @@ namespace TechbloxModdingAPI.Blocks.Engines
 			var skew = entitiesDB.QueryEntity<SkewComponent>(id);
 			entitiesDB.QueryEntity<RenderingDataStruct>(id).matrix =
 				math.mul(float4x4.TRS(pos.position, rot.rotation, scale.scale), skew.skewMatrix);
-			entitiesDB.PublishEntityChange<GFXPrefabEntityStructGPUI>(id); // Signal a prefab change so it updates the render buffers
+			entitiesDB.PublishEntityChangeDelayed<GFXPrefabEntityStructGPUI>(id); // Signal a prefab change so it updates the render buffers
 		}
 
 		internal void UpdatePrefab(Block block, byte material, bool flipped)
@@ -141,15 +144,15 @@ namespace TechbloxModdingAPI.Blocks.Engines
 			entitiesDB.QueryEntityOrDefault<GFXPrefabEntityStructGPUI>(block).prefabID = prefabId;
 			if (block.Exists)
 			{
-				entitiesDB.PublishEntityChange<CubeMaterialStruct>(block.Id);
+				entitiesDB.PublishEntityChangeDelayed<CubeMaterialStruct>(block.Id);
-				entitiesDB.PublishEntityChange<GFXPrefabEntityStructGPUI>(block.Id);
+				entitiesDB.PublishEntityChangeDelayed<GFXPrefabEntityStructGPUI>(block.Id);
 
 				ref BuildingActionComponent local =
 					ref entitiesDB.QueryEntity<BuildingActionComponent>(BuildingDroneUtility
 						.GetLocalBuildingDrone(entitiesDB).ToEGID(entitiesDB));
 				local.buildAction = BuildAction.ChangeMaterial;
 				local.targetPosition = block.Position;
-				this.entitiesDB.PublishEntityChange<BuildingActionComponent>(local.ID);
+				this.entitiesDB.PublishEntityChangeDelayed<BuildingActionComponent>(local.ID);
 			}
 			//Phyiscs prefab: prefabAssetID, set on block creation from the CubeListData
 		}

TechbloxModdingAPI/TechbloxModdingAPI.csproj

@@ -8,7 +8,7 @@
     <PackageProjectUrl>https://git.exmods.org/modtainers/GamecraftModdingAPI</PackageProjectUrl>
     <NeutralLanguage>en-CA</NeutralLanguage>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>8</LangVersion>
+    <LangVersion>9</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   </PropertyGroup>

TechbloxModdingAPI/Tests/TestRoot.cs

@@ -205,7 +205,7 @@ namespace TechbloxModdingAPI.Tests
 							} while (cont);
 						}
 
-						yield return Yield.It;
+						yield return new WaitForSecondsEnumerator(1f).Continue();
 					}
 				}
 

TechbloxModdingAPI/Utility/NativeApiExtensions.cs

@@ -1,4 +1,9 @@
+using System;
+using System.Collections.Generic;
 using Svelto.ECS;
+using Svelto.Tasks;
+using Svelto.Tasks.Lean;
+using TechbloxModdingAPI.Tasks;
 
 namespace TechbloxModdingAPI.Utility
 {
@@ -58,5 +63,40 @@ namespace TechbloxModdingAPI.Utility
             if (init.Has<T>()) return ref init.Get<T>();*/
             return ref opt.Get(); //Default value
         }
+
+        private static readonly Dictionary<Type, (int PublishedCount, HashSet<EGID> Changes)> ChangesToPublish = new();
+
+        /// <summary>
+        /// Publishes an entity change, ignoring duplicate publishes and delaying changes as necessary.
+        /// It will only publish in the next frame.
+        /// </summary>
+        /// <param name="entitiesDB">The entities DB to publish to</param>
+        /// <param name="obj">The ECS object that got changed</param>
+        /// <param name="limit">Limits how many changes to publish - should be no more than the consumers' capacity that process this component</param>
+        /// <typeparam name="T">The component that changed</typeparam>
+        public static void PublishEntityChangeDelayed<T>(this EntitiesDB entitiesDB, EGID id, int limit = 80)
+            where T : unmanaged, IEntityComponent
+        { //TODO: Doesn't seem to help
+            if(!ChangesToPublish.ContainsKey(typeof(T)))
+                ChangesToPublish.Add(typeof(T), (0, new HashSet<EGID>()));
+            var changes = ChangesToPublish[typeof(T)].Changes;
+            if (changes.Contains(id)) return;
+            changes.Add(id);
+            PublishChanges<T>(entitiesDB, id, limit).RunOn(Scheduler.leanRunner);
+        }
+
+        private static IEnumerator<TaskContract> PublishChanges<T>(EntitiesDB entitiesDB, EGID id, int limit)
+            where T : unmanaged, IEntityComponent
+        {
+            yield return Yield.It;
+            while (ChangesToPublish[typeof(T)].PublishedCount >= limit)
+                yield return Yield.It;
+            entitiesDB.PublishEntityChange<T>(id);
+            var (count, changes) = ChangesToPublish[typeof(T)];
+            changes.Remove(id);
+            ChangesToPublish[typeof(T)] = (count + 1, changes);
+            yield return Yield.It;
+            ChangesToPublish[typeof(T)] = (0, changes);
+        }
     }
 }