Биом с расширенной генерацией

[DementiaMoss]

Привет, ребят! Я уже порядка недели пытаюсь добавить биом с расширенным типом генерации в мир с обычной генерацией. И мне кажется что это невозможно в рамках мода, без редакции кода самой игры. Возможно ли это?

Игра запускается и мир создаётся. Биом на данный момент представляет из себя равнину с глубокими каньонами и изредка холмистой местностью.

За это время я пробовал взаимодействовать на прямую с PerlinNoise и пытаться в целом повлиять на шум используемый при генерации мира (не через PerlinNoise). Так же пытался работать просто при помощи JSON-файлов, но я в них ещё хуже чем в генерации данных. Приложил последнюю версию кода, так как предыдущие уже не восстановлю.

Пожалуйста, в первую очередь, скажите возможно ли это или я шиз конкретный.

Вот то что я смог накидать (извините код говна) :

public class ModWorldGenProvider extends DatapackBuiltinEntriesProvider {
    public static final ResourceKey<NoiseGeneratorSettings> AMPLIFIED_NOISE_KEY =
            ResourceKey.create(Registries.NOISE_SETTINGS, new ResourceLocation(modid.MOD_ID, "amplified_forest"));

    public static final ResourceKey<DensityFunction> AMPLIFIED_FOREST_DENSITY_KEY =
            ResourceKey.create(Registries.DENSITY_FUNCTION, new ResourceLocation(modid.MOD_ID, "amplified_forest"));

    public static final ResourceKey<ConfiguredFeature<?, ?>> AMPLIFIED_PEAK_KEY =
            ResourceKey.create(Registries.CONFIGURED_FEATURE, new ResourceLocation(modid.MOD_ID, "amplified_peak"));

    public static final ResourceKey<PlacedFeature> AMPLIFIED_PEAK_PLACED_KEY =
            ResourceKey.create(Registries.PLACED_FEATURE, new ResourceLocation(modid.MOD_ID, "amplified_peak_placed"));

    public static final ResourceKey<ConfiguredFeature<?, ?>> OPEN_CAVE_KEY =
            ResourceKey.create(Registries.CONFIGURED_FEATURE, new ResourceLocation(modid.MOD_ID, "open_cave"));

    public static final ResourceKey<PlacedFeature> OPEN_CAVE_PLACED_KEY =
            ResourceKey.create(Registries.PLACED_FEATURE, new ResourceLocation(modid.MOD_ID, "open_cave_placed"));

    public static final ResourceKey<ConfiguredFeature<?, ?>> OAK_KEY =
            ResourceKey.create(Registries.CONFIGURED_FEATURE, new ResourceLocation(modid.MOD_ID, "oak"));

    public static final ResourceKey<PlacedFeature> OAK_PLACED_KEY =
            ResourceKey.create(Registries.PLACED_FEATURE, new ResourceLocation(modid.MOD_ID, "oak_placed"));

    private static boolean featuresRegistered = false;

    private static final RegistrySetBuilder BUILDER = new RegistrySetBuilder();
[COLOR=rgb(84, 172, 210)]//            .add(Registries.DENSITY_FUNCTION, ModWorldGenProvider::registerDensityFunctions)
//            .add(Registries.NOISE_SETTINGS, ModWorldGenProvider::registerNoiseSettings)
//            .add(Registries.CONFIGURED_FEATURE, ModWorldGenProvider::registerConfiguredFeatures)
//            .add(Registries.PLACED_FEATURE, ModWorldGenProvider::registerPlacedFeatures)
//            .add(Registries.BIOME, ModBiomeProvider::bootstrap);[/COLOR]

    public ModWorldGenProvider(PackOutput output, CompletableFuture<HolderLookup.Provider> registries) {
        super(output, registries, BUILDER, Set.of(modid.MOD_ID));
    }

    public static void registerConfiguredFeatures(BootstapContext<ConfiguredFeature<?, ?>> context) {
        modid.LOGGER.info("Registering configured features");

        context.register(AMPLIFIED_PEAK_KEY, new ConfiguredFeature<>(
                Feature.SIMPLE_BLOCK,
                new SimpleBlockConfiguration(BlockStateProvider.simple(Blocks.STONE))
        ));

        context.register(OPEN_CAVE_KEY, new ConfiguredFeature<>(
                        Feature.LAKE,
                        new LakeFeature.Configuration(
                                BlockStateProvider.simple(Blocks.AIR),
                                BlockStateProvider.simple(Blocks.STONE))
                )
        );

        context.register(OAK_KEY, new ConfiguredFeature<>(
                Feature.TREE,
                new TreeConfiguration.TreeConfigurationBuilder(
                        BlockStateProvider.simple(Blocks.OAK_LOG),
                        new StraightTrunkPlacer(5, 2, 0),
                        BlockStateProvider.simple(Blocks.OAK_LEAVES),
                        new BlobFoliagePlacer(ConstantInt.of(2), ConstantInt.of(0), 3),
                        new TwoLayersFeatureSize(1, 0, 1)
                ).build()
        ));
    }

