net.minecraft.block.entity.BlockEntityType Java Examples

public static void setupGlobal() {
    Set<String> supportedMods = Sets.newHashSet("minecraft", "sandbox", "sandboxapi", "fabricloader");
    Sandbox.unsupportedModsLoaded = FabricLoader.getInstance().getAllMods().stream()
            .map(ModContainer::getMetadata)
            .map(ModMetadata::getId)
            .anyMatch(((Predicate<String>) supportedMods::contains).negate());
    Policy.setPolicy(new AddonSecurityPolicy());

    Registry.REGISTRIES.add(new Identifier("sandbox", "container"), SandboxRegistries.CONTAINER_FACTORIES);

    ((SandboxInternal.Registry) Registry.BLOCK).set(new BasicRegistry<>(Registry.BLOCK, Block.class, WrappingUtil::convert, WrappingUtil::convert));
    ((SandboxInternal.Registry) Registry.ITEM).set(new BasicRegistry<>(Registry.ITEM, Item.class, WrappingUtil::convert, WrappingUtil::convert));
    ((SandboxInternal.Registry) Registry.ENCHANTMENT).set(new BasicRegistry<>((SimpleRegistry<net.minecraft.enchantment.Enchantment>) Registry.ENCHANTMENT, Enchantment.class, WrappingUtil::convert, b -> (Enchantment) b));
    ((SandboxInternal.Registry) Registry.FLUID).set(new BasicRegistry<>(Registry.FLUID, Fluid.class, WrappingUtil::convert, WrappingUtil::convert));
    ((SandboxInternal.Registry) Registry.ENTITY_TYPE).set(new BasicRegistry<>(Registry.ENTITY_TYPE, Entity.Type.class, WrappingUtil::convert, WrappingUtil::convert));
    ((SandboxInternal.Registry) Registry.BLOCK_ENTITY).set(new BasicRegistry((SimpleRegistry) Registry.BLOCK_ENTITY, BlockEntity.Type.class, (Function<BlockEntity.Type, BlockEntityType>) WrappingUtil::convert, (Function<BlockEntityType, BlockEntity.Type>) WrappingUtil::convert, true)); // DONT TOUCH THIS FOR HEAVENS SAKE PLEASE GOD NO
    ((SandboxInternal.Registry) SandboxRegistries.CONTAINER_FACTORIES).set(new BasicRegistry<>(SandboxRegistries.CONTAINER_FACTORIES, ContainerFactory.class, a -> a, a -> a));
}
 

private void mutateBlockEntityRegistry(ISimpleRegistry<BlockEntityType<?>> registry) {
    registry.unregister(BlockEntityType.BARREL);
    registry.unregister(BlockEntityType.SMOKER);
    registry.unregister(BlockEntityType.BLAST_FURNACE);
    registry.unregister(BlockEntityType.LECTERN);
    registry.unregister(BlockEntityType.BELL);
    registry.unregister(BlockEntityType.JIGSAW);
    registry.unregister(BlockEntityType.CAMPFIRE);
}
 

@Override
public void onInitialize() {
	Registry.register(Registry.ITEM, new Identifier(MODID, "client_gui"), new GuiItem());
	
	GUI_BLOCK = new GuiBlock();
	Registry.register(Registry.BLOCK, new Identifier(MODID, "gui"), GUI_BLOCK);
	GUI_BLOCK_ITEM = new BlockItem(GUI_BLOCK, new Item.Settings().group(ItemGroup.MISC));
	Registry.register(Registry.ITEM, new Identifier(MODID, "gui"), GUI_BLOCK_ITEM);
	GUI_BLOCKENTITY_TYPE = BlockEntityType.Builder.create(GuiBlockEntity::new, GUI_BLOCK).build(null);
	Registry.register(Registry.BLOCK_ENTITY_TYPE, new Identifier(MODID, "gui"), GUI_BLOCKENTITY_TYPE);
	
	GUI_SCREEN_HANDLER_TYPE = ScreenHandlerRegistry.registerSimple(new Identifier(MODID, "gui"), (int syncId, PlayerInventory inventory) -> {
		return new TestDescription(GUI_SCREEN_HANDLER_TYPE, syncId, inventory, ScreenHandlerContext.EMPTY);
	});

	Optional<ModContainer> containerOpt = FabricLoader.getInstance().getModContainer("jankson");
	if (containerOpt.isPresent()) {
		ModContainer jankson = containerOpt.get();
		System.out.println("Jankson root path: "+jankson.getRootPath());
		try {
			Files.list(jankson.getRootPath()).forEach((path)->{
				path.getFileSystem().getFileStores().forEach((store)->{
					System.out.println("        Filestore: "+store.name());
				});
				System.out.println("    "+path.toAbsolutePath());
			});
		} catch (IOException e) {
			e.printStackTrace();
		}
		Path modJson = jankson.getPath("/fabric.mod.json");
		System.out.println("Jankson fabric.mod.json path: "+modJson);
		System.out.println(Files.exists(modJson) ? "Exists" : "Does Not Exist");
	} else {
		System.out.println("Container isn't present!");
	}
}
 

