Java Code Examples for net.minecraft.util.registry.Registry#register()

@Override
public void register(V value) {
	Objects.requireNonNull(value, "value must not be null");
	Identifier identifier = value.getRegistryName();

	Optional<V> potentialOldValue = vanilla.getOrEmpty(identifier);

	potentialOldValue.ifPresent(
			oldValue -> {
				if (oldValue == value) {
					LOGGER.warn(REGISTRIES, "Registry {}: The object {} has been registered twice for the same name {}.", this.superType.getSimpleName(), value, identifier);

					return;
				} else {
					throw new IllegalArgumentException(String.format("The name %s has been registered twice, for %s and %s.", identifier, oldValue, value));
				}
			}
	);

	Identifier oldIdentifier = vanilla.getId(value);

	if (oldIdentifier != getDefaultKey()) {
		throw new IllegalArgumentException(String.format("The object %s{%x} has been registered twice, using the names %s and %s.", value, System.identityHashCode(value), oldIdentifier, identifier));
	}

	Registry.register(vanilla, identifier, value);
}
 

private static <T extends Recipe<?>> RecipeType<T> registerType(String id) {
    return Registry.register(Registry.RECIPE_TYPE, new Identifier(Constants.MOD_ID, id), new RecipeType<T>() {
        public String toString() {
            return id;
        }
    });
}
 

public static void register() {
        Registry.register(UniversalComponents.ENERGY_TYPES, new Identifier(Constants.MOD_ID, Constants.Energy.GALACTICRAFT_JOULES), GALACTICRAFT_JOULES);
        Registry.register(UniversalComponents.ENERGY_TYPES, new Identifier(Constants.MOD_ID, Constants.Energy.GALACTICRAFT_OXYGEN), GALACTICRAFT_OXYGEN);

//        ItemComponentCallback.event(GalacticraftItems.BATTERY).register((stack, container) -> container.put(UniversalComponents.CAPACITOR_COMPONENT, new ItemCapacitorComponent(BatteryItem.getMaxEnergy(), GalacticraftEnergy.GALACTICRAFT_JOULES)));
//        ItemComponentCallback.event(GalacticraftItems.INFINITE_BATTERY).register((stack, container) -> {
//            ItemCapacitorComponent capacitorComponent = new ItemCapacitorComponent(Integer.MAX_VALUE, GalacticraftEnergy.GALACTICRAFT_JOULES);
//            capacitorComponent.copyFrom(GalacticraftEnergy.INFINITE_ENERGY_COMPONENT);
//            container.put(UniversalComponents.CAPACITOR_COMPONENT, capacitorComponent);
//        });
    }
 

@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!");
	}
}
 

public static <C extends FeatureConfig, F extends Feature<C>> F register(String name, F feature) {
	return Registry.register(Registry.FEATURE, TheHallow.id(name), feature);
}
 

public static void register() {
    Registry.register(Registry.BIOME_SOURCE, new Identifier(Constants.MOD_ID, "moon"), MoonBiomeSource.CODEC);
}
 

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));
}
 

protected static <T extends Item> T register(String name, T item) {
	return Registry.register(Registry.ITEM, TheHallow.id(name), item);
}
 

protected static <T extends Enchantment> T register(String name, T enchantment) {
	return Registry.register(Registry.ENCHANTMENT, TheHallow.id(name), enchantment);
}
 

private static SoundEvent register(String name) {
	return Registry.register(Registry.SOUND_EVENT, TheHallow.id(name), new SoundEvent(TheHallow.id(name)));
}
 

public static <C extends SurfaceConfig, F extends SurfaceBuilder<C>> F register(String name, F surfaceBuilder) {
	return Registry.register(Registry.SURFACE_BUILDER, TheHallow.id(name), surfaceBuilder);
}
 

static <T extends Fluid> T register(String name, T fluid) {
	T b = Registry.register(Registry.FLUID, TheHallow.id(name), fluid);
	return b;
}
 

private static <T extends Biome> T register(String name, T biome) {
	return Registry.register(Registry.BIOME, TheHallow.id(name), biome);
}
 

private static <S extends RecipeSerializer<T>, T extends Recipe<?>> S registerSerializer(String id, S serializer) {
    return Registry.register(Registry.RECIPE_SERIALIZER, new Identifier(Constants.MOD_ID, id), serializer);
}
 

private static Block registerMachine(Block block, String id) {
    Block registered = Registry.register(Registry.BLOCK, new Identifier(Constants.MOD_ID, id), block);
    Registry.register(Registry.ITEM, new Identifier(Constants.MOD_ID, id), new BlockItem(registered, new Item.Settings().group(MACHINES_GROUP)));
    return registered;
}
 

private static Block registerBlock(Block block, String id) {
    Block registered = registerBlockWithoutItem(block, id);
    Registry.register(Registry.ITEM, new Identifier(Constants.MOD_ID, id), new BlockItem(registered, new Item.Settings().group(BLOCKS_GROUP)));
    return registered;
}
 

private static Block registerBlockWithoutItem(Block block, String id) {
    return Registry.register(Registry.BLOCK, new Identifier(Constants.MOD_ID, id), block);
}
 

public static void register() {
    Registry.register(Registry.PARTICLE_TYPE, new Identifier(Constants.MOD_ID, Constants.Particles.DRIPPING_CRUDE_OIL_PARTICLE), DRIPPING_FUEL_PARTICLE);
    Registry.register(Registry.PARTICLE_TYPE, new Identifier(Constants.MOD_ID, Constants.Particles.DRIPPING_FUEL_PARTICLE), DRIPPING_CRUDE_OIL_PARTICLE);
    Galacticraft.logger.info("Registered particles!");
}
 

private static CelestialBodyType register(CelestialBodyType type) {
    return Registry.register(AddonRegistry.CELESTIAL_BODIES, type.getId(), type);
}
 

public static void register() {
    Registry.register(Registry.CHUNK_GENERATOR, new Identifier(Constants.MOD_ID, "moon"), MoonChunkGenerator.CODEC);

    MOON = RegistryKey.of(Registry.DIMENSION, new Identifier(Constants.MOD_ID, "moon"));

    FabricDimensions.registerDefaultPlacer(MOON, GalacticraftDimensions::placeEntity);
}