    public static void registerPlacedFeatures(BootstapContext<PlacedFeature> context) {
        if (featuresRegistered) return;

        HolderGetter<ConfiguredFeature<?, ?>> configuredFeatures = context.lookup(Registries.CONFIGURED_FEATURE);

        context.register(AMPLIFIED_PEAK_PLACED_KEY, new PlacedFeature(
                configuredFeatures.getOrThrow(AMPLIFIED_PEAK_KEY),
                List.of(
                        RarityFilter.onAverageOnceEvery(20),
                        InSquarePlacement.spread(),
                        PlacementUtils.HEIGHTMAP_TOP_SOLID,
                        BiomeFilter.biome()
                )
        ));

        context.register(OPEN_CAVE_PLACED_KEY, new PlacedFeature(
                configuredFeatures.getOrThrow(OPEN_CAVE_KEY),
                List.of(
                        RarityFilter.onAverageOnceEvery(10),
                        InSquarePlacement.spread(),
                        PlacementUtils.HEIGHTMAP,
                        BiomeFilter.biome()
                )
        ));

        context.register(OAK_PLACED_KEY, new PlacedFeature(
                configuredFeatures.getOrThrow(OAK_KEY),
                List.of(
                        RarityFilter.onAverageOnceEvery(5),
                        InSquarePlacement.spread(),
                        PlacementUtils.HEIGHTMAP_WORLD_SURFACE,
                        BiomeFilter.biome()
                )
        ));

        featuresRegistered = true;
    }

    public static final VolcanoDensity VOLCANO_DENSITY = new VolcanoDensity(PerlinNoise.create(
            RandomSource.create(12345L),
            20,
            0.001,
            10.0
    ));

    public static void registerDensityFunctions(BootstapContext<DensityFunction> context) {
        context.register(AMPLIFIED_FOREST_DENSITY_KEY, VOLCANO_DENSITY);
        modid.LOGGER.info("Density functions registered");
    }

    public static NoiseGeneratorSettings createAmplifiedNoiseSettings(BootstapContext<NoiseGeneratorSettings> context) {
        SurfaceRules.RuleSource surfaceRules = SurfaceRules.sequence(
                SurfaceRules.ifTrue(
                        SurfaceRules.ON_FLOOR,
                        SurfaceRules.state(Blocks.GRASS_BLOCK.defaultBlockState())
                ),
                SurfaceRules.ifTrue(
                        SurfaceRules.UNDER_FLOOR,
                        SurfaceRules.state(Blocks.DIRT.defaultBlockState())
                ),
                SurfaceRules.ifTrue(
                        SurfaceRules.steep(),
                        SurfaceRules.state(Blocks.STONE.defaultBlockState())
                )
        );

        NoiseSettings settings = NoiseSettings.create(
                -64,
                512,
                1,
                1
        );

        return new NoiseGeneratorSettings(
                settings,
                Blocks.STONE.defaultBlockState(),
                Blocks.WATER.defaultBlockState(),
                createExtremeRouter(context),
                surfaceRules,                          [COLOR=rgb(84, 172, 210)] // surfaceRule[/COLOR]
                Collections.emptyList(),               [COLOR=rgb(84, 172, 210)] // spawnTarget[/COLOR]
                63,                                     [COLOR=rgb(84, 172, 210)]// seaLevel[/COLOR]
                false,                                  [COLOR=rgb(84, 172, 210)]// disableMobGeneration[/COLOR]
                true,                                  [COLOR=rgb(84, 172, 210)] // aquifersEnabled[/COLOR]
                true,                                  [COLOR=rgb(84, 172, 210)] // oreVeinsEnabled[/COLOR]
                false                                  [COLOR=rgb(84, 172, 210)] // useLegacyRandomSource[/COLOR]
        );
    }

