package net.minecraft.world.level.levelgen.feature;

import com.google.common.collect.ImmutableList;
import net.minecraft.Util;
import net.minecraft.world.level.levelgen.structure.OceanRuinFeature;
import java.util.Locale;
import com.google.common.collect.HashBiMap;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.Block;
import java.util.Collections;
import net.minecraft.world.level.biome.Biome;
import java.util.Random;
import net.minecraft.world.level.levelgen.ChunkGeneratorSettings;
import net.minecraft.world.level.chunk.ChunkGenerator;
import net.minecraft.world.level.LevelAccessor;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.core.BlockPos;
import net.minecraft.world.level.LevelWriter;
import net.minecraft.core.Registry;
import com.mojang.datafixers.Dynamic;
import java.util.function.Function;
import java.util.List;
import com.google.common.collect.BiMap;
import net.minecraft.world.level.levelgen.feature.configurations.DecoratedFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.RandomBooleanFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.SimpleRandomFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.RandomFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.RandomRandomFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.LayerConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.ProbabilityFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.SimpleBlockConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.CountFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.SeagrassFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.EndGatewayConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.SpikeConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.OreConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.FeatureRadiusConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.DiskConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.BlockBlobConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.BlockStateConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.HugeMushroomFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.ReplaceBlockConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.SpringConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.BlockPileConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.RandomPatchConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.MegaTreeConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.TreeConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.SmallTreeConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.VillageConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.BuriedTreasureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.OceanRuinConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.ShipwreckConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.MineshaftConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.NoneFeatureConfiguration;
import net.minecraft.world.level.levelgen.feature.configurations.FeatureConfiguration;

