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.

468 lines
17KB

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