@Override
public IForgeRegistryEntry<BlockEntityType> setRegistryName(Identifier name) {
	this.registryName = name;

	return this;
}
 

public static void resolve(boolean ponySkulls) {
    Mson.getInstance().getEntityRendererRegistry().registerBlockRenderer(BlockEntityType.SKULL,
            ponySkulls ? PonySkullRenderer::new : SkullBlockEntityRenderer::new
    );
}
 

public AbstractFurnaceBlockEntityMixin_RealTime(BlockEntityType<?> blockEntityType_1) {
    super(blockEntityType_1);
}
 

public BrewingStandBlockEntityMixin_RealTime(BlockEntityType<?> blockEntityType_1) {
    super(blockEntityType_1);
}
 

protected HopperBlockEntityMixin(BlockEntityType<?> blockEntityType_1) {
    super(blockEntityType_1);
}
 

public PistonBlockEntity_movableTEMixin(BlockEntityType<?> blockEntityType_1)
{
    super(blockEntityType_1);
}
 

@Shadow
public abstract BlockEntityType<?> getType();
 

public MixinHopperBlockEntity(BlockEntityType<?> blockEntityType_1) {
    super(blockEntityType_1);
}
 

@Override
public <T extends BlockEntity> BlockEntity.Type<T> blockEntityTypeFunction(Supplier<T> s, Block[] b) {
    return (BlockEntity.Type) BlockEntityType.Builder.create((Supplier) () -> WrappingUtil.convert(s.get()), WrappingUtil.convert(b)).build(null);
}
 

public static BlockEntity.Type convert(BlockEntityType type) {
    return cast(type, BlockEntity.Type.class);
}
 

public static BlockEntityType convert(BlockEntity.Type type) {
    return cast(type, BlockEntityType.class);
}
 

public Class<BlockEntityType> getRegistryType() {
	return BlockEntityType.class;
}
 

public Identifier getRegistryName() {
	BlockEntityType<?> blockEntityType = (BlockEntityType<?>) (Object) this;

	return Identifiers.getOrFallback(Registry.BLOCK_ENTITY, blockEntityType, registryName);
}
 

public ConfigurableElectricMachineBlockEntity(BlockEntityType<? extends ConfigurableElectricMachineBlockEntity> blockEntityType) {
    super(blockEntityType);
    capacitorComponent.getListeners().add(this::markDirty);
    this.inventory.getListeners().add(this::markDirty);
}
 

protected DispenserBlockEntity_craftingMixin(BlockEntityType<?> blockEntityType_1)
{
    super(blockEntityType_1);
}
 

public MixinSkullBlockEntity(BlockEntityType<?> type) {
    super(type);
}
 

public MixinBedBlockEntity(BlockEntityType<?> type) {
    super(type);
}
 

public MixinBannerBlockEntity(BlockEntityType<?> type) {
    super(type);
}
 

public static void registerBlockEntities(ISimpleRegistry<BlockEntityType<?>> registry) {
    registry.unregister(BlockEntityType.CONDUIT);
    AbstractProtocol.insertAfter(registry, BlockEntityType.MOB_SPAWNER, NOTE_BLOCK, "noteblock");
    AbstractProtocol.insertAfter(registry, BlockEntityType.COMPARATOR, FLOWER_POT, "flower_pot");
}
 

private void mutateBlockEntityTypeRegistry(ISimpleRegistry<BlockEntityType<?>> registry) {
    registry.unregister(BlockEntityType.BEEHIVE);
}
 

private void mutateBlockEntityTypeRegistry(ISimpleRegistry<BlockEntityType<?>> registry) {
    registry.purge(BlockEntityType.SHULKER_BOX);
}
 

public SignBlockEntityMixin(WurstClient wurst, BlockEntityType<?> type)
{
	super(type);
}
 

@Inject(method = "supports(Lnet/minecraft/block/Block;)Z", at = @At("HEAD"), cancellable = true)
private void supports(Block block, CallbackInfoReturnable<Boolean> info) {
	if (BlockEntityType.SIGN.equals((Object) this) && block instanceof HallowedSign) {
		info.setReturnValue(true);
	}
}
 

private static <B extends BlockEntity> BlockEntityType<B> register(String name, Supplier<B> supplier, Block... supportedBlocks) {
	return Registry.register(Registry.BLOCK_ENTITY_TYPE, TheHallow.id(name), BlockEntityType.Builder.create(supplier, supportedBlocks).build(null));
}