public abstract class Feature<FC extends FeatureConfiguration> {
    public static final StructureFeature<NoneFeatureConfiguration> PILLAGER_OUTPOST;
    public static final StructureFeature<MineshaftConfiguration> MINESHAFT;
    public static final StructureFeature<NoneFeatureConfiguration> WOODLAND_MANSION;
    public static final StructureFeature<NoneFeatureConfiguration> JUNGLE_TEMPLE;
    public static final StructureFeature<NoneFeatureConfiguration> DESERT_PYRAMID;
    public static final StructureFeature<NoneFeatureConfiguration> IGLOO;
    public static final StructureFeature<ShipwreckConfiguration> SHIPWRECK;
    public static final SwamplandHutFeature SWAMP_HUT;
    public static final StructureFeature<NoneFeatureConfiguration> STRONGHOLD;
    public static final StructureFeature<NoneFeatureConfiguration> OCEAN_MONUMENT;
    public static final StructureFeature<OceanRuinConfiguration> OCEAN_RUIN;
    public static final StructureFeature<NoneFeatureConfiguration> NETHER_BRIDGE;
    public static final StructureFeature<NoneFeatureConfiguration> END_CITY;
    public static final StructureFeature<BuriedTreasureConfiguration> BURIED_TREASURE;
    public static final StructureFeature<VillageConfiguration> VILLAGE;
    public static final Feature<NoneFeatureConfiguration> NO_OP;
    public static final Feature<SmallTreeConfiguration> NORMAL_TREE;
    public static final Feature<SmallTreeConfiguration> ACACIA_TREE;
    public static final Feature<SmallTreeConfiguration> FANCY_TREE;
    public static final Feature<TreeConfiguration> JUNGLE_GROUND_BUSH;
    public static final Feature<MegaTreeConfiguration> DARK_OAK_TREE;
    public static final Feature<MegaTreeConfiguration> MEGA_JUNGLE_TREE;
    public static final Feature<MegaTreeConfiguration> MEGA_SPRUCE_TREE;
    public static final AbstractFlowerFeature<RandomPatchConfiguration> FLOWER;
    public static final Feature<RandomPatchConfiguration> RANDOM_PATCH;
    public static final Feature<BlockPileConfiguration> BLOCK_PILE;
    public static final Feature<SpringConfiguration> SPRING;
    public static final Feature<NoneFeatureConfiguration> CHORUS_PLANT;
    public static final Feature<ReplaceBlockConfiguration> EMERALD_ORE;
    public static final Feature<NoneFeatureConfiguration> VOID_START_PLATFORM;
    public static final Feature<NoneFeatureConfiguration> DESERT_WELL;
    public static final Feature<NoneFeatureConfiguration> FOSSIL;
    public static final Feature<HugeMushroomFeatureConfiguration> HUGE_RED_MUSHROOM;
    public static final Feature<HugeMushroomFeatureConfiguration> HUGE_BROWN_MUSHROOM;
    public static final Feature<NoneFeatureConfiguration> ICE_SPIKE;
    public static final Feature<NoneFeatureConfiguration> GLOWSTONE_BLOB;
    public static final Feature<NoneFeatureConfiguration> FREEZE_TOP_LAYER;
    public static final Feature<NoneFeatureConfiguration> VINES;
    public static final Feature<NoneFeatureConfiguration> MONSTER_ROOM;
    public static final Feature<NoneFeatureConfiguration> BLUE_ICE;
    public static final Feature<BlockStateConfiguration> ICEBERG;
    public static final Feature<BlockBlobConfiguration> FOREST_ROCK;
    public static final Feature<DiskConfiguration> DISK;
    public static final Feature<FeatureRadiusConfiguration> ICE_PATCH;
    public static final Feature<BlockStateConfiguration> LAKE;
    public static final Feature<OreConfiguration> ORE;
    public static final Feature<SpikeConfiguration> END_SPIKE;
    public static final Feature<NoneFeatureConfiguration> END_ISLAND;
    public static final Feature<EndGatewayConfiguration> END_GATEWAY;
    public static final Feature<SeagrassFeatureConfiguration> SEAGRASS;
    public static final Feature<NoneFeatureConfiguration> KELP;
    public static final Feature<NoneFeatureConfiguration> CORAL_TREE;
    public static final Feature<NoneFeatureConfiguration> CORAL_MUSHROOM;
    public static final Feature<NoneFeatureConfiguration> CORAL_CLAW;
    public static final Feature<CountFeatureConfiguration> SEA_PICKLE;
    public static final Feature<SimpleBlockConfiguration> SIMPLE_BLOCK;
    public static final Feature<ProbabilityFeatureConfiguration> BAMBOO;
    public static final Feature<LayerConfiguration> FILL_LAYER;
    public static final BonusChestFeature BONUS_CHEST;
    public static final Feature<RandomRandomFeatureConfiguration> RANDOM_RANDOM_SELECTOR;
    public static final Feature<RandomFeatureConfiguration> RANDOM_SELECTOR;
    public static final Feature<SimpleRandomFeatureConfiguration> SIMPLE_RANDOM_SELECTOR;
    public static final Feature<RandomBooleanFeatureConfiguration> RANDOM_BOOLEAN_SELECTOR;
    public static final Feature<DecoratedFeatureConfiguration> DECORATED;
    public static final Feature<DecoratedFeatureConfiguration> DECORATED_FLOWER;
    public static final BiMap<String, StructureFeature<?>> STRUCTURES_REGISTRY;
    public static final List<StructureFeature<?>> NOISE_AFFECTING_FEATURES;
    private final Function<Dynamic<?>, ? extends FC> configurationFactory;
    
    private static <C extends FeatureConfiguration, F extends Feature<C>> F register(final String string, final F cdu) {
        return Registry.<F>register(Registry.FEATURE, string, cdu);
    }
    
    public Feature(final Function<Dynamic<?>, ? extends FC> function) {
        this.configurationFactory = function;
    }
    
    public ConfiguredFeature<FC, ?> configured(final FC cgn) {
        return new ConfiguredFeature<FC, Object>(this, cgn);
    }
    
    public FC createSettings(final Dynamic<?> dynamic) {
        return (FC)this.configurationFactory.apply(dynamic);
    }
    