    private static NoiseRouter createExtremeRouter(BootstapContext<?> context) {
        return new NoiseRouter(
                [COLOR=rgb(84, 172, 210)]/* barrier */[/COLOR]               createMegaMountains(),
                [COLOR=rgb(84, 172, 210)]/* fluid_level_floodedness */[/COLOR] DensityFunctions.constant(0.0),
                [COLOR=rgb(84, 172, 210)]/* fluid_level_spread */[/COLOR]     DensityFunctions.constant(0.0),
                [COLOR=rgb(84, 172, 210)]/* lava */[/COLOR]                  DensityFunctions.constant(0.0),
                [COLOR=rgb(84, 172, 210)]/* temperature */[/COLOR]           createChaoticNoise(-10, 3.0),
                [COLOR=rgb(84, 172, 210)]/* vegetation */[/COLOR]            DensityFunctions.constant(0.0),
               [COLOR=rgb(84, 172, 210)] /* continents */[/COLOR]            createContinentNoise(),
                [COLOR=rgb(84, 172, 210)]/* erosion */[/COLOR]               createErosionNoise().clamp(-3.5, 3.5),
               [COLOR=rgb(84, 172, 210)] /* depth */[/COLOR]                 createVerticalGradient(),
                [COLOR=rgb(84, 172, 210)]/* ridges */[/COLOR]                createRidgeNoise(),
               [COLOR=rgb(84, 172, 210)] /* initial_density */[/COLOR]       DensityFunctions.add(
                createFloatingIslands(),
                DensityFunctions.mul(
                        DensityFunctions.yClampedGradient(-64, 384, -8, 100.0),
                        DensityFunctions.constant(400.0)
                )
        ),
               [COLOR=rgb(84, 172, 210)] /* final_density */[/COLOR]         DensityFunctions.add(applyVerticalBoost(), VOLCANO_DENSITY),
                [COLOR=rgb(84, 172, 210)]/* vein_toggle */[/COLOR]           DensityFunctions.constant(0.0),
                [COLOR=rgb(84, 172, 210)]/* vein_ridged */[/COLOR]           DensityFunctions.constant(0.0),
                [COLOR=rgb(84, 172, 210)]/* vein_gap */[/COLOR]              DensityFunctions.constant(0.0)
        );
    }


    public static void registerNoiseSettings(BootstapContext<NoiseGeneratorSettings> context) {
        context.register(AMPLIFIED_NOISE_KEY, createAmplifiedNoiseSettings(context));
       modid.LOGGER.info("Amplified noise settings registered!");
    }

    private static DensityFunction createMegaMountains() {
        return DensityFunctions.add(
                DensityFunctions.constant(-2.5),
                DensityFunctions.mul(
                        DensityFunctions.yClampedGradient(-64, 512, -20.0, 400.0),
                        DensityFunctions.constant(1500.0)
                )
        );
    }

    private static DensityFunction createFloatingIslands() {
        DensityFunction primaryNoise = DensityFunctions.noise(
                Holder.direct(new NormalNoise.NoiseParameters(-3, 15.0)),
                0.0003,
                0.0003
        );
        return DensityFunctions.add(
                DensityFunctions.mul(
                        DensityFunctions.constant(200.0),
                        primaryNoise
                ),
                DensityFunctions.mul(
                        DensityFunctions.yClampedGradient(100, 400, 1.0, -1.0),
                        DensityFunctions.constant(500.0)
                )
        );
    }

    private static DensityFunction applyVerticalBoost() {
        return DensityFunctions.add(
                createFloatingIslands(),
                DensityFunctions.mul(
                        DensityFunctions.yClampedGradient(-64, 384, -1.5, 2.5),
                        DensityFunctions.constant(250.0)
                )
        ).clamp(-64.0, 384.0);
    }

    private static DensityFunction createChaoticNoise(int firstOctave, double amplitude) {
        return DensityFunctions.noise(
                Holder.direct(new NormalNoise.NoiseParameters(firstOctave, amplitude)),
                0.8,
                0.1
        );
    }

    private static DensityFunction createContinentNoise() {
        return DensityFunctions.mul(
                DensityFunctions.constant(8),
                DensityFunctions.noise(
                        Holder.direct(new NormalNoise.NoiseParameters(-12, 40.0)),
                        0.1,
                        0.1
                ).clamp(-3.0, 3.0)
        );
    }

    private static DensityFunction createErosionNoise() {
        return DensityFunctions.add(
                DensityFunctions.constant(-1.5),
                DensityFunctions.noise(
                        Holder.direct(new NormalNoise.NoiseParameters(-11, 20.0)),
                        1.2,
                        1.2
                )
        ).clamp(-2.5, 2.5);
    }

