A stable modding interface between Techblox and mods https://mod.exmods.org/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

Block.cs 17KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Reflection.Emit;
  5. using Svelto.ECS;
  6. using Svelto.ECS.EntityStructs;
  7. using RobocraftX.Common;
  8. using RobocraftX.Blocks;
  9. using Unity.Mathematics;
  10. using Unity.Entities;
  11. using Gamecraft.Blocks.GUI;
  12. using GamecraftModdingAPI.Blocks;
  13. using GamecraftModdingAPI.Utility;
  14. namespace GamecraftModdingAPI
  15. {
  16. /// <summary>
  17. /// A single (perhaps scaled) block. Properties may return default values if the block is removed and then setting them is ignored.
  18. /// For specific block type operations, use the specialised block classes in the GamecraftModdingAPI.Blocks namespace.
  19. /// </summary>
  20. public class Block : IEquatable<Block>, IEquatable<EGID>
  21. {
  22. protected static readonly PlacementEngine PlacementEngine = new PlacementEngine();
  23. protected static readonly MovementEngine MovementEngine = new MovementEngine();
  24. protected static readonly RotationEngine RotationEngine = new RotationEngine();
  25. protected static readonly RemovalEngine RemovalEngine = new RemovalEngine();
  26. protected static readonly SignalEngine SignalEngine = new SignalEngine();
  27. protected static readonly BlockEventsEngine BlockEventsEngine = new BlockEventsEngine();
  28. protected static readonly ScalingEngine ScalingEngine = new ScalingEngine();
  29. protected internal static readonly BlockEngine BlockEngine = new BlockEngine();
  30. /// <summary>
  31. /// Place a new block at the given position. If scaled, position means the center of the block. The default block size is 0.2 in terms of position.
  32. /// Place blocks next to each other to connect them.
  33. /// The placed block will be a complete block with a placement grid and collision which will be saved along with the game.
  34. /// <para></para>
  35. /// <para>When placing multiple blocks, do not access properties immediately after creation as this
  36. /// triggers a sync each time which can affect performance and may cause issues with the game.
  37. /// You may either use AsyncUtils.WaitForSubmission() after placing all of the blocks
  38. /// or simply access the block properties which will trigger the synchronization the first time a property is used.</para>
  39. /// </summary>
  40. /// <param name="block">The block's type</param>
  41. /// <param name="color">The block's color</param>
  42. /// <param name="darkness">The block color's darkness (0-9) - 0 is default color</param>
  43. /// <param name="position">The block's position in the grid - default block size is 0.2</param>
  44. /// <param name="rotation">The block's rotation in degrees</param>
  45. /// <param name="uscale">The block's uniform scale - default scale is 1 (with 0.2 width)</param>
  46. /// <param name="scale">The block's non-uniform scale - 0 means <paramref name="uscale"/> is used</param>
  47. /// <param name="player">The player who placed the block</param>
  48. /// <returns>The placed block or null if failed</returns>
  49. public static Block PlaceNew(BlockIDs block, float3 position,
  50. float3 rotation = default, BlockColors color = BlockColors.Default, byte darkness = 0,
  51. int uscale = 1, float3 scale = default, Player player = null)
  52. {
  53. return PlaceNew<Block>(block, position, rotation, color, darkness, uscale, scale, player);
  54. }
  55. /// <summary>
  56. /// Place a new block at the given position. If scaled, position means the center of the block. The default block size is 0.2 in terms of position.
  57. /// Place blocks next to each other to connect them.
  58. /// The placed block will be a complete block with a placement grid and collision which will be saved along with the game.
  59. /// </summary>
  60. /// <param name="block">The block's type</param>
  61. /// <param name="color">The block's color</param>
  62. /// <param name="darkness">The block color's darkness (0-9) - 0 is default color</param>
  63. /// <param name="position">The block's position in the grid - default block size is 0.2</param>
  64. /// <param name="rotation">The block's rotation in degrees</param>
  65. /// <param name="uscale">The block's uniform scale - default scale is 1 (with 0.2 width)</param>
  66. /// <param name="scale">The block's non-uniform scale - 0 means <paramref name="uscale"/> is used</param>
  67. /// <param name="player">The player who placed the block</param>
  68. /// <returns>The placed block or null if failed</returns>
  69. public static T PlaceNew<T>(BlockIDs block, float3 position,
  70. float3 rotation = default, BlockColors color = BlockColors.Default, byte darkness = 0,
  71. int uscale = 1, float3 scale = default, Player player = null) where T : Block
  72. {
  73. if (PlacementEngine.IsInGame && GameState.IsBuildMode())
  74. {
  75. var egid = PlacementEngine.PlaceBlock(block, color, darkness,
  76. position, uscale, scale, player, rotation, out var initializer);
  77. var bl = New<T>(egid.entityID, egid.groupID);
  78. bl.InitData.Group = BlockEngine.InitGroup(initializer);
  79. Placed += bl.OnPlacedInit;
  80. return bl;
  81. }
  82. return null;
  83. }
  84. /// <summary>
  85. /// Returns the most recently placed block.
  86. /// </summary>
  87. /// <returns>The block object</returns>
  88. public static Block GetLastPlacedBlock()
  89. {
  90. return New<Block>(BlockIdentifiers.LatestBlockID);
  91. }
  92. /// <summary>
  93. /// An event that fires each time a block is placed.
  94. /// </summary>
  95. public static event EventHandler<BlockPlacedRemovedEventArgs> Placed
  96. {
  97. add => BlockEventsEngine.Placed += value;
  98. remove => BlockEventsEngine.Placed -= value;
  99. }
  100. /// <summary>
  101. /// An event that fires each time a block is removed.
  102. /// </summary>
  103. public static event EventHandler<BlockPlacedRemovedEventArgs> Removed
  104. {
  105. add => BlockEventsEngine.Removed += value;
  106. remove => BlockEventsEngine.Removed -= value;
  107. }
  108. private static Dictionary<Type, Func<EGID, Block>> initializers = new Dictionary<Type, Func<EGID, Block>>();
  109. private static Dictionary<Type, ExclusiveGroupStruct[]> typeToGroup =
  110. new Dictionary<Type, ExclusiveGroupStruct[]>
  111. {
  112. {typeof(ConsoleBlock), new[] {CommonExclusiveGroups.BUILD_CONSOLE_BLOCK_GROUP}},
  113. {typeof(Motor), new[] {CommonExclusiveGroups.BUILD_MOTOR_BLOCK_GROUP}},
  114. {typeof(MusicBlock), new[] {CommonExclusiveGroups.BUILD_MUSIC_BLOCK_GROUP}},
  115. {typeof(Piston), new[] {CommonExclusiveGroups.BUILD_PISTON_BLOCK_GROUP}},
  116. {typeof(Servo), new[] {CommonExclusiveGroups.BUILD_SERVO_BLOCK_GROUP}},
  117. {
  118. typeof(SpawnPoint),
  119. new[]
  120. {
  121. CommonExclusiveGroups.BUILD_SPAWNPOINT_BLOCK_GROUP,
  122. CommonExclusiveGroups.BUILD_BUILDINGSPAWN_BLOCK_GROUP
  123. }
  124. },
  125. {typeof(TextBlock), new[] {CommonExclusiveGroups.BUILD_TEXT_BLOCK_GROUP}},
  126. {typeof(Timer), new[] {CommonExclusiveGroups.BUILD_TIMER_BLOCK_GROUP}}
  127. };
  128. /// <summary>
  129. /// Constructs a new instance of T with the given ID and group using dynamically created delegates.
  130. /// It's equivalent to new T(EGID) with a minimal overhead thanks to caching the created delegates.
  131. /// </summary>
  132. /// <param name="id">The block ID</param>
  133. /// <param name="group">The block group</param>
  134. /// <typeparam name="T">The block's type or Block itself</typeparam>
  135. /// <returns>An instance of the provided type</returns>
  136. /// <exception cref="BlockTypeException">The block group doesn't match or cannot be found</exception>
  137. /// <exception cref="MissingMethodException">The block class doesn't have the needed constructor</exception>
  138. private static T New<T>(uint id, ExclusiveGroupStruct? group = null) where T : Block
  139. {
  140. var type = typeof(T);
  141. EGID egid;
  142. if (!group.HasValue)
  143. {
  144. if (typeToGroup.TryGetValue(type, out var gr) && gr.Length == 1)
  145. egid = new EGID(id, gr[0]);
  146. else
  147. egid = BlockEngine.FindBlockEGID(id) ?? throw new BlockTypeException("Could not find block group!");
  148. }
  149. else
  150. {
  151. egid = new EGID(id, group.Value);
  152. if (typeToGroup.TryGetValue(type, out var gr)
  153. && gr.All(egs => egs != group.Value)) //If this subclass has a specific group, then use that - so Block should still work
  154. throw new BlockTypeException($"Incompatible block type! Type {type.Name} belongs to group {gr.Select(g => g.ToString()).Aggregate((a, b) => a + ", " + b)} instead of {group.Value}");
  155. }
  156. if (initializers.TryGetValue(type, out var func))
  157. {
  158. var bl = (T) func(egid);
  159. return bl;
  160. }
  161. //https://stackoverflow.com/a/10593806/2703239
  162. var ctor = type.GetConstructor(new[] {typeof(EGID)});
  163. if (ctor == null)
  164. throw new MissingMethodException("There is no constructor with an EGID parameter for this object");
  165. DynamicMethod dynamic = new DynamicMethod(string.Empty,
  166. type,
  167. new[] {typeof(EGID)},
  168. type);
  169. ILGenerator il = dynamic.GetILGenerator();
  170. il.DeclareLocal(type);
  171. il.Emit(OpCodes.Ldarg_0); //Load EGID and pass to constructor
  172. il.Emit(OpCodes.Newobj, ctor); //Call constructor
  173. //il.Emit(OpCodes.Stloc_0); - doesn't seem like we need these
  174. //il.Emit(OpCodes.Ldloc_0);
  175. il.Emit(OpCodes.Ret);
  176. func = (Func<EGID, T>) dynamic.CreateDelegate(typeof(Func<EGID, T>));
  177. initializers.Add(type, func);
  178. var block = (T) func(egid);
  179. return block;
  180. }
  181. public Block(EGID id)
  182. {
  183. Id = id;
  184. var type = GetType();
  185. if (typeToGroup.TryGetValue(type, out var groups))
  186. {
  187. if (groups.All(gr => gr != id.groupID))
  188. throw new BlockTypeException("The block has the wrong group! The type is " + GetType() +
  189. " while the group is " + id.groupID);
  190. }
  191. else if (type != typeof(Block))
  192. Logging.LogWarning($"Unknown block type! Add {type} to the dictionary.");
  193. }
  194. /// <summary>
  195. /// This overload searches for the correct group the block is in.
  196. /// It will throw an exception if the block doesn't exist.
  197. /// Use the EGID constructor where possible or subclasses of Block as those specify the group.
  198. /// </summary>
  199. public Block(uint id)
  200. {
  201. Id = BlockEngine.FindBlockEGID(id) ?? throw new BlockTypeException("Could not find the appropriate group for the block. The block probably doesn't exist or hasn't been submitted.");
  202. }
  203. public EGID Id { get; }
  204. internal BlockEngine.BlockInitData InitData;
  205. /// <summary>
  206. /// The block's current position or zero if the block no longer exists.
  207. /// A block is 0.2 wide by default in terms of position.
  208. /// </summary>
  209. public float3 Position
  210. {
  211. get => MovementEngine.GetPosition(Id, InitData);
  212. set
  213. {
  214. MovementEngine.MoveBlock(Id, InitData, value);
  215. }
  216. }
  217. /// <summary>
  218. /// The block's current rotation in degrees or zero if the block doesn't exist.
  219. /// </summary>
  220. public float3 Rotation
  221. {
  222. get => RotationEngine.GetRotation(Id, InitData);
  223. set
  224. {
  225. RotationEngine.RotateBlock(Id, InitData, value);
  226. }
  227. }
  228. /// <summary>
  229. /// The block's non-uniform scale or zero if the block's invalid. Independent of the uniform scaling.
  230. /// The default scale of 1 means 0.2 in terms of position.
  231. /// </summary>
  232. public float3 Scale
  233. {
  234. get => BlockEngine.GetBlockInfo(this, (ScalingEntityStruct st) => st.scale);
  235. set
  236. {
  237. BlockEngine.SetBlockInfo(this, (ref ScalingEntityStruct st, float3 val) => st.scale = val, value);
  238. if (!Exists) return; //UpdateCollision needs the block to exist
  239. ScalingEngine.UpdateCollision(Id);
  240. }
  241. }
  242. /// <summary>
  243. /// The block's uniform scale or zero if the block's invalid. Also sets the non-uniform scale.
  244. /// The default scale of 1 means 0.2 in terms of position.
  245. /// </summary>
  246. public int UniformScale
  247. {
  248. get => BlockEngine.GetBlockInfo(this, (UniformBlockScaleEntityStruct st) => st.scaleFactor);
  249. set
  250. {
  251. BlockEngine.SetBlockInfo(this, (ref UniformBlockScaleEntityStruct st, int val) => st.scaleFactor = val,
  252. value);
  253. Scale = new float3(value, value, value);
  254. }
  255. }
  256. /// <summary>
  257. /// The block's type (ID). Returns BlockIDs.Invalid if the block doesn't exist anymore.
  258. /// </summary>
  259. public BlockIDs Type
  260. {
  261. get
  262. {
  263. return BlockEngine.GetBlockInfo(this, (DBEntityStruct st) => (BlockIDs) st.DBID, BlockIDs.Invalid);
  264. }
  265. }
  266. /// <summary>
  267. /// The block's color. Returns BlockColors.Default if the block no longer exists.
  268. /// </summary>
  269. public BlockColor Color
  270. {
  271. get
  272. {
  273. byte index = BlockEngine.GetBlockInfo(this, (ColourParameterEntityStruct st) => st.indexInPalette,
  274. byte.MaxValue);
  275. return new BlockColor(index);
  276. }
  277. set
  278. {
  279. BlockEngine.SetBlockInfo(this, (ref ColourParameterEntityStruct color, BlockColor val) =>
  280. {
  281. color.indexInPalette = (byte) (val.Color + val.Darkness * 10);
  282. color.overridePaletteColour = false;
  283. color.needsUpdate = true;
  284. BlockEngine.SetBlockColorFromPalette(ref color);
  285. }, value);
  286. }
  287. }
  288. /// <summary>
  289. /// The block's exact color. Gets reset to the palette color (Color property) after reentering the game.
  290. /// </summary>
  291. public float4 CustomColor
  292. {
  293. get => BlockEngine.GetBlockInfo(this, (ColourParameterEntityStruct st) => st.overriddenColour);
  294. set
  295. {
  296. BlockEngine.SetBlockInfo(this, (ref ColourParameterEntityStruct color, float4 val) =>
  297. {
  298. color.overriddenColour = val;
  299. color.overridePaletteColour = true;
  300. color.needsUpdate = true;
  301. }, value);
  302. }
  303. }
  304. /// <summary>
  305. /// The text displayed on the block if applicable, or null.
  306. /// Setting it is temporary to the session, it won't be saved.
  307. /// </summary>
  308. public string Label
  309. {
  310. get => BlockEngine.GetBlockInfo(this, (TextLabelEntityViewStruct st) => st.textLabelComponent?.text);
  311. set
  312. {
  313. BlockEngine.SetBlockInfo(this, (ref TextLabelEntityViewStruct text, string val) =>
  314. {
  315. if (text.textLabelComponent != null) text.textLabelComponent.text = val;
  316. }, value);
  317. }
  318. }
  319. /// <summary>
  320. /// Whether the block exists. The other properties will return a default value if the block doesn't exist.
  321. /// If the block was just placed, then this will also return false but the properties will work correctly.
  322. /// </summary>
  323. public bool Exists => BlockEngine.BlockExists(Id);
  324. /// <summary>
  325. /// Returns an array of blocks that are connected to this one. Returns an empty array if the block doesn't exist.
  326. /// </summary>
  327. public Block[] GetConnectedCubes() => BlockEngine.GetConnectedBlocks(Id);
  328. /// <summary>
  329. /// Removes this block.
  330. /// </summary>
  331. /// <returns>True if the block exists and could be removed.</returns>
  332. public bool Remove() => RemovalEngine.RemoveBlock(Id);
  333. /// <summary>
  334. /// Returns the rigid body of the chunk of blocks this one belongs to during simulation.
  335. /// Can be used to apply forces or move the block around while the simulation is running.
  336. /// </summary>
  337. /// <returns>The SimBody of the chunk or null if the block doesn't exist.</returns>
  338. public SimBody GetSimBody()
  339. {
  340. return BlockEngine.GetBlockInfo(this,
  341. (GridConnectionsEntityStruct st) => new SimBody(st.machineRigidBodyId));
  342. }
  343. private void OnPlacedInit(object sender, BlockPlacedRemovedEventArgs e)
  344. { //Member method instead of lambda to avoid constantly creating delegates
  345. if (e.ID != Id) return;
  346. Placed -= OnPlacedInit; //And we can reference it
  347. InitData = default; //Remove initializer as it's no longer valid - if the block gets removed it shouldn't be used again
  348. }
  349. public override string ToString()
  350. {
  351. return $"{nameof(Id)}: {Id}, {nameof(Position)}: {Position}, {nameof(Type)}: {Type}, {nameof(Color)}: {Color}, {nameof(Exists)}: {Exists}";
  352. }
  353. public bool Equals(Block other)
  354. {
  355. if (ReferenceEquals(null, other)) return false;
  356. if (ReferenceEquals(this, other)) return true;
  357. return Id.Equals(other.Id);
  358. }
  359. public bool Equals(EGID other)
  360. {
  361. return Id.Equals(other);
  362. }
  363. public override bool Equals(object obj)
  364. {
  365. if (ReferenceEquals(null, obj)) return false;
  366. if (ReferenceEquals(this, obj)) return true;
  367. if (obj.GetType() != this.GetType()) return false;
  368. return Equals((Block) obj);
  369. }
  370. public override int GetHashCode()
  371. {
  372. return Id.GetHashCode();
  373. }
  374. public static void Init()
  375. {
  376. GameEngineManager.AddGameEngine(PlacementEngine);
  377. GameEngineManager.AddGameEngine(MovementEngine);
  378. GameEngineManager.AddGameEngine(RotationEngine);
  379. GameEngineManager.AddGameEngine(RemovalEngine);
  380. GameEngineManager.AddGameEngine(BlockEngine);
  381. GameEngineManager.AddGameEngine(BlockEventsEngine);
  382. GameEngineManager.AddGameEngine(ScalingEngine);
  383. }
  384. /// <summary>
  385. /// Convert the block to a specialised block class.
  386. /// </summary>
  387. /// <returns>The block.</returns>
  388. /// <typeparam name="T">The specialised block type.</typeparam>
  389. public T Specialise<T>() where T : Block
  390. {
  391. // What have I gotten myself into?
  392. // C# can't cast to a child of Block unless the object was originally that child type
  393. // And C# doesn't let me make implicit cast operators for child types
  394. // So thanks to Microsoft, we've got this horrible implementation using reflection
  395. //Lets improve that using delegates
  396. var block = New<T>(Id.entityID, Id.groupID);
  397. block.InitData = this.InitData;
  398. return block;
  399. }
  400. #if DEBUG
  401. public static EntitiesDB entitiesDB
  402. {
  403. get
  404. {
  405. return BlockEngine.GetEntitiesDB();
  406. }
  407. }
  408. #endif
  409. internal static void Setup(World physicsWorld)
  410. {
  411. ScalingEngine.Setup(physicsWorld.EntityManager);
  412. }
  413. }
  414. }