    protected void setBlock(final LevelWriter bke, final BlockPos fk, final BlockState byj) {
        bke.setBlock(fk, byj, 3);
    }
    
    public abstract boolean place(final LevelAccessor bjx, final ChunkGenerator<? extends ChunkGeneratorSettings> caa, final Random random, final BlockPos fk, final FC cgn);
    
    public List<Biome.SpawnerData> getSpecialEnemies() {
        return Collections.<Biome.SpawnerData>emptyList();
    }
    
    public List<Biome.SpawnerData> getSpecialAnimals() {
        return Collections.<Biome.SpawnerData>emptyList();
    }
    
    protected static boolean isStone(final Block bph) {
        return bph == Blocks.STONE || bph == Blocks.GRANITE || bph == Blocks.DIORITE || bph == Blocks.ANDESITE;
    }
    
    protected static boolean isDirt(final Block bph) {
        return bph == Blocks.DIRT || bph == Blocks.GRASS_BLOCK || bph == Blocks.PODZOL || bph == Blocks.COARSE_DIRT || bph == Blocks.MYCELIUM;
    }
    
    static {
        PILLAGER_OUTPOST = Feature.<FeatureConfiguration, PillagerOutpostFeature>register("pillager_outpost", new PillagerOutpostFeature(NoneFeatureConfiguration::deserialize));
        MINESHAFT = Feature.<FeatureConfiguration, MineshaftFeature>register("mineshaft", new MineshaftFeature(MineshaftConfiguration::deserialize));
        WOODLAND_MANSION = Feature.<FeatureConfiguration, WoodlandMansionFeature>register("woodland_mansion", new WoodlandMansionFeature(NoneFeatureConfiguration::deserialize));
        JUNGLE_TEMPLE = Feature.<FeatureConfiguration, JunglePyramidFeature>register("jungle_temple", new JunglePyramidFeature(NoneFeatureConfiguration::deserialize));
        DESERT_PYRAMID = Feature.<FeatureConfiguration, DesertPyramidFeature>register("desert_pyramid", new DesertPyramidFeature(NoneFeatureConfiguration::deserialize));
        IGLOO = Feature.<FeatureConfiguration, IglooFeature>register("igloo", new IglooFeature(NoneFeatureConfiguration::deserialize));
        SHIPWRECK = Feature.<FeatureConfiguration, ShipwreckFeature>register("shipwreck", new ShipwreckFeature(ShipwreckConfiguration::deserialize));
        SWAMP_HUT = Feature.<FeatureConfiguration, SwamplandHutFeature>register("swamp_hut", new SwamplandHutFeature(NoneFeatureConfiguration::deserialize));
        STRONGHOLD = Feature.<FeatureConfiguration, StrongholdFeature>register("stronghold", new StrongholdFeature(NoneFeatureConfiguration::deserialize));
        OCEAN_MONUMENT = Feature.<FeatureConfiguration, OceanMonumentFeature>register("ocean_monument", new OceanMonumentFeature(NoneFeatureConfiguration::deserialize));
        OCEAN_RUIN = Feature.<FeatureConfiguration, OceanRuinFeature>register("ocean_ruin", new OceanRuinFeature(OceanRuinConfiguration::deserialize));
        NETHER_BRIDGE = Feature.<FeatureConfiguration, NetherFortressFeature>register("nether_bridge", new NetherFortressFeature(NoneFeatureConfiguration::deserialize));
        END_CITY = Feature.<FeatureConfiguration, EndCityFeature>register("end_city", new EndCityFeature(NoneFeatureConfiguration::deserialize));
        BURIED_TREASURE = Feature.<FeatureConfiguration, BuriedTreasureFeature>register("buried_treasure", new BuriedTreasureFeature(BuriedTreasureConfiguration::deserialize));
        VILLAGE = Feature.<FeatureConfiguration, VillageFeature>register("village", new VillageFeature(VillageConfiguration::deserialize));
        NO_OP = Feature.<FeatureConfiguration, NoOpFeature>register("no_op", new NoOpFeature(NoneFeatureConfiguration::deserialize));
        NORMAL_TREE = Feature.<FeatureConfiguration, TreeFeature>register("normal_tree", new TreeFeature(SmallTreeConfiguration::deserialize));
        ACACIA_TREE = Feature.<FeatureConfiguration, AcaciaFeature>register("acacia_tree", new AcaciaFeature(SmallTreeConfiguration::deserialize));
        FANCY_TREE = Feature.<FeatureConfiguration, FancyTreeFeature>register("fancy_tree", new FancyTreeFeature(SmallTreeConfiguration::deserialize));
        JUNGLE_GROUND_BUSH = Feature.<FeatureConfiguration, GroundBushFeature>register("jungle_ground_bush", new GroundBushFeature(TreeConfiguration::deserialize));
        DARK_OAK_TREE = Feature.<FeatureConfiguration, DarkOakFeature>register("dark_oak_tree", new DarkOakFeature(MegaTreeConfiguration::deserialize));
        MEGA_JUNGLE_TREE = Feature.<FeatureConfiguration, MegaJungleTreeFeature>register("mega_jungle_tree", new MegaJungleTreeFeature(MegaTreeConfiguration::deserialize));
        MEGA_SPRUCE_TREE = Feature.<FeatureConfiguration, MegaPineTreeFeature>register("mega_spruce_tree", new MegaPineTreeFeature(MegaTreeConfiguration::deserialize));
        FLOWER = Feature.<FeatureConfiguration, DefaultFlowerFeature>register("flower", new DefaultFlowerFeature(RandomPatchConfiguration::deserialize));
        RANDOM_PATCH = Feature.<FeatureConfiguration, RandomPatchFeature>register("random_patch", new RandomPatchFeature(RandomPatchConfiguration::deserialize));
        BLOCK_PILE = Feature.<FeatureConfiguration, BlockPileFeature>register("block_pile", new BlockPileFeature(BlockPileConfiguration::deserialize));
        SPRING = Feature.<FeatureConfiguration, SpringFeature>register("spring_feature", new SpringFeature(SpringConfiguration::deserialize));
        CHORUS_PLANT = Feature.<FeatureConfiguration, ChorusPlantFeature>register("chorus_plant", new ChorusPlantFeature(NoneFeatureConfiguration::deserialize));
        EMERALD_ORE = Feature.<FeatureConfiguration, ReplaceBlockFeature>register("emerald_ore", new ReplaceBlockFeature(ReplaceBlockConfiguration::deserialize));
        VOID_START_PLATFORM = Feature.<FeatureConfiguration, VoidStartPlatformFeature>register("void_start_platform", new VoidStartPlatformFeature(NoneFeatureConfiguration::deserialize));
        DESERT_WELL = Feature.<FeatureConfiguration, DesertWellFeature>register("desert_well", new DesertWellFeature(NoneFeatureConfiguration::deserialize));
        FOSSIL = Feature.<FeatureConfiguration, FossilFeature>register("fossil", new FossilFeature(NoneFeatureConfiguration::deserialize));
        HUGE_RED_MUSHROOM = Feature.<FeatureConfiguration, HugeRedMushroomFeature>register("huge_red_mushroom", new HugeRedMushroomFeature(HugeMushroomFeatureConfiguration::deserialize));
        HUGE_BROWN_MUSHROOM = Feature.<FeatureConfiguration, HugeBrownMushroomFeature>register("huge_brown_mushroom", new HugeBrownMushroomFeature(HugeMushroomFeatureConfiguration::deserialize));
        ICE_SPIKE = Feature.<FeatureConfiguration, IceSpikeFeature>register("ice_spike", new IceSpikeFeature(NoneFeatureConfiguration::deserialize));
        GLOWSTONE_BLOB = Feature.<FeatureConfiguration, GlowstoneFeature>register("glowstone_blob", new GlowstoneFeature(NoneFeatureConfiguration::deserialize));
        FREEZE_TOP_LAYER = Feature.<FeatureConfiguration, SnowAndFreezeFeature>register("freeze_top_layer", new SnowAndFreezeFeature(NoneFeatureConfiguration::deserialize));
        VINES = Feature.<FeatureConfiguration, VinesFeature>register("vines", new VinesFeature(NoneFeatureConfiguration::deserialize));
        MONSTER_ROOM = Feature.<FeatureConfiguration, MonsterRoomFeature>register("monster_room", new MonsterRoomFeature(NoneFeatureConfiguration::deserialize));
        BLUE_ICE = Feature.<FeatureConfiguration, BlueIceFeature>register("blue_ice", new BlueIceFeature(NoneFeatureConfiguration::deserialize));
        ICEBERG = Feature.<FeatureConfiguration, IcebergFeature>register("iceberg", new IcebergFeature(BlockStateConfiguration::deserialize));
        FOREST_ROCK = Feature.<FeatureConfiguration, BlockBlobFeature>register("forest_rock", new BlockBlobFeature(BlockBlobConfiguration::deserialize));
        DISK = Feature.<FeatureConfiguration, DiskReplaceFeature>register("disk", new DiskReplaceFeature(DiskConfiguration::deserialize));
        ICE_PATCH = Feature.<FeatureConfiguration, IcePatchFeature>register("ice_patch", new IcePatchFeature(FeatureRadiusConfiguration::deserialize));
        LAKE = Feature.<FeatureConfiguration, LakeFeature>register("lake", new LakeFeature(BlockStateConfiguration::deserialize));
        ORE = Feature.<FeatureConfiguration, OreFeature>register("ore", new OreFeature(OreConfiguration::deserialize));
        END_SPIKE = Feature.<FeatureConfiguration, SpikeFeature>register("end_spike", new SpikeFeature(SpikeConfiguration::deserialize));
        END_ISLAND = Feature.<FeatureConfiguration, EndIslandFeature>register("end_island", new EndIslandFeature(NoneFeatureConfiguration::deserialize));
        END_GATEWAY = Feature.<FeatureConfiguration, EndGatewayFeature>register("end_gateway", new EndGatewayFeature(EndGatewayConfiguration::deserialize));
        SEAGRASS = Feature.<FeatureConfiguration, SeagrassFeature>register("seagrass", new SeagrassFeature(SeagrassFeatureConfiguration::deserialize));
        KELP = Feature.<FeatureConfiguration, KelpFeature>register("kelp", new KelpFeature(NoneFeatureConfiguration::deserialize));
        CORAL_TREE = Feature.<FeatureConfiguration, CoralTreeFeature>register("coral_tree", new CoralTreeFeature(NoneFeatureConfiguration::deserialize));
        CORAL_MUSHROOM = Feature.<FeatureConfiguration, CoralMushroomFeature>register("coral_mushroom", new CoralMushroomFeature(NoneFeatureConfiguration::deserialize));
        CORAL_CLAW = Feature.<FeatureConfiguration, CoralClawFeature>register("coral_claw", new CoralClawFeature(NoneFeatureConfiguration::deserialize));
        SEA_PICKLE = Feature.<FeatureConfiguration, SeaPickleFeature>register("sea_pickle", new SeaPickleFeature(CountFeatureConfiguration::deserialize));
        SIMPLE_BLOCK = Feature.<FeatureConfiguration, SimpleBlockFeature>register("simple_block", new SimpleBlockFeature(SimpleBlockConfiguration::deserialize));
        BAMBOO = Feature.<FeatureConfiguration, BambooFeature>register("bamboo", new BambooFeature(ProbabilityFeatureConfiguration::deserialize));
        FILL_LAYER = Feature.<FeatureConfiguration, FillLayerFeature>register("fill_layer", new FillLayerFeature(LayerConfiguration::deserialize));
        BONUS_CHEST = Feature.<FeatureConfiguration, BonusChestFeature>register("bonus_chest", new BonusChestFeature(NoneFeatureConfiguration::deserialize));
        RANDOM_RANDOM_SELECTOR = Feature.<FeatureConfiguration, RandomRandomFeature>register("random_random_selector", new RandomRandomFeature(RandomRandomFeatureConfiguration::deserialize));
        RANDOM_SELECTOR = Feature.<FeatureConfiguration, RandomSelectorFeature>register("random_selector", new RandomSelectorFeature(RandomFeatureConfiguration::deserialize));
        SIMPLE_RANDOM_SELECTOR = Feature.<FeatureConfiguration, SimpleRandomSelectorFeature>register("simple_random_selector", new SimpleRandomSelectorFeature(SimpleRandomFeatureConfiguration::deserialize));
        RANDOM_BOOLEAN_SELECTOR = Feature.<FeatureConfiguration, RandomBooleanSelectorFeature>register("random_boolean_selector", new RandomBooleanSelectorFeature(RandomBooleanFeatureConfiguration::deserialize));
        DECORATED = Feature.<FeatureConfiguration, DecoratedFeature>register("decorated", new DecoratedFeature(DecoratedFeatureConfiguration::deserialize));
        DECORATED_FLOWER = Feature.<FeatureConfiguration, DecoratedFlowerFeature>register("decorated_flower", new DecoratedFlowerFeature(DecoratedFeatureConfiguration::deserialize));
        STRUCTURES_REGISTRY = Util.<BiMap<String, StructureFeature<?>>>make(HashBiMap.create(), hashBiMap -> {
            hashBiMap.put("Pillager_Outpost".toLowerCase(Locale.ROOT), Feature.PILLAGER_OUTPOST);
            hashBiMap.put("Mineshaft".toLowerCase(Locale.ROOT), (StructureFeature<NoneFeatureConfiguration>)Feature.MINESHAFT);
            hashBiMap.put("Mansion".toLowerCase(Locale.ROOT), Feature.WOODLAND_MANSION);
            hashBiMap.put("Jungle_Pyramid".toLowerCase(Locale.ROOT), Feature.JUNGLE_TEMPLE);
            hashBiMap.put("Desert_Pyramid".toLowerCase(Locale.ROOT), Feature.DESERT_PYRAMID);
            hashBiMap.put("Igloo".toLowerCase(Locale.ROOT), Feature.IGLOO);
            hashBiMap.put("Shipwreck".toLowerCase(Locale.ROOT), (StructureFeature<NoneFeatureConfiguration>)Feature.SHIPWRECK);
            hashBiMap.put("Swamp_Hut".toLowerCase(Locale.ROOT), Feature.SWAMP_HUT);
            hashBiMap.put("Stronghold".toLowerCase(Locale.ROOT), Feature.STRONGHOLD);
            hashBiMap.put("Monument".toLowerCase(Locale.ROOT), Feature.OCEAN_MONUMENT);
            hashBiMap.put("Ocean_Ruin".toLowerCase(Locale.ROOT), (StructureFeature<NoneFeatureConfiguration>)Feature.OCEAN_RUIN);
            hashBiMap.put("Fortress".toLowerCase(Locale.ROOT), Feature.NETHER_BRIDGE);
            hashBiMap.put("EndCity".toLowerCase(Locale.ROOT), Feature.END_CITY);
            hashBiMap.put("Buried_Treasure".toLowerCase(Locale.ROOT), (StructureFeature<NoneFeatureConfiguration>)Feature.BURIED_TREASURE);
            hashBiMap.put("Village".toLowerCase(Locale.ROOT), (StructureFeature<NoneFeatureConfiguration>)Feature.VILLAGE);
            return;
        });
        NOISE_AFFECTING_FEATURES = ImmutableList.<StructureFeature<NoneFeatureConfiguration>>of(Feature.PILLAGER_OUTPOST, (StructureFeature<NoneFeatureConfiguration>)Feature.VILLAGE);
    }
}