    private static DensityFunction createRidgeNoise() {
        return DensityFunctions.mul(
                DensityFunctions.constant(3),
                DensityFunctions.noise(
                        Holder.direct(new NormalNoise.NoiseParameters(-7, 3.0)),
                        1.5,
                        1.5
                ).clamp(-1.5, 1.5)
        );
    }

    private static DensityFunction createVerticalGradient() {
        return DensityFunctions.yClampedGradient(-64, 512, -0.7, 3.9);
    }
}

public class ModBiomeProvider extends DatapackBuiltinEntriesProvider {
    private static final RegistrySetBuilder BUILDER = new RegistrySetBuilder()
            .add(Registries.BIOME, ModBiomeProvider::bootstrap)
            .add(Registries.DENSITY_FUNCTION, ModWorldGenProvider::registerDensityFunctions)
            .add(Registries.NOISE_SETTINGS, ModWorldGenProvider::registerNoiseSettings)
            .add(Registries.CONFIGURED_FEATURE, ModWorldGenProvider::registerConfiguredFeatures)
            .add(Registries.PLACED_FEATURE, ModWorldGenProvider::registerPlacedFeatures);

    public ModBiomeProvider(PackOutput output, CompletableFuture<HolderLookup.Provider> registries) {
        super(output, registries, BUILDER, Set.of(modid.MOD_ID));
    }

    static void bootstrap(BootstapContext<Biome> context) {
        modid.LOGGER.info("Registering biome: amplified_forest");
        context.register(
                ResourceKey.create(Registries.BIOME, ResourceLocation.fromNamespaceAndPath(modid.MOD_ID, "amplified_forest")),
                createAmplifiedForestBiome(context)
        );
        modid.LOGGER.info("Biome amplified_forest registered successfully");
    }

    private static Biome createAmplifiedForestBiome(BootstapContext<Biome> context) {
        HolderGetter<PlacedFeature> placedFeatureGetter = context.lookup(Registries.PLACED_FEATURE);
        HolderGetter<ConfiguredWorldCarver<?>> carverGetter = context.lookup(Registries.CONFIGURED_CARVER);

        HolderGetter<NoiseGeneratorSettings> noiseSettings = context.lookup(Registries.NOISE_SETTINGS);
        Holder<NoiseGeneratorSettings> amplifiedNoise = noiseSettings.getOrThrow(ModWorldGenProvider.AMPLIFIED_NOISE_KEY);

        BiomeGenerationSettings.Builder generationSettings = new BiomeGenerationSettings.Builder(
                placedFeatureGetter,
                carverGetter
        );

        ResourceKey<PlacedFeature> openCaveKey = ResourceKey.create(
                Registries.PLACED_FEATURE, ResourceLocation.fromNamespaceAndPath(modid.MOD_ID, "open_cave_placed"));
        try {
            Holder<PlacedFeature> openCaveFeature = placedFeatureGetter.getOrThrow(openCaveKey);
            generationSettings.addFeature(GenerationStep.Decoration.UNDERGROUND_STRUCTURES, openCaveFeature);
            modid.LOGGER.info("Open cave feature added to amplified_forest");
        } catch (IllegalStateException e) {
            modid.LOGGER.error("Failed to add open cave feature: {}", openCaveKey, e);
        }

        ResourceKey<PlacedFeature> peakKey = ResourceKey.create(
                Registries.PLACED_FEATURE, ResourceLocation.fromNamespaceAndPath(modid.MOD_ID, "amplified_peak_placed"));
        try {
            Holder<PlacedFeature> peakFeature = placedFeatureGetter.getOrThrow(peakKey);
            generationSettings.addFeature(GenerationStep.Decoration.TOP_LAYER_MODIFICATION, peakFeature);
            modid.LOGGER.info("Amplified peak feature added to amplified_forest");
        } catch (IllegalStateException e) {
            modid.LOGGER.error("Failed to add amplified peak feature: {}", peakKey, e);
        }

        ResourceKey<PlacedFeature> oakKey = ResourceKey.create(
                Registries.PLACED_FEATURE, ResourceLocation.fromNamespaceAndPath(modid.MOD_ID, "oak_placed"));
        try {
            Holder<PlacedFeature> oakTreeFeature = placedFeatureGetter.getOrThrow(oakKey);
            generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, oakTreeFeature);
            modid.LOGGER.info("Oak trees added to amplified_forest");
        } catch (IllegalStateException e) {
            modid.LOGGER.error("Failed to add oak tree feature: {}", oakKey, e);
        }

