NorbiPeti
dba7c0a46f
Added an event for placing and removing blocks Added a class to wrap event calls in a try-catch Removed BlockDoesNotExistException Made Block.GetSimBody() return null if block doesn't exist
329 lines
No EOL
12 KiB
C#
329 lines
No EOL
12 KiB
C#
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 static readonly BlockEventsEngine BlockEventsEngine = new BlockEventsEngine();
|
|
|
|
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.
|
|
/// <para></para>
|
|
/// <para>When placing multiple blocks, do not access properties immediately after creation as this
|
|
/// triggers a sync each time which can affect performance and may cause issues with the game.
|
|
/// You may either use AsyncUtils.WaitForSubmission() after placing all of the blocks
|
|
/// or simply access the block properties which will trigger the synchronization the first time a property is used.</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 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 which may take a significant amount of time.
|
|
/// Only use this to place a single block.
|
|
/// For placing multiple blocks, use PlaceNew() then AsyncUtils.WaitForSubmission() when done with placing blocks.</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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// An event that fires each time a block is placed.
|
|
/// </summary>
|
|
public static event EventHandler<BlockPlacedRemovedEventArgs> Placed
|
|
{
|
|
add => BlockEventsEngine.Placed += value;
|
|
remove => BlockEventsEngine.Placed -= value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// An event that fires each time a block is removed.
|
|
/// </summary>
|
|
public static event EventHandler<BlockPlacedRemovedEventArgs> Removed
|
|
{
|
|
add => BlockEventsEngine.Removed += value;
|
|
remove => BlockEventsEngine.Removed -= value;
|
|
}
|
|
|
|
public Block(EGID id)
|
|
{
|
|
Id = id;
|
|
}
|
|
|
|
public Block(uint id) : this(new EGID(id, CommonExclusiveGroups.OWNED_BLOCKS_GROUP))
|
|
{
|
|
}
|
|
|
|
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.
|
|
/// The default scale of 1 means 0.2 in terms of position.
|
|
/// </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.
|
|
/// The default scale of 1 means 0.2 in terms of position.
|
|
/// </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 or null if the block doesn't exist.</returns>
|
|
public SimBody GetSimBody()
|
|
{
|
|
uint id = BlockEngine.GetBlockInfo<GridConnectionsEntityStruct>(Id, out var exists).machineRigidBodyId;
|
|
return exists ? new SimBody(id) : null;
|
|
}
|
|
|
|
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);
|
|
GameEngineManager.AddGameEngine(BlockEventsEngine);
|
|
}
|
|
|
|
/// <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
|
|
}
|
|
} |