Api Reference

if (ModList.get().isLoaded("bagofyurting"))
{
	YourBagOfYurtingProxy.doBagOfYurtingStuff();
}

public class YourBagOfYurtingProxy
{
	public static void doBagOfYurtingStuff()
	{
		BagOfYurtingAPI.registerBlockDataTransformer(yourTileEntityType, serializer, deserializer);
	}
}

	/**
	 * Register block data transformers to a tile entity type. Call this during FMLCommonSetupEvent.
	 * This is safe to call during multithreaded modloading. It will stop being safe to call once modloading concludes.
	 * @param <T> The class type of the tile entity, e.g. ChestTileEntity. Generic bounds on the de/serialization
	 * function parameters must be no higher than TileEntity and no lower than T.
	 * e.g. if T is LockableLootTileEntity, you can provide a function that requires a TileEntity,
	 * but not one that requires a ChestTileEntity.
	 * @param type The type of the tile entity; only one pair of data transformers can be assigned to a given type
	 * @param serializer Yurt-context-sensitive serializer for the given block entity type
	 * @param deserializer Yurt-context-sensitive deserializer for the given block entity type
	 */
	public static <T extends TileEntity> void registerBlockDataTransformer(TileEntityType<T> type,
		BlockDataSerializer<? super T> serializer,
		BlockDataDeserializer<? super T> deserializer);

@FunctionalInterface
public interface BlockDataSerializer<T>
{
	/**
	 * Function that writes a blockentity's data into the supplied compoundNBT.
	 * This is called after what-blocks-to-remove are determined, but before any blocks are actually removed from the world.
	 * Making changes to the world at this point will not change which blocks are stored in the bag.
	 * @param blockEntity The blockentity instance being yurted. Has world/pos/state context if needed.
	 * @param nbt An empty nbt compound that the implementer should write data into.
	 * This should be a standard-format blockentity compound; if no BlockDataSerializer is assigned to the relevant tile entity type,
	 * then TileEntity::write is used by default instead.
	 * The rotation should be applied to any rotation-sensitive data.
	 * @param rotation A rotation that should be applied to any rotation-sensitive data.
	 * @param minYurt The minimal corner of the yurt region.
	 * @param maxYurt The maximal corner of the yurt region.
	 * @param origin The blockpos in absolute worldspace that the bag of yurting was used on (the bottom center of the yurt region)
	 * @param newOffset The position that the translated-and-rotated te position will be stored as in yurt data (as an offset relative to the 0,0,0 origin)
	 */
	public void writeWithYurtContext(T blockEntity, CompoundNBT nbt, Rotation rotation, BlockPos minYurt, BlockPos maxYurt, BlockPos origin, BlockPos newOffset);
}

@FunctionalInterface
public interface BlockDataDeserializer<T>
{
	/**
	 * Function that reads a standard-format blockentity compound into the given blockentity, applying transformations
	 * from yurt context if necessary. This function is called for each blockentity that becomes unyurted into the world,
	 * after all blocks and blockentities have been placed into the world.
	 * 
	 * Be aware that minYurt and maxYurt are based on the yurting radius of the bag item, and the area defined by them
	 * may be larger than the area actually changed during the unyurting.
	 * 
	 * @param blockEntity The new blockentity that data is being read into.
	 * @param input The compound from yurt data that we are reading into the blockentity.
	 * @param world The world that the blockentity was placed in.
	 * @param pos The position that the blockentity was placed at.
	 * If the blockentity has any absolute-position-sensitive data that must be translated when yurted,
	 * it is recommended to subtract the old position when serializing and to add the new position when deserializing.
	 * (The position of the blockentity itself is handled automatically and does not need to be manually transformed by the implementor).
	 * @param state The new blockstate in the world at the te's position
	 * @param rotation A rotation to apply to any rotation-sensitive data in the blockentity.
	 * @param minYurt The minimal corner of the yurt region being placed into the world.
	 * @param maxYurt The maximal corner of the yurt region being placed into the world
	 * @param origin The position that the bag of yurting was used at to unload blocks (the bottom-center of the yurting region)
	 * 
	 */
	public void readWithYurtContext(T blockEntity, CompoundNBT input, World world, BlockPos pos, BlockState state, Rotation rotation, BlockPos minYurt, BlockPos maxYurt, BlockPos origin);
}