        BiomeDefaultFeatures.addDefaultOres(generationSettings);
        BiomeDefaultFeatures.addDefaultSoftDisks(generationSettings);
        BiomeDefaultFeatures.addDefaultFlowers(generationSettings);
        BiomeDefaultFeatures.addDefaultGrass(generationSettings);
        BiomeDefaultFeatures.addDefaultMushrooms(generationSettings);
        BiomeDefaultFeatures.addDefaultCarversAndLakes(generationSettings);
        BiomeDefaultFeatures.addExtraEmeralds(generationSettings);
        BiomeDefaultFeatures.addInfestedStone(generationSettings);

        BiomeGenerationSettings builtGenerationSettings = generationSettings.build();

        return new Biome.BiomeBuilder()
                .temperature(0.7F)
                .downfall(0.9F)
                .generationSettings(generationSettings.build())
                .mobSpawnSettings(new MobSpawnSettings.Builder().build())
                .specialEffects(new BiomeSpecialEffects.Builder()
                        .skyColor(0x78A7FF)
                        .fogColor(0xC0D8FF)
                        .waterColor(0x3F76E4)
                        .waterFogColor(0x050533)
                        .grassColorOverride(0x8FFE09)
                        .foliageColorOverride(0x77AB2F)
                        .build())
                .temperatureAdjustment(Biome.TemperatureModifier.FROZEN)
                .hasPrecipitation(true)
                .build();
    }
}

public class ModSurfaceRules {

    public static void register() {
        SurfaceRuleManager.addSurfaceRules(
                SurfaceRuleManager.RuleCategory.OVERWORLD,
                "modid",
                SurfaceRules.sequence(
                        SurfaceRules.ifTrue(
                                SurfaceRules.abovePreliminarySurface(),
                                SurfaceRules.sequence(

                                        SurfaceRules.ifTrue(
                                                SurfaceRules.ON_FLOOR,
                                                SurfaceRules.ifTrue(
                                                        SurfaceRules.not(SurfaceRules.steep()),
                                                        SurfaceRules.state(Blocks.GRASS_BLOCK.defaultBlockState())
                                                )
                                        ),

                                        SurfaceRules.ifTrue(
                                                SurfaceRules.UNDER_FLOOR,
                                                SurfaceRules.state(Blocks.DIRT.defaultBlockState())
                                        ),

                                        SurfaceRules.ifTrue(
                                                SurfaceRules.steep(),
                                                SurfaceRules.state(Blocks.STONE.defaultBlockState())
                                        )
                                )
                        )
                )
        );

    }
}

public class AmplifiedBiome {
    public static final ResourceKey<Biome> AMPLIFIED_FOREST_KEY = ResourceKey.create(
            Registries.BIOME,
            new ResourceLocation("modid", "amplified_forest")
    );
}

public class ModBiomes {
    public static final ResourceKey<Biome> AMPLIFIED_FOREST_KEY = ResourceKey.create(
            Registries.BIOME,
            new ResourceLocation(modid.MOD_ID, "amplified_forest")
    );

    public static void register() {

    }
}

public class ModOverworldRegion extends Region {
    public ModOverworldRegion(ResourceLocation name, int weight) {
        super(name, RegionType.OVERWORLD, weight);
    }

    @Override
    public void addBiomes(Registry<Biome> registry, Consumer<Pair<Climate.ParameterPoint, ResourceKey<Biome>>> mapper) {
        Climate.ParameterPoint parameters = Climate.parameters(
                Climate.Parameter.span(-1.0F, 1.0F),
                Climate.Parameter.span(-1.0F, 1.0F),
                Climate.Parameter.span(-1.0F, 1.0F),
                Climate.Parameter.span(-1.0F, 1.0F),
                Climate.Parameter.span(-1.0F, 1.0F),
                Climate.Parameter.span(-1.0F, 1.0F),
                0L
        );
        this.addBiome(mapper, parameters, ModBiomes.AMPLIFIED_FOREST_KEY);
    }
}

public class ModTerrablender {
    private static final Logger LOGGER = LogManager.getLogger();

    public static final DeferredRegister<Biome> BIOMES =
            DeferredRegister.create(Registries.BIOME, modid.MOD_ID);

    public static final ResourceLocation AMPLIFIED_FOREST_ID =
            new ResourceLocation(modid.MOD_ID, "amplified_forest");

