TechbloxModdingAPI/GamecraftModdingAPI/Block.cs

using System;
using System.Reflection;
using System.Threading.Tasks;

using Svelto.ECS;
using Svelto.ECS.EntityStructs;
using RobocraftX.Common;
using RobocraftX.Blocks;
using Unity.Mathematics;
using Gamecraft.Blocks.GUI;

using GamecraftModdingAPI.Blocks;
using GamecraftModdingAPI.Utility;

namespace GamecraftModdingAPI
{
	/// <summary>
	/// A single (perhaps scaled) block. Properties may return default values if the block is removed and then setting them is ignored.
	/// For specific block type operations, use the specialised block classes in the GamecraftModdingAPI.Blocks namespace.
	/// </summary>
	public class Block
	{
		protected static readonly PlacementEngine PlacementEngine = new PlacementEngine();
		protected static readonly MovementEngine MovementEngine = new MovementEngine();
		protected static readonly RotationEngine RotationEngine = new RotationEngine();
		protected static readonly RemovalEngine RemovalEngine = new RemovalEngine();
		protected static readonly SignalEngine SignalEngine = new SignalEngine();
		
		protected internal static readonly BlockEngine BlockEngine = new BlockEngine();

		/// <summary>
		/// 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.
		/// Place blocks next to each other to connect them.
		/// The placed block will be a complete block with a placement grid and collision which will be saved along with the game.
		/// </summary>
		/// <param name="block">The block's type</param>
		/// <param name="color">The block's color</param>
		/// <param name="darkness">The block color's darkness (0-9) - 0 is default color</param>
		/// <param name="position">The block's position in the grid - default block size is 0.2</param>
		/// <param name="rotation">The block's rotation in degrees</param>
		/// <param name="uscale">The block's uniform scale - default scale is 1 (with 0.2 width)</param>
		/// <param name="scale">The block's non-uniform scale - 0 means <paramref name="uscale"/> is used</param>
		/// <param name="player">The player who placed the block</param>
		/// <returns>The placed block or null if failed</returns>
		public static Block PlaceNew(BlockIDs block, float3 position,
			float3 rotation = default, BlockColors color = BlockColors.Default, byte darkness = 0,
			int uscale = 1, float3 scale = default, Player player = null)
		{
			if (PlacementEngine.IsInGame && GameState.IsBuildMode())
			{
				return new Block(PlacementEngine.PlaceBlock(block, color, darkness,
					position, uscale, scale, player, rotation));
			}

			return null;
		}

		/// <summary>
		/// 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.
		/// Place blocks next to each other to connect them.
		/// The placed block will be a complete block with a placement grid and collision which will be saved along with the game.
		/// <para></para>
		/// <para>This method waits for the block to be constructed in the game.</para>
		/// </summary>
		/// <param name="block">The block's type</param>
		/// <param name="color">The block's color</param>
		/// <param name="darkness">The block color's darkness (0-9) - 0 is default color</param>
		/// <param name="position">The block's position in the grid - default block size is 0.2</param>
		/// <param name="rotation">The block's rotation in degrees</param>
		/// <param name="uscale">The block's uniform scale - default scale is 1 (with 0.2 width)</param>
		/// <param name="scale">The block's non-uniform scale - 0 means <paramref name="uscale"/> is used</param>
		/// <param name="player">The player who placed the block</param>
		/// <returns>The placed block or null if failed</returns>
		public static async Task<Block> PlaceNewAsync(BlockIDs block, float3 position,
			float3 rotation = default, BlockColors color = BlockColors.Default, byte darkness = 0,
			int uscale = 1, float3 scale = default, Player player = null)
		{
			if (PlacementEngine.IsInGame && GameState.IsBuildMode())
			{
				try
				{
					var ret = new Block(PlacementEngine.PlaceBlock(block, color, darkness,
						position, uscale, scale, player, rotation));
					await AsyncUtils.WaitForSubmission();
					return ret;
				}
				catch (Exception e)
				{
					Logging.MetaDebugLog(e);
				}
			}

			return null;
		}

