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.

470 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.CONSOLE_BLOCK_GROUP}},
  108. {typeof(LogicGate), new [] {CommonExclusiveGroups.LOGIC_BLOCK_GROUP}},
  109. {typeof(Motor), new[] {CommonExclusiveGroups.MOTOR_BLOCK_GROUP}},
  110. {typeof(MusicBlock), new[] {CommonExclusiveGroups.MUSIC_BLOCK_GROUP}},
  111. {typeof(ObjectIdentifier), new[]{CommonExclusiveGroups.OBJID_BLOCK_GROUP}},
  112. {typeof(Piston), new[] {CommonExclusiveGroups.PISTON_BLOCK_GROUP}},
  113. {typeof(Servo), new[] {CommonExclusiveGroups.SERVO_BLOCK_GROUP}},
  114. {
  115. typeof(SpawnPoint),
  116. new[]
  117. {
  118. CommonExclusiveGroups.SPAWNPOINT_BLOCK_GROUP,
  119. CommonExclusiveGroups.BUILDINGSPAWN_BLOCK_GROUP
  120. }
  121. },
  122. {
  123. typeof(SfxBlock),
  124. new[]
  125. {
  126. CommonExclusiveGroups.SIMPLESFX_BLOCK_GROUP,
  127. CommonExclusiveGroups.LOOPEDSFX_BLOCK_GROUP
  128. }
  129. },
  130. {typeof(DampedSpring), new [] {CommonExclusiveGroups.DAMPEDSPRING_BLOCK_GROUP}},
  131. {typeof(TextBlock), new[] {CommonExclusiveGroups.TEXT_BLOCK_GROUP}},
  132. {typeof(Timer), new[] {CommonExclusiveGroups.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.hasNetworkChange = true;
  291. color.paletteColour = BlockEngine.ConvertBlockColor(color.indexInPalette);
  292. }, value);
  293. }
  294. }
  295. /// <summary>
  296. /// The block's exact color. Gets reset to the palette color (Color property) after reentering the game.
  297. /// </summary>
  298. public float4 CustomColor
  299. {
  300. get => BlockEngine.GetBlockInfo(this, (ColourParameterEntityStruct st) => st.paletteColour);
  301. set
  302. {
  303. BlockEngine.SetBlockInfo(this, (ref ColourParameterEntityStruct color, float4 val) =>
  304. {
  305. color.paletteColour = val;
  306. //color.overridePaletteColour = true;
  307. //color.needsUpdate = true;
  308. color.hasNetworkChange = true;
  309. }, value);
  310. }
  311. }
  312. /// <summary>
  313. /// The text displayed on the block if applicable, or null.
  314. /// Setting it is temporary to the session, it won't be saved.
  315. /// </summary>
  316. public string Label
  317. {
  318. get => BlockEngine.GetBlockInfoViewStruct(this, (TextLabelEntityViewStruct st) => st.textLabelComponent?.text);
  319. set
  320. {
  321. BlockEngine.SetBlockInfoViewStruct(this, (ref TextLabelEntityViewStruct text, string val) =>
  322. {
  323. if (text.textLabelComponent != null) text.textLabelComponent.text = val;
  324. }, value);
  325. }
  326. }
  327. /// <summary>
  328. /// Whether the block exists. The other properties will return a default value if the block doesn't exist.
  329. /// If the block was just placed, then this will also return false but the properties will work correctly.
  330. /// </summary>
  331. public bool Exists => BlockEngine.BlockExists(Id);
  332. /// <summary>
  333. /// Returns an array of blocks that are connected to this one. Returns an empty array if the block doesn't exist.
  334. /// </summary>
  335. public Block[] GetConnectedCubes() => BlockEngine.GetConnectedBlocks(Id);
  336. /// <summary>
  337. /// Removes this block.
  338. /// </summary>
  339. /// <returns>True if the block exists and could be removed.</returns>
  340. public bool Remove() => RemovalEngine.RemoveBlock(Id);
  341. /// <summary>
  342. /// Returns the rigid body of the chunk of blocks this one belongs to during simulation.
  343. /// Can be used to apply forces or move the block around while the simulation is running.
  344. /// </summary>
  345. /// <returns>The SimBody of the chunk or null if the block doesn't exist or not in simulation mode.</returns>
  346. public SimBody GetSimBody()
  347. {
  348. return BlockEngine.GetBlockInfo(this,
  349. (GridConnectionsEntityStruct st) => st.machineRigidBodyId != uint.MaxValue
  350. ? new SimBody(st.machineRigidBodyId, st.clusterId)
  351. : null);
  352. }
  353. private void OnPlacedInit(object sender, BlockPlacedRemovedEventArgs e)
  354. { //Member method instead of lambda to avoid constantly creating delegates
  355. if (e.ID != Id) return;
  356. Placed -= OnPlacedInit; //And we can reference it
  357. InitData = default; //Remove initializer as it's no longer valid - if the block gets removed it shouldn't be used again
  358. }
  359. public override string ToString()
  360. {
  361. return $"{nameof(Id)}: {Id}, {nameof(Position)}: {Position}, {nameof(Type)}: {Type}, {nameof(Color)}: {Color}, {nameof(Exists)}: {Exists}";
  362. }
  363. public bool Equals(Block other)
  364. {
  365. if (ReferenceEquals(null, other)) return false;
  366. if (ReferenceEquals(this, other)) return true;
  367. return Id.Equals(other.Id);
  368. }
  369. public bool Equals(EGID other)
  370. {
  371. return Id.Equals(other);
  372. }
  373. public override bool Equals(object obj)
  374. {
  375. if (ReferenceEquals(null, obj)) return false;
  376. if (ReferenceEquals(this, obj)) return true;
  377. if (obj.GetType() != this.GetType()) return false;
  378. return Equals((Block) obj);
  379. }
  380. public override int GetHashCode()
  381. {
  382. return Id.GetHashCode();
  383. }
  384. public static void Init()
  385. {
  386. GameEngineManager.AddGameEngine(PlacementEngine);
  387. GameEngineManager.AddGameEngine(MovementEngine);
  388. GameEngineManager.AddGameEngine(RotationEngine);
  389. GameEngineManager.AddGameEngine(RemovalEngine);
  390. GameEngineManager.AddGameEngine(BlockEngine);
  391. GameEngineManager.AddGameEngine(BlockEventsEngine);
  392. GameEngineManager.AddGameEngine(ScalingEngine);
  393. GameEngineManager.AddGameEngine(SignalEngine);
  394. Wire.signalEngine = SignalEngine; // requires same functionality, no need to duplicate the engine
  395. }
  396. /// <summary>
  397. /// Convert the block to a specialised block class.
  398. /// </summary>
  399. /// <returns>The block.</returns>
  400. /// <typeparam name="T">The specialised block type.</typeparam>
  401. public T Specialise<T>() where T : Block
  402. {
  403. // What have I gotten myself into?
  404. // C# can't cast to a child of Block unless the object was originally that child type
  405. // And C# doesn't let me make implicit cast operators for child types
  406. // So thanks to Microsoft, we've got this horrible implementation using reflection
  407. //Lets improve that using delegates
  408. var block = New<T>(Id.entityID, Id.groupID);
  409. if (this.InitData.Group != null)
  410. {
  411. block.InitData = this.InitData;
  412. Placed += block.OnPlacedInit; //Reset InitData of new object
  413. }
  414. return block;
  415. }
  416. #if DEBUG
  417. public static EntitiesDB entitiesDB
  418. {
  419. get
  420. {
  421. return BlockEngine.GetEntitiesDB();
  422. }
  423. }
  424. #endif
  425. }
  426. }