    public static void registerBiomes() {
        modid.LOGGER.info("Registering TerraBlender region for modid...");
        Regions.register(new ModOverworldRegion(new ResourceLocation(modid.MOD_ID, "overworld"), 2));
        modid.LOGGER.info("TerraBlender region registered.");
    }

    public static void register() {
        LOGGER.info("Registering TerraBlender region for modid...");
        Regions.register(new ModOverworldRegion(new ResourceLocation(modid.MOD_ID, "overworld"), 2));
        LOGGER.info("TerraBlender region registered.");
    }
}

public class VolcanoDensity implements DensityFunction {
    private final PerlinNoise noise;

    public VolcanoDensity(PerlinNoise perlinNoise) {
        this.noise = perlinNoise;
    }

    @Override
    public double compute(FunctionContext context) {
        double x = context.blockX() * 0.008;
        double z = context.blockZ() * 0.008;
        double y = context.blockY() * 0.001;

        if (context.blockY() < 80) {
            return 0;
        }

        double base = Math.sin(x * 12) * Math.cos(z * 12) * 600;
        double details = noise.getValue(x * 6, z * 6, y) * 400;
        return base + details;
    }

    @Override
    public void fillArray(double[] pArray, ContextProvider pContextProvider) {

    }

    @Override
    public DensityFunction mapAll(Visitor pVisitor) {
        return null;
    }

    @Override
    public double minValue() {
        return -600;
    }

    @Override
    public double maxValue() {
        return 600;
    }

    @Override
    public KeyDispatchDataCodec<? extends DensityFunction> codec() {
        return KeyDispatchDataCodec.of(
                Codec.unit(new VolcanoDensity(this.noise))
        );
    }
}

@Mod(com.middlemoss.modid.modid.MOD_ID)
public class modid {

    public static final String MOD_ID = "modid";
    public static final Logger LOGGER = LogUtils.getLogger();

    public static final ResourceLocation CHARGE_BAR_ID = new ResourceLocation("modid", "charge_bar");

    public modid(FMLJavaModLoadingContext context) {

        IEventBus MOD_EVENT_BUS = FMLJavaModLoadingContext.get().getModEventBus();

        IEventBus modEventBus = context.getModEventBus();

        modEventBus.addListener(this::gatherData);
        modEventBus.addListener(this::commonSetup);

        ModItems.register(modEventBus);
        ModBlocks.register(modEventBus);
        ModCreativeModTabs.register(modEventBus);

        ModSounds.register(modEventBus);

        ModBiomes.register();
        ModSurfaceRules.register();

        LOGGER.info("Initializing modid...");
        ModTerrablender.BIOMES.register(MOD_EVENT_BUS);
        ModTerrablender.registerBiomes();
        MOD_EVENT_BUS.addListener(this::commonSetup);
        LOGGER.info("modid initialization complete.");

        MinecraftForge.EVENT_BUS.register(this);

        modEventBus.addListener(this::addCreative);
    }

    private void commonSetup(final FMLCommonSetupEvent event) {
        event.enqueueWork(() -> {
            Regions.register(new ModOverworldRegion(new ResourceLocation(MOD_ID, "overworld"), 2));
        });
    }

    private void addCreative(BuildCreativeModeTabContentsEvent event) {
        if(event.getTabKey() == CreativeModeTabs.INGREDIENTS) {
            event.accept(ModItems.COPPER_SHEET);
        }
    }

    @SubscribeEvent
    public void onServerStarting(ServerStartingEvent event) {

        LOGGER.info("Server starting, registering TerraBlender region...");
        ModTerrablender.register();
        LOGGER.info("Server starting setup complete.");

        LOGGER.info("HELLO from server starting");
    }

    @Mod.EventBusSubscriber(modid = MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
    public static class ClientModEvents {
        @SubscribeEvent
        public static void onClientSetup(FMLClientSetupEvent event)
        {

        }
    }

    private void gatherData(GatherDataEvent event) {
        DataGenerator generator = event.getGenerator();
        PackOutput packOutput = generator.getPackOutput();
        ExistingFileHelper existingFileHelper = event.getExistingFileHelper();
        CompletableFuture<HolderLookup.Provider> lookupProvider = event.getLookupProvider();

[COLOR=rgb(84, 172, 210)]//        generator.addProvider(event.includeServer(), new ModWorldGenProvider(packOutput, lookupProvider));[/COLOR]
        generator.addProvider(event.includeServer(), new ModBiomeProvider(packOutput, lookupProvider));
    }
}