		/// <summary>
		/// Returns the most recently placed block.
		/// </summary>
		/// <returns>The block object</returns>
		public static Block GetLastPlacedBlock()
		{
			return new Block(BlockIdentifiers.LatestBlockID);
		}

		public Block(EGID id)
		{
			Id = id;
			if (!BlockEngine.BlockExists(Id))
            {
                Sync();
                if (!BlockEngine.BlockExists(Id))
                {
					throw new BlockDoesNotExistException($"Block {Id.entityID} must be placed using PlaceNew(...) since it does not exist yet");
                }
            }
		}

		public Block(uint id) : this(new EGID(id, CommonExclusiveGroups.OWNED_BLOCKS_GROUP))
		{
		}

        /// <summary>
        /// Synchronize newly created entity components with entities DB.
		/// This forces a partial game tick, so it may be slow.
		/// This also has the potential to make Gamecraft unstable.
		/// Use this sparingly.
        /// </summary>
		protected static void Sync()
		{
			DeterministicStepCompositionRootPatch.SubmitEntitiesNow();
		}

		public EGID Id { get; protected set; }

		/// <summary>
		/// The block's current position or zero if the block no longer exists.
		/// A block is 0.2 wide by default in terms of position.
		/// </summary>
		public float3 Position
		{
			get => Exists ? MovementEngine.GetPosition(Id.entityID) : float3.zero;
			set
			{
				if (Exists) MovementEngine.MoveBlock(Id.entityID, value);
			}
		}

		/// <summary>
		/// The block's current rotation in degrees or zero if the block doesn't exist.
		/// </summary>
		public float3 Rotation
		{
			get => Exists ? RotationEngine.GetRotation(Id.entityID) : float3.zero;
			set
			{
				if (Exists) RotationEngine.RotateBlock(Id.entityID, value);
			}
		}

		/// <summary>
		/// The block's non-uniform scale or zero if the block's invalid. Independent of the uniform scaling.
		/// </summary>
		public float3 Scale
		{
			get => BlockEngine.GetBlockInfo<ScalingEntityStruct>(Id).scale;
			set
			{
				BlockEngine.GetBlockInfo<ScalingEntityStruct>(Id).scale = value;
			}
		}

		/// <summary>
		/// The block's uniform scale or zero if the block's invalid. Also sets the non-uniform scale.
		/// </summary>
		public int UniformScale
		{
			get => BlockEngine.GetBlockInfo<UniformBlockScaleEntityStruct>(Id).scaleFactor;
			set
			{
				ref var scaleStruct = ref BlockEngine.GetBlockInfo<UniformBlockScaleEntityStruct>(Id);
				scaleStruct.scaleFactor = value;
				Scale = new float3(value, value, value);
			}
		}

		/// <summary>
		/// The block's type (ID). Returns BlockIDs.Invalid if the block doesn't exist anymore.
		/// </summary>
		public BlockIDs Type
		{
			get
			{
				var id = (BlockIDs) BlockEngine.GetBlockInfo<DBEntityStruct>(Id, out var exists).DBID;
				return exists ? id : BlockIDs.Invalid;
			}
		}

		/// <summary>
		/// The block's color. Returns BlockColors.Default if the block no longer exists.
		/// </summary>
		public BlockColor Color
		{
			get
			{
				byte index = BlockEngine.GetBlockInfo<ColourParameterEntityStruct>(Id, out var exists).indexInPalette;
				if (!exists) index = byte.MaxValue;
				if (index == byte.MaxValue) return new BlockColor { Color = BlockColors.Default };
				return new BlockColor { Color = (BlockColors)(index % 10), Darkness = (byte)(index / 10) };
			}
			set
			{
				ref var color = ref BlockEngine.GetBlockInfo<ColourParameterEntityStruct>(Id);
				color.indexInPalette = (byte)(value.Color + value.Darkness * 10);
				color.overridePaletteColour = false;
				color.needsUpdate = true;
				BlockEngine.SetBlockColorFromPalette(ref color);
			}
		}

		/// <summary>
		/// The block's exact color. Gets reset to the palette color (Color property) after reentering the game.
		/// </summary>
		public float4 CustomColor
		{
			get => BlockEngine.GetBlockInfo<ColourParameterEntityStruct>(Id).overriddenColour;
			set
			{
				ref var color = ref BlockEngine.GetBlockInfo<ColourParameterEntityStruct>(Id);
				color.overriddenColour = value;
				color.overridePaletteColour = true;
				color.needsUpdate = true;
			}
		}

		/// <summary>
		/// The short text displayed on the block if applicable, or null.
		/// Setting it is temporary to the session, it won't be saved.
		/// </summary>
		public string Label
		{
			get => BlockEngine.GetBlockInfo<TextLabelEntityViewStruct>(Id).textLabelComponent?.text;
			set
			{
				ref var text = ref BlockEngine.GetBlockInfo<TextLabelEntityViewStruct>(Id);
				if (text.textLabelComponent != null) text.textLabelComponent.text = value;
			}
		}

		/// <summary>
		/// Whether the block exists. The other properties will return a default value if the block doesn't exist.
		/// </summary>
		public bool Exists => BlockEngine.BlockExists(Id);

		/// <summary>
		/// Returns an array of blocks that are connected to this one. Returns an empty array if the block doesn't exist.
		/// </summary>
		public Block[] GetConnectedCubes() => BlockEngine.GetConnectedBlocks(Id);

		/// <summary>
		/// Removes this block.
		/// </summary>
		/// <returns>True if the block exists and could be removed.</returns>
		public bool Remove() => RemovalEngine.RemoveBlock(Id);

		/// <summary>
		/// Returns the rigid body of the cluster of blocks this one belongs to during simulation.
		/// Can be used to apply forces or move the block around while the simulation is running.
		/// </summary>
		/// <returns>The SimBody of the cluster</returns>
		public SimBody GetSimBody()
		{
			uint id = BlockEngine.GetBlockInfo<GridConnectionsEntityStruct>(Id).machineRigidBodyId;
			return new SimBody(id);
		}

		public override string ToString()
		{
			return $"{nameof(Id)}: {Id}, {nameof(Position)}: {Position}, {nameof(Type)}: {Type}, {nameof(Color)}: {Color}, {nameof(Exists)}: {Exists}";
		}

		public static void Init()
		{
			GameEngineManager.AddGameEngine(PlacementEngine);
			GameEngineManager.AddGameEngine(MovementEngine);
			GameEngineManager.AddGameEngine(RotationEngine);
			GameEngineManager.AddGameEngine(RemovalEngine);
			GameEngineManager.AddGameEngine(BlockEngine);
		}

        /// <summary>
        /// Convert the block to a specialised block class.
        /// </summary>
        /// <returns>The block.</returns>
        /// <typeparam name="T">The specialised block type.</typeparam>
		public T Specialise<T>() where T : Block
		{
			// What have I gotten myself into?
			// C# can't cast to a child of Block unless the object was originally that child type
			// And C# doesn't let me make implicit cast operators for child types
			// So thanks to Microsoft, we've got this horrible implementation using reflection
			ConstructorInfo ctor = typeof(T).GetConstructor(types: new System.Type[] { typeof(EGID) });
			if (ctor == null)
			{
				throw new BlockSpecializationException("Specialized block constructor does not accept an EGID");
			}
			return (T)ctor.Invoke(new object[] { Id });
		}

#if DEBUG
		public static EntitiesDB entitiesDB
		{
			get
			{
				return BlockEngine.GetEntitiesDB();
			}
		}
#endif
	}
}