Initial Update to 1.19

- Updated to 1.19
- Added mangrove vertical slabs

It has one launch crash that will need to be fixed

.idea/jarRepositories.xml

@@ -29,12 +29,7 @@
     <remote-repository>
       <option name="id" value="UserLocalRemappedMods" />
       <option name="name" value="UserLocalRemappedMods" />
-      <option name="url" value="file:/$USER_HOME$/Minecraft%20Mods%20and%20Plugins/Fabric/VanillaPlus/.gradle/loom-cache/remapped_mods/" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="UserLocalRemappedMods" />
-      <option name="name" value="UserLocalRemappedMods" />
-      <option name="url" value="file:/$PROJECT_DIR$/.gradle/loom-cache/remapped_mods/" />
+      <option name="url" value="file:/$PROJECT_DIR$/../../../Minecraft%20Mods%20and%20Plugins/Fabric/VanillaPlus/.gradle/loom-cache/remapped_mods/" />
     </remote-repository>
   </component>
 </project>

.idea/misc.xml

@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="temurin-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="azul-16" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

build.gradle

@@ -22,10 +22,6 @@ dependencies {
     modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
 }
 
-loom {
-    accessWidenerPath = file("src/main/resources/vplus.accesswidener")
-}
-
 processResources {
     inputs.property "version", project.version
 
@@ -48,4 +44,3 @@ jar {
         rename { "${it}_${project.archivesBaseName}"}
     }
 }
-

gradle.properties

@@ -4,13 +4,13 @@ org.gradle.jvmargs=-Xmx4G
 # Fabric Properties
 # check these on https://fabricmc.net/versions.html
 minecraft_version=1.19
-yarn_mappings=1.19+build.1
-loader_version=0.14.6
+yarn_mappings=1.19+build.4
+loader_version=0.14.8
 
 # Mod Properties
-mod_version = 1.1.2
+mod_version = 1.1.1
 maven_group = tech.nevets
 archives_base_name = vplus
 
 # Dependencies
-fabric_version=0.55.1+1.19
+fabric_version=0.57.0+1.19

src/main/java/tech/nevets/vplus/Main.java

@@ -6,11 +6,13 @@ import tech.nevets.vplus.blocks.VPBlocks;
 import tech.nevets.vplus.food.VPFood;
 import tech.nevets.vplus.items.VPItems;
 import tech.nevets.vplus.misc.VPFuels;
+import tech.nevets.vplus.misc.VPOreGen;
 import tech.nevets.vplus.tools.VPTools;
-import tech.nevets.vplus.worldgen.features.VPOreConfiguredFeatures;
 
 public class Main implements ModInitializer {
 
+    public static String modid = "vplus";
+
     @Override
     public void onInitialize() {
         VPBlocks.vpBlocks();
@@ -18,8 +20,7 @@ public class Main implements ModInitializer {
         VPFood.vpFood();
         VPTools.vpTools();
         VPArmor.vpArmor();
-        new VPOreConfiguredFeatures();
-        //VPOreGen.vpOres();
+        VPOreGen.vpOres();
         VPFuels.vpFuels();
     }
 }

src/main/java/tech/nevets/vplus/VPBlocks.java

@@ -1,48 +0,0 @@
-package tech.nevets.vplus;
-
-import net.minecraft.block.*;
-import net.minecraft.item.BlockItem;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemGroup;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.math.intprovider.IntProvider;
-import net.minecraft.util.registry.Registry;
-import tech.nevets.vplus.items.VPItemGroups;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class VPBlocks extends Blocks {
-    public static final List<Block> BLOCKS = new ArrayList<>();
-    public static final Block SAPPHIRE_ORE;
-    public static final Block RUBY_ORE;
-    public static final Block JADE_ORE;
-
-    public VPBlocks() {
-    }
-
-    static {
-        SAPPHIRE_ORE = register("sapphire_ore", new OreBlock(AbstractBlock.Settings.of(Material.STONE).requiresTool().strength(3.0F, 3.0F)), VPItemGroups.ALL).getBlock();
-        RUBY_ORE = register("ruby_ore", new OreBlock(AbstractBlock.Settings.of(Material.STONE).requiresTool().strength(3.0F, 3.0F)), VPItemGroups.ALL).getBlock();
-        JADE_ORE = register("jade_ore", new OreBlock(AbstractBlock.Settings.of(Material.STONE).requiresTool().strength(3.0F, 3.0F)), VPItemGroups.ALL).getBlock();
-
-        ///////////////////\\\\ITERATOR////\\\\\\\\\\\\\\\\\\\
-
-        for (Block block : BLOCKS) {
-            for (BlockState blockState : block.getStateManager().getStates()) {
-                Block.STATE_IDS.add(blockState);
-            }
-            block.getLootTableId();
-        }
-    }
-
-    /*
-    Use blockItem.getBlock(); to get instance of the block if needed
-     */
-    private static BlockItem register(String id, Block block, ItemGroup group) {
-        BLOCKS.add(block);
-        Registry.register(Registry.BLOCK, new Identifier("vplus", id), block);
-        return Registry.register(Registry.ITEM, new Identifier("vplus", id), new BlockItem(block, new Item.Settings().group(group)));
-    }
-
-}

src/main/java/tech/nevets/vplus/armor/ArmorMaterials.java

@@ -4,7 +4,6 @@ import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.item.ArmorMaterial;
-import net.minecraft.item.ItemConvertible;
 import net.minecraft.item.Items;
 import net.minecraft.recipe.Ingredient;
 import net.minecraft.sound.SoundEvent;
@@ -38,7 +37,7 @@ public enum ArmorMaterials implements ArmorMaterial {
         this.equipSound = equipSound;
         this.toughness = toughness;
         this.knockbackResistance = knockbackResistance;
-        this.repairIngredientSupplier = new Lazy(repairIngredientSupplier);
+        this.repairIngredientSupplier = new Lazy<>(repairIngredientSupplier);
     }
 
     public int getDurability(EquipmentSlot slot) {

src/main/java/tech/nevets/vplus/armor/VPArmor.java

@@ -5,6 +5,8 @@ import net.minecraft.item.ArmorMaterial;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 
+import static tech.nevets.vplus.Main.modid;
+
 public class VPArmor {
 
     public static final ArmorMaterial COPPER_ARMOR = ArmorMaterials.COPPER;
@@ -20,30 +22,30 @@ public class VPArmor {
     }
 
     public static void initializeHelmet() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_helmet"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.HEAD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_helmet"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.HEAD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_helmet"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.HEAD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_helmet"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.HEAD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_helmet"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.HEAD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_helmet"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.HEAD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_helmet"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.HEAD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_helmet"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.HEAD));
     }
 
     public static void initializeChestplates() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_chestplate"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.CHEST));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_chestplate"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.CHEST));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_chestplate"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.CHEST));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_chestplate"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.CHEST));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_chestplate"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.CHEST));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_chestplate"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.CHEST));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_chestplate"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.CHEST));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_chestplate"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.CHEST));
     }
 
     public static void initialzeLeggings() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_leggings"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.LEGS));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_leggings"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.LEGS));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_leggings"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.LEGS));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_leggings"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.LEGS));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_leggings"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.LEGS));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_leggings"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.LEGS));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_leggings"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.LEGS));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_leggings"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.LEGS));
     }
 
     public static void initializeBoots() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_boots"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.FEET));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_boots"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.FEET));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_boots"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.FEET));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_boots"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.FEET));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_boots"), new BaseArmor(COPPER_ARMOR, EquipmentSlot.FEET));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_boots"), new BaseArmor(EMERALD_ARMOR, EquipmentSlot.FEET));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_boots"), new BaseArmor(PLATINUM_ARMOR, EquipmentSlot.FEET));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_boots"), new BaseArmor(RUBY_ARMOR, EquipmentSlot.FEET));
     }
 }

src/main/java/tech/nevets/vplus/blocks/ColorTorchBlock.java

@@ -37,9 +37,9 @@ public class ColorTorchBlock extends Block {
     }
 
     public void randomDisplayTick(BlockState state, World world, BlockPos pos, Random random) {
-        double d = (double) pos.getX() + 0.5D;
-        double e = (double) pos.getY() + 0.7D;
-        double f = (double) pos.getZ() + 0.5D;
+        double d = (double)pos.getX() + 0.5D;
+        double e = (double)pos.getY() + 0.7D;
+        double f = (double)pos.getZ() + 0.5D;
         world.addParticle(ParticleTypes.SMOKE, d, e, f, 0.0D, 0.0D, 0.0D);
         world.addParticle(this.particle, d, e, f, 0.0D, 0.0D, 0.0D);
     }

src/main/java/tech/nevets/vplus/blocks/ColorWallTorchBlock.java

@@ -57,11 +57,8 @@ public class ColorWallTorchBlock extends TorchBlock {
         WorldView worldView = ctx.getWorld();
         BlockPos blockPos = ctx.getBlockPos();
         Direction[] directions = ctx.getPlacementDirections();
-        Direction[] var6 = directions;
-        int var7 = directions.length;
 
-        for(int var8 = 0; var8 < var7; ++var8) {
-            Direction direction = var6[var8];
+        for (Direction direction : directions) {
             if (direction.getAxis().isHorizontal()) {
                 Direction direction2 = direction.getOpposite();
                 blockState = blockState.with(FACING, direction2);

src/main/java/tech/nevets/vplus/blocks/LavaSpongeBlock.java

@@ -41,33 +41,31 @@ public class LavaSpongeBlock extends Block {
 
     private boolean absorbLava(World world, BlockPos pos) {
         Queue<Pair<BlockPos, Integer>> queue = Lists.newLinkedList();
-        queue.add(new Pair(pos, 0));
+        queue.add(new Pair<>(pos, 0));
         int i = 0;
 
         while(!queue.isEmpty()) {
-            Pair pair = queue.poll();
-            BlockPos blockPos = (BlockPos)pair.getLeft();
-            int j = (Integer)pair.getRight();
+            Pair<BlockPos, Integer> pair = queue.poll();
+            BlockPos blockPos = pair.getLeft();
+            int j = pair.getRight();
             Direction[] var8 = Direction.values();
-            int var9 = var8.length;
 
-            for(int var10 = 0; var10 < var9; ++var10) {
-                Direction direction = var8[var10];
+            for (Direction direction : var8) {
                 BlockPos blockPos2 = blockPos.offset(direction);
                 BlockState blockState = world.getBlockState(blockPos2);
                 FluidState fluidState = world.getFluidState(blockPos2);
                 Material material = blockState.getMaterial();
                 if (fluidState.isIn(FluidTags.LAVA)) {
-                    if (blockState.getBlock() instanceof FluidDrainable && !((FluidDrainable)blockState.getBlock()).tryDrainFluid(world, blockPos2, blockState).isEmpty()) {
+                    if (blockState.getBlock() instanceof FluidDrainable && !((FluidDrainable) blockState.getBlock()).tryDrainFluid(world, blockPos2, blockState).isEmpty()) {
                         ++i;
                         if (j < 6) {
-                            queue.add(new Pair(blockPos2, j + 1));
+                            queue.add(new Pair<>(blockPos2, j + 1));
                         }
                     } else if (blockState.getBlock() instanceof FluidBlock) {
                         world.setBlockState(blockPos2, Blocks.AIR.getDefaultState(), 3);
                         ++i;
                         if (j < 6) {
-                            queue.add(new Pair(blockPos2, j + 1));
+                            queue.add(new Pair<>(blockPos2, j + 1));
                         }
                     }
                 }

src/main/java/tech/nevets/vplus/blocks/PlatinumBlock.java

@@ -8,6 +8,6 @@ import net.minecraft.sound.BlockSoundGroup;
 //TODO Change platinum to saphire
 public class PlatinumBlock extends Block {
     public PlatinumBlock() {
-        super(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.METAL).strength(30, 1000f));
+        super(FabricBlockSettings.of(Material.STONE).requiresTool().sounds(BlockSoundGroup.METAL).strength(30, 1000f));
     }
 }

src/main/java/tech/nevets/vplus/blocks/PlatinumOre.java

@@ -11,25 +11,24 @@ import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.BlockSoundGroup;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.random.Random;
+
+import java.util.Random;
 
 public class PlatinumOre extends Block {
     public PlatinumOre() {
-        super(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).strength(3, 1500f));
+        super(FabricBlockSettings.of(Material.STONE).requiresTool().sounds(BlockSoundGroup.STONE).strength(3, 1500f));
     }
     protected int getExperienceWhenMined(Random random) {
-        return MathHelper.nextInt(random, 3, 7);
+        return MathHelper.nextInt((net.minecraft.util.math.random.Random) random, 3, 7);
     }
 
-    /*
     public void onStacksDropped(BlockState state, ServerWorld world, BlockPos pos, ItemStack stack) {
-        super.onStacksDropped(state, world, pos, stack);
-        if (EnchantmentHelper.getLevel(Enchantments.SILK_TOUCH, stack) == 0) {
-            int i = this.getExperienceWhenMined(world.random);
+        super.onStacksDropped(state, world, pos, stack, true);
+        if (EnchantmentHelper.get(stack).containsKey(Enchantments.SILK_TOUCH)) {
+            int i = this.getExperienceWhenMined((Random) world.random);
             if (i > 0) {
                 this.dropExperience(world, pos, i);
             }
         }
     }
-    */
 }

src/main/java/tech/nevets/vplus/blocks/RubyBlock.java

@@ -7,6 +7,6 @@ import net.minecraft.sound.BlockSoundGroup;
 
 public class RubyBlock extends Block {
     public RubyBlock() {
-        super(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.METAL).strength(5, 6.0f));
+        super(FabricBlockSettings.of(Material.STONE).requiresTool().sounds(BlockSoundGroup.METAL).strength(5, 6.0f));
     }
 }

src/main/java/tech/nevets/vplus/blocks/RubyOre.java

@@ -11,25 +11,24 @@ import net.minecraft.server.world.ServerWorld;
 import net.minecraft.sound.BlockSoundGroup;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.random.Random;
+
+import java.util.Random;
 
 public class RubyOre extends Block {
     public RubyOre() {
-        super(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).strength(3, 1500f));
+        super(FabricBlockSettings.of(Material.STONE).requiresTool().sounds(BlockSoundGroup.STONE).strength(3, 1500f));
     }
     protected int getExperienceWhenMined(Random random) {
-        return MathHelper.nextInt(random, 3, 7);
+        return MathHelper.nextInt((net.minecraft.util.math.random.Random) random, 3, 7);
     }
 
-    /*
     public void onStacksDropped(BlockState state, ServerWorld world, BlockPos pos, ItemStack stack) {
-        super.onStacksDropped(state, world, pos, stack);
-        if (EnchantmentHelper.getLevel(Enchantments.SILK_TOUCH, stack) == 0) {
-            int i = this.getExperienceWhenMined(world.random);
+        super.onStacksDropped(state, world, pos, stack, true);
+        if (EnchantmentHelper.get(stack).containsKey(Enchantments.SILK_TOUCH)) {
+            int i = this.getExperienceWhenMined((Random) world.random);
             if (i > 0) {
                 this.dropExperience(world, pos, i);
             }
         }
     }
-    */
 }

src/main/java/tech/nevets/vplus/blocks/SaturatedLavaSpongeBlock.java

@@ -10,9 +10,10 @@ import net.minecraft.particle.ParticleTypes;
 import net.minecraft.sound.BlockSoundGroup;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
-import net.minecraft.util.math.random.Random;
 import net.minecraft.world.World;
 
+import java.util.Random;
+
 public class SaturatedLavaSpongeBlock extends Block {
 
     public SaturatedLavaSpongeBlock() {
@@ -21,14 +22,14 @@ public class SaturatedLavaSpongeBlock extends Block {
 
     @Environment(EnvType.CLIENT)
     public void randomDisplayTick(BlockState state, World world, BlockPos pos, Random random) {
-        Direction direction = Direction.random(random);
+        Direction direction = Direction.random((net.minecraft.util.math.random.Random) random);
         if (direction != Direction.UP) {
             BlockPos blockPos = pos.offset(direction);
             BlockState blockState = world.getBlockState(blockPos);
             if (!state.isOpaque() || !blockState.isSideSolidFullSquare(world, blockPos, direction.getOpposite())) {
-                double d = (double)pos.getX();
-                double e = (double)pos.getY();
-                double f = (double)pos.getZ();
+                double d = pos.getX();
+                double e = pos.getY();
+                double f = pos.getZ();
                 if (direction == Direction.DOWN) {
                     e -= 0.05D;
                     d += random.nextDouble();

src/main/java/tech/nevets/vplus/blocks/VPBlocks.java

@@ -9,6 +9,8 @@ import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 import tech.nevets.vplus.items.VPItemGroups;
 
+import static tech.nevets.vplus.Main.modid;
+
 public class VPBlocks {
 
     public static final Block LAVASPONGEBLOCK = new LavaSpongeBlock();
@@ -26,25 +28,25 @@ public class VPBlocks {
     }
 
     public static void initializeBlocks() {
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "lava_sponge"), LAVASPONGEBLOCK);
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "saturated_lava_sponge"), SATURATEDLAVASPONGEBLOCK);
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "platinum_ore"), PLATINUMORE);
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "platinum_block"), PLATINUMBLOCK);
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "ruby_block"), RUBYBLOCK);
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "ruby_ore"), RUBYORE);
+        Registry.register(Registry.BLOCK, new Identifier(modid, "lava_sponge"), LAVASPONGEBLOCK);
+        Registry.register(Registry.BLOCK, new Identifier(modid, "saturated_lava_sponge"), SATURATEDLAVASPONGEBLOCK);
+        Registry.register(Registry.BLOCK, new Identifier(modid, "platinum_ore"), PLATINUMORE);
+        Registry.register(Registry.BLOCK, new Identifier(modid, "platinum_block"), PLATINUMBLOCK);
+        Registry.register(Registry.BLOCK, new Identifier(modid, "ruby_block"), RUBYBLOCK);
+        Registry.register(Registry.BLOCK, new Identifier(modid, "ruby_ore"), RUBYORE);
     }
 
     public static void initializeBlockItems() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "lava_sponge"), new BlockItem(LAVASPONGEBLOCK, new Item.Settings().group(VPItemGroups.ALL)));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "saturated_lava_sponge"), new BlockItem(SATURATEDLAVASPONGEBLOCK, new Item.Settings().group(VPItemGroups.ALL).recipeRemainder(Item.fromBlock(VPBlocks.LAVASPONGEBLOCK))));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_ore"), new BlockItem(PLATINUMORE, new Item.Settings().group(VPItemGroups.ALL)));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_block"), new BlockItem(PLATINUMBLOCK, new Item.Settings().group(VPItemGroups.ALL)));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_block"), new BlockItem(RUBYBLOCK, new Item.Settings().group(VPItemGroups.ALL)));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_ore"), new BlockItem(RUBYORE, new Item.Settings().group(VPItemGroups.ALL)));
+        Registry.register(Registry.ITEM, new Identifier(modid, "lava_sponge"), new BlockItem(LAVASPONGEBLOCK, new Item.Settings().group(VPItemGroups.ALL)));
+        Registry.register(Registry.ITEM, new Identifier(modid, "saturated_lava_sponge"), new BlockItem(SATURATEDLAVASPONGEBLOCK, new Item.Settings().group(VPItemGroups.ALL).recipeRemainder(Item.fromBlock(VPBlocks.LAVASPONGEBLOCK))));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_ore"), new BlockItem(PLATINUMORE, new Item.Settings().group(VPItemGroups.ALL)));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_block"), new BlockItem(PLATINUMBLOCK, new Item.Settings().group(VPItemGroups.ALL)));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_block"), new BlockItem(RUBYBLOCK, new Item.Settings().group(VPItemGroups.ALL)));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_ore"), new BlockItem(RUBYORE, new Item.Settings().group(VPItemGroups.ALL)));
     }
 
     public static void initializeTorches() {
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "green_torch"), new ColorTorchBlock(AbstractBlock.Settings.of(Material.DECORATION).noCollision().breakInstantly().luminance((state) -> 14).sounds(BlockSoundGroup.WOOD), ParticleTypes.FLAME));
-        Registry.register(Registry.BLOCK, new Identifier("vplus", "green_wall_torch"), new ColorWallTorchBlock(AbstractBlock.Settings.of(Material.DECORATION).noCollision().breakInstantly().luminance((state) -> 14).sounds(BlockSoundGroup.WOOD).dropsLike(Blocks.TORCH), ParticleTypes.FLAME));
+        Registry.register(Registry.BLOCK, new Identifier(modid, "green_torch"), new ColorTorchBlock(AbstractBlock.Settings.of(Material.DECORATION).noCollision().breakInstantly().luminance((state) -> 14).sounds(BlockSoundGroup.WOOD), ParticleTypes.FLAME));
+        Registry.register(Registry.BLOCK, new Identifier(modid, "green_wall_torch"), new ColorWallTorchBlock(AbstractBlock.Settings.of(Material.DECORATION).noCollision().breakInstantly().luminance((state) -> 14).sounds(BlockSoundGroup.WOOD).dropsLike(Blocks.TORCH), ParticleTypes.FLAME));
     }
 }

src/main/java/tech/nevets/vplus/blocks/VPVerticalSlabs.java

@@ -10,11 +10,11 @@ import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 import tech.nevets.vplus.items.VPItemGroups;
 
+import static tech.nevets.vplus.Main.modid;
+
 public class VPVerticalSlabs {
 
     //TODO add new 1.17 blocks
-    //TODO add new 1.18 blocks
-    //TODO add new 1.19 blocks
 
     public static final Block VERTICAL_OAK_SLAB;
     public static final Block VERTICAL_SPRUCE_SLAB;
@@ -24,6 +24,7 @@ public class VPVerticalSlabs {
     public static final Block VERTICAL_DARK_OAK_SLAB;
     public static final Block VERTICAL_CRIMSON_SLAB;
     public static final Block VERTICAL_WARPED_SLAB;
+    public static final Block VERTICAL_MANGROVE_SLAB;
     public static final Block VERTICAL_STONE_SLAB;
     public static final Block VERTICAL_SMOOTH_STONE_SLAB;
     public static final Block VERTICAL_SANDSTONE_SLAB;
@@ -57,84 +58,86 @@ public class VPVerticalSlabs {
     public static final Block VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB;
 
     public static void vpVerticalSlabs() {
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_oak_slab"), VERTICAL_OAK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_oak_slab"), new BlockItem(VERTICAL_OAK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_spruce_slab"), VERTICAL_SPRUCE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_spruce_slab"), new BlockItem(VERTICAL_SPRUCE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_birch_slab"), VERTICAL_BIRCH_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_birch_slab"), new BlockItem(VERTICAL_BIRCH_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_jungle_slab"), VERTICAL_JUNGLE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_jungle_slab"), new BlockItem(VERTICAL_JUNGLE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_acacia_slab"), VERTICAL_ACACIA_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_acacia_slab"), new BlockItem(VERTICAL_ACACIA_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_dark_oak_slab"), VERTICAL_DARK_OAK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_dark_oak_slab"), new BlockItem(VERTICAL_DARK_OAK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_crimson_slab"), VERTICAL_CRIMSON_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_crimson_slab"), new BlockItem(VERTICAL_CRIMSON_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_warped_slab"), VERTICAL_WARPED_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_warped_slab"), new BlockItem(VERTICAL_WARPED_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_stone_slab"), VERTICAL_STONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_stone_slab"), new BlockItem(VERTICAL_STONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_smooth_stone_slab"), VERTICAL_SMOOTH_STONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_smooth_stone_slab"), new BlockItem(VERTICAL_SMOOTH_STONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_sandstone_slab"), VERTICAL_SANDSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_sandstone_slab"), new BlockItem(VERTICAL_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_cut_sandstone_slab"), VERTICAL_CUT_SANDSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_cut_sandstone_slab"), new BlockItem(VERTICAL_CUT_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_cobblestone_slab"), VERTICAL_COBBLESTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_cobblestone_slab"), new BlockItem(VERTICAL_COBBLESTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_brick_slab"), VERTICAL_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_brick_slab"), new BlockItem(VERTICAL_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_stone_brick_slab"), VERTICAL_STONE_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_stone_brick_slab"), new BlockItem(VERTICAL_STONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_nether_brick_slab"), VERTICAL_NETHER_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_nether_brick_slab"), new BlockItem(VERTICAL_NETHER_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_quartz_slab"), VERTICAL_QUARTZ_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_quartz_slab"), new BlockItem(VERTICAL_QUARTZ_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_red_sandstone_slab"), VERTICAL_RED_SANDSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_red_sandstone_slab"), new BlockItem(VERTICAL_RED_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_cut_red_sandstone_slab"), VERTICAL_CUT_RED_SANDSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_cut_red_sandstone_slab"), new BlockItem(VERTICAL_CUT_RED_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_purpur_slab"), VERTICAL_PURPUR_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_purpur_slab"), new BlockItem(VERTICAL_PURPUR_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_prismarine_slab"), VERTICAL_PRISMARINE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_prismarine_slab"), new BlockItem(VERTICAL_PRISMARINE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_prismarine_brick_slab"), VERTICAL_PRISMARINE_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_prismarine_brick_slab"), new BlockItem(VERTICAL_PRISMARINE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_dark_prismarine_slab"), VERTICAL_DARK_PRISMARINE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_dark_prismarine_slab"), new BlockItem(VERTICAL_DARK_PRISMARINE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_polished_granite_slab"), VERTICAL_POLISHED_GRANITE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_polished_granite_slab"), new BlockItem(VERTICAL_POLISHED_GRANITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_smooth_red_sandstone_slab"), VERTICAL_SMOOTH_RED_SANDSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_smooth_red_sandstone_slab"), new BlockItem(VERTICAL_SMOOTH_RED_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_mossy_stone_brick_slab"), VERTICAL_MOSSY_STONE_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_mossy_stone_brick_slab"), new BlockItem(VERTICAL_MOSSY_STONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_polished_diorite_slab"), VERTICAL_POLISHED_DIORITE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_polished_diorite_slab"), new BlockItem(VERTICAL_POLISHED_DIORITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_mossy_cobblestone_slab"), VERTICAL_MOSSY_COBBLESTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_mossy_cobblestone_slab"), new BlockItem(VERTICAL_MOSSY_COBBLESTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_end_stone_brick_slab"), VERTICAL_END_STONE_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_end_stone_brick_slab"), new BlockItem(VERTICAL_END_STONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_smooth_sandstone_slab"), VERTICAL_SMOOTH_SANDSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_smooth_sandstone_slab"), new BlockItem(VERTICAL_SMOOTH_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_smooth_quartz_slab"), VERTICAL_SMOOTH_QUARTZ_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_smooth_quartz_slab"), new BlockItem(VERTICAL_SMOOTH_QUARTZ_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_granite_slab"), VERTICAL_GRANITE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_granite_slab"), new BlockItem(VERTICAL_GRANITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_andesite_slab"), VERTICAL_ANDESITE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_andesite_slab"), new BlockItem(VERTICAL_ANDESITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_red_nether_brick_slab"), VERTICAL_RED_NETHER_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_red_nether_brick_slab"), new BlockItem(VERTICAL_RED_NETHER_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_polished_andesite_slab"), VERTICAL_POLISHED_ANDESITE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_polished_andesite_slab"), new BlockItem(VERTICAL_POLISHED_ANDESITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_diorite_slab"), VERTICAL_DIORITE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_diorite_slab"), new BlockItem(VERTICAL_DIORITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_blackstone_slab"), VERTICAL_BLACKSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_blackstone_slab"), new BlockItem(VERTICAL_BLACKSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_polished_blackstone_slab"), VERTICAL_POLISHED_BLACKSTONE_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_polished_blackstone_slab"), new BlockItem(VERTICAL_POLISHED_BLACKSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
-        Registry.register(Registry.BLOCK, new Identifier("vplus","vertical_polished_blackstone_brick_slab"), VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB);
-        Registry.register(Registry.ITEM, new Identifier("vplus","vertical_polished_blackstone_brick_slab"), new BlockItem(VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_oak_slab"), VERTICAL_OAK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_oak_slab"), new BlockItem(VERTICAL_OAK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_spruce_slab"), VERTICAL_SPRUCE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_spruce_slab"), new BlockItem(VERTICAL_SPRUCE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_birch_slab"), VERTICAL_BIRCH_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_birch_slab"), new BlockItem(VERTICAL_BIRCH_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_jungle_slab"), VERTICAL_JUNGLE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_jungle_slab"), new BlockItem(VERTICAL_JUNGLE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_acacia_slab"), VERTICAL_ACACIA_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_acacia_slab"), new BlockItem(VERTICAL_ACACIA_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_dark_oak_slab"), VERTICAL_DARK_OAK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_dark_oak_slab"), new BlockItem(VERTICAL_DARK_OAK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_crimson_slab"), VERTICAL_CRIMSON_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_crimson_slab"), new BlockItem(VERTICAL_CRIMSON_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_warped_slab"), VERTICAL_WARPED_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_warped_slab"), new BlockItem(VERTICAL_WARPED_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_mangrove_slab"), VERTICAL_MANGROVE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_mangrove_slab"), new BlockItem(VERTICAL_MANGROVE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_stone_slab"), VERTICAL_STONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_stone_slab"), new BlockItem(VERTICAL_STONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_smooth_stone_slab"), VERTICAL_SMOOTH_STONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_smooth_stone_slab"), new BlockItem(VERTICAL_SMOOTH_STONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_sandstone_slab"), VERTICAL_SANDSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_sandstone_slab"), new BlockItem(VERTICAL_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_cut_sandstone_slab"), VERTICAL_CUT_SANDSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_cut_sandstone_slab"), new BlockItem(VERTICAL_CUT_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_cobblestone_slab"), VERTICAL_COBBLESTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_cobblestone_slab"), new BlockItem(VERTICAL_COBBLESTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_brick_slab"), VERTICAL_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_brick_slab"), new BlockItem(VERTICAL_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_stone_brick_slab"), VERTICAL_STONE_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_stone_brick_slab"), new BlockItem(VERTICAL_STONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_nether_brick_slab"), VERTICAL_NETHER_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_nether_brick_slab"), new BlockItem(VERTICAL_NETHER_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_quartz_slab"), VERTICAL_QUARTZ_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_quartz_slab"), new BlockItem(VERTICAL_QUARTZ_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_red_sandstone_slab"), VERTICAL_RED_SANDSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_red_sandstone_slab"), new BlockItem(VERTICAL_RED_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_cut_red_sandstone_slab"), VERTICAL_CUT_RED_SANDSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_cut_red_sandstone_slab"), new BlockItem(VERTICAL_CUT_RED_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_purpur_slab"), VERTICAL_PURPUR_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_purpur_slab"), new BlockItem(VERTICAL_PURPUR_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_prismarine_slab"), VERTICAL_PRISMARINE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_prismarine_slab"), new BlockItem(VERTICAL_PRISMARINE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_prismarine_brick_slab"), VERTICAL_PRISMARINE_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_prismarine_brick_slab"), new BlockItem(VERTICAL_PRISMARINE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_dark_prismarine_slab"), VERTICAL_DARK_PRISMARINE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_dark_prismarine_slab"), new BlockItem(VERTICAL_DARK_PRISMARINE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_polished_granite_slab"), VERTICAL_POLISHED_GRANITE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_polished_granite_slab"), new BlockItem(VERTICAL_POLISHED_GRANITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_smooth_red_sandstone_slab"), VERTICAL_SMOOTH_RED_SANDSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_smooth_red_sandstone_slab"), new BlockItem(VERTICAL_SMOOTH_RED_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_mossy_stone_brick_slab"), VERTICAL_MOSSY_STONE_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_mossy_stone_brick_slab"), new BlockItem(VERTICAL_MOSSY_STONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_polished_diorite_slab"), VERTICAL_POLISHED_DIORITE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_polished_diorite_slab"), new BlockItem(VERTICAL_POLISHED_DIORITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_mossy_cobblestone_slab"), VERTICAL_MOSSY_COBBLESTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_mossy_cobblestone_slab"), new BlockItem(VERTICAL_MOSSY_COBBLESTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_end_stone_brick_slab"), VERTICAL_END_STONE_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_end_stone_brick_slab"), new BlockItem(VERTICAL_END_STONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_smooth_sandstone_slab"), VERTICAL_SMOOTH_SANDSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_smooth_sandstone_slab"), new BlockItem(VERTICAL_SMOOTH_SANDSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_smooth_quartz_slab"), VERTICAL_SMOOTH_QUARTZ_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_smooth_quartz_slab"), new BlockItem(VERTICAL_SMOOTH_QUARTZ_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_granite_slab"), VERTICAL_GRANITE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_granite_slab"), new BlockItem(VERTICAL_GRANITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_andesite_slab"), VERTICAL_ANDESITE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_andesite_slab"), new BlockItem(VERTICAL_ANDESITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_red_nether_brick_slab"), VERTICAL_RED_NETHER_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_red_nether_brick_slab"), new BlockItem(VERTICAL_RED_NETHER_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_polished_andesite_slab"), VERTICAL_POLISHED_ANDESITE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_polished_andesite_slab"), new BlockItem(VERTICAL_POLISHED_ANDESITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_diorite_slab"), VERTICAL_DIORITE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_diorite_slab"), new BlockItem(VERTICAL_DIORITE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_blackstone_slab"), VERTICAL_BLACKSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_blackstone_slab"), new BlockItem(VERTICAL_BLACKSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_polished_blackstone_slab"), VERTICAL_POLISHED_BLACKSTONE_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_polished_blackstone_slab"), new BlockItem(VERTICAL_POLISHED_BLACKSTONE_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
+        Registry.register(Registry.BLOCK, new Identifier(modid,"vertical_polished_blackstone_brick_slab"), VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB);
+        Registry.register(Registry.ITEM, new Identifier(modid,"vertical_polished_blackstone_brick_slab"), new BlockItem(VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB, new Item.Settings().group(VPItemGroups.VERTICAL_SLABS)));
     }
 
     static {
@@ -146,36 +149,37 @@ public class VPVerticalSlabs {
         VERTICAL_DARK_OAK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.WOOD).sounds(BlockSoundGroup.WOOD).hardness(2.0F));
         VERTICAL_CRIMSON_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.WOOD).sounds(BlockSoundGroup.WOOD).hardness(2.0F));
         VERTICAL_WARPED_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.WOOD).sounds(BlockSoundGroup.WOOD).hardness(2.0F));
-        VERTICAL_STONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_SMOOTH_STONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_CUT_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_COBBLESTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_STONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_NETHER_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_QUARTZ_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_RED_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_CUT_RED_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_PURPUR_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_PRISMARINE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_PRISMARINE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_DARK_PRISMARINE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_POLISHED_GRANITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_SMOOTH_RED_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_MOSSY_STONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_POLISHED_DIORITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_MOSSY_COBBLESTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_END_STONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_SMOOTH_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_SMOOTH_QUARTZ_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_GRANITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_ANDESITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_RED_NETHER_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_POLISHED_ANDESITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_DIORITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_BLACKSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_POLISHED_BLACKSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
-        VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F));
+        VERTICAL_MANGROVE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.WOOD).sounds(BlockSoundGroup.WOOD).hardness(2.0F));
+        VERTICAL_STONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_SMOOTH_STONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_CUT_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_COBBLESTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_STONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_NETHER_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_QUARTZ_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_RED_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_CUT_RED_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_PURPUR_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_PRISMARINE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_PRISMARINE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_DARK_PRISMARINE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_POLISHED_GRANITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_SMOOTH_RED_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_MOSSY_STONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_POLISHED_DIORITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_MOSSY_COBBLESTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_END_STONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_SMOOTH_SANDSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_SMOOTH_QUARTZ_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_GRANITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_ANDESITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_RED_NETHER_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_POLISHED_ANDESITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_DIORITE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_BLACKSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_POLISHED_BLACKSTONE_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
+        VERTICAL_POLISHED_BLACKSTONE_BRICK_SLAB = new VerticalSlabs(FabricBlockSettings.of(Material.STONE).sounds(BlockSoundGroup.STONE).hardness(2.0F).requiresTool());
     }
 }

src/main/java/tech/nevets/vplus/blocks/VerticalSlabs.java

@@ -14,6 +14,9 @@ import net.minecraft.util.shape.VoxelShape;
 import net.minecraft.util.shape.VoxelShapes;
 import net.minecraft.world.BlockView;
 
+import java.util.Objects;
+
+
 public class VerticalSlabs extends HorizontalFacingBlock {
     private static final VoxelShape NORTH_SHAPE;
     private static final VoxelShape EAST_SHAPE;
@@ -28,8 +31,8 @@ public class VerticalSlabs extends HorizontalFacingBlock {
 
     //TODO Fix Waterlogging
     @Override
-    public FluidState getFluidState(BlockState blockState) {
-        return blockState.get(WATERLOGGED) ? Fluids.WATER.getStill(false) : super.getFluidState(blockState);
+    public FluidState getFluidState(BlockState blockState_1) {
+        return blockState_1.get(WATERLOGGED) ? Fluids.WATER.getStill(false) : super.getFluidState(blockState_1);
     }
 
     @Override
@@ -41,7 +44,7 @@ public class VerticalSlabs extends HorizontalFacingBlock {
     public BlockState getPlacementState(ItemPlacementContext itemPlacementContext) {
         FluidState fluidState = itemPlacementContext.getWorld().getFluidState(itemPlacementContext.getBlockPos());
         boolean waterLog = fluidState.isIn(FluidTags.WATER) && fluidState.getLevel() == 8;
-        return super.getPlacementState(itemPlacementContext).with(WATERLOGGED, waterLog)
+        return Objects.requireNonNull(super.getPlacementState(itemPlacementContext)).with(WATERLOGGED, waterLog)
                 .with(FACING, itemPlacementContext.getPlayerFacing().getOpposite());
     }
 
@@ -52,28 +55,28 @@ public class VerticalSlabs extends HorizontalFacingBlock {
 
     @Override
     public VoxelShape getOutlineShape(BlockState state, BlockView view, BlockPos pos, ShapeContext context) {
-        switch(state.get(FACING)) {
-            case NORTH: return NORTH_SHAPE;
-            case EAST: return EAST_SHAPE;
-            case SOUTH: return SOUTH_SHAPE;
-            case WEST: return WEST_SHAPE;
-            default: return super.getOutlineShape(state, view, pos, context);
-        }
+        return switch (state.get(FACING)) {
+            case NORTH -> NORTH_SHAPE;
+            case EAST -> EAST_SHAPE;
+            case SOUTH -> SOUTH_SHAPE;
+            case WEST -> WEST_SHAPE;
+            default -> super.getOutlineShape(state, view, pos, context);
+        };
     }
 
     static {
         VoxelShape shape = createCuboidShape(0.0D, 0.0D, 0.0D, 8.0D, 16.0D, 16.0D);
 
         EAST_SHAPE = shape;
-        NORTH_SHAPE = rotate(Direction.EAST, Direction.NORTH, shape);
-        SOUTH_SHAPE = rotate(Direction.EAST, Direction.SOUTH, shape);
-        WEST_SHAPE = rotate(Direction.EAST, Direction.WEST, shape);
+        NORTH_SHAPE = rotate(Direction.NORTH, shape);
+        SOUTH_SHAPE = rotate(Direction.SOUTH, shape);
+        WEST_SHAPE = rotate(Direction.WEST, shape);
     }
 
-    private static VoxelShape rotate(Direction from, Direction to, VoxelShape shape) {
+    private static VoxelShape rotate(Direction to, VoxelShape shape) {
         VoxelShape[] buffer = new VoxelShape[]{ shape, VoxelShapes.empty() };
 
-        int times = (to.getHorizontal() - from.getHorizontal() + 4) % 4;
+        int times = (to.getHorizontal() - Direction.EAST.getHorizontal() + 4) % 4;
         for (int i = 0; i < times; i++) {
             buffer[0].forEachBox((minX, minY, minZ, maxX, maxY, maxZ) -> buffer[1] = VoxelShapes.union(buffer[1], VoxelShapes.cuboid(1-maxZ, minY, minX, 1-minZ, maxY, maxX)));
             buffer[0] = buffer[1];

src/main/java/tech/nevets/vplus/food/EnchantedCopperApple.java

@@ -12,7 +12,6 @@ public class EnchantedCopperApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(12).saturationModifier(16).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 6),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/EnchantedDiamondApple.java

@@ -12,7 +12,6 @@ public class EnchantedDiamondApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(8).saturationModifier(14).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 4),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/EnchantedEmeraldApple.java

@@ -12,7 +12,6 @@ public class EnchantedEmeraldApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(12).saturationModifier(16).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 6),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/EnchantedIronApple.java

@@ -12,7 +12,6 @@ public class EnchantedIronApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(6).saturationModifier(10).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 2),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/EnchantedNetheriteApple.java

@@ -12,7 +12,6 @@ public class EnchantedNetheriteApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(14).saturationModifier(18).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 8),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/EnchantedPlatinumApple.java

@@ -12,7 +12,6 @@ public class EnchantedPlatinumApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(16).saturationModifier(20).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 10),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/EnchantedRubyApple.java

@@ -12,7 +12,6 @@ public class EnchantedRubyApple extends Item {
         super(new Settings().group(VPItemGroups.FOOD).food(new FoodComponent.Builder().hunger(18).saturationModifier(22).alwaysEdible().statusEffect(new StatusEffectInstance(StatusEffects.REGENERATION, 20*120, 12),1f).build()));
     }
 
-    @Override
     public boolean hasGlint(ItemStack stack) {
         return true;
     }

src/main/java/tech/nevets/vplus/food/VPFood.java

@@ -4,6 +4,8 @@ import net.minecraft.item.Item;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 
+import static tech.nevets.vplus.Main.modid;
+
 public class VPFood {
 
     public static final Item IRONAPPLE = new IronApple();
@@ -27,19 +29,19 @@ public class VPFood {
 
     //TODO Balance apple strengths
     public static void initializeApples() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "iron_apple"), IRONAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_iron_apple"), ENCHANTEDIRONAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_apple"), COPPERAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_copper_apple"), ENCHANTEDCOPPERAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "diamond_apple"), DIAMONDAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_diamond_apple"), ENCHANTEDDIAMONDAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_apple"), EMERALDAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_emerald_apple"), ENCHANTEDEMERALDAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "netherite_apple"), NETHERITEAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_netherite_apple"), ENCHANTEDNETHERITEAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_apple"), PLATINUMAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_platinum_apple"), ENCHANTEDPLATINUMAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_apple"), RUBYAPPLE);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "enchanted_ruby_apple"), ENCHANTEDRUBYAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "iron_apple"), IRONAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_iron_apple"), ENCHANTEDIRONAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_apple"), COPPERAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_copper_apple"), ENCHANTEDCOPPERAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "diamond_apple"), DIAMONDAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_diamond_apple"), ENCHANTEDDIAMONDAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_apple"), EMERALDAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_emerald_apple"), ENCHANTEDEMERALDAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "netherite_apple"), NETHERITEAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_netherite_apple"), ENCHANTEDNETHERITEAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_apple"), PLATINUMAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_platinum_apple"), ENCHANTEDPLATINUMAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_apple"), RUBYAPPLE);
+        Registry.register(Registry.ITEM, new Identifier(modid, "enchanted_ruby_apple"), ENCHANTEDRUBYAPPLE);
     }
 }

src/main/java/tech/nevets/vplus/items/VPItems.java

@@ -4,6 +4,8 @@ import net.minecraft.item.Item;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 
+import static tech.nevets.vplus.Main.modid;
+
 public class VPItems {
 
     public static final Item PLATINUMINGOT = new PlatinumIngot(new Item.Settings().group(VPItemGroups.ALL));
@@ -15,9 +17,9 @@ public class VPItems {
     }
 
     public static void initializeValuables() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_ingot"), PLATINUMINGOT);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_nugget"), PLATINUMNUGGET);
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby"), RUBY);
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_ingot"), PLATINUMINGOT);
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_nugget"), PLATINUMNUGGET);
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby"), RUBY);
     }
 
 }

src/main/java/tech/nevets/vplus/misc/VPOreGen.java

@@ -0,0 +1,59 @@
+package tech.nevets.vplus.misc;
+
+import net.fabricmc.fabric.api.biome.v1.BiomeModifications;
+import net.fabricmc.fabric.api.biome.v1.BiomeSelectors;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.BuiltinRegistries;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.util.registry.RegistryEntry;
+import net.minecraft.util.registry.RegistryKey;
+import net.minecraft.world.gen.GenerationStep;
+import net.minecraft.world.gen.YOffset;
+import net.minecraft.world.gen.feature.*;
+import net.minecraft.world.gen.placementmodifier.CountPlacementModifier;
+import net.minecraft.world.gen.placementmodifier.HeightRangePlacementModifier;
+import net.minecraft.world.gen.placementmodifier.SquarePlacementModifier;
+import tech.nevets.vplus.blocks.VPBlocks;
+
+import java.util.Arrays;
+
+import static tech.nevets.vplus.Main.modid;
+
+public class VPOreGen {
+
+    private static final ConfiguredFeature<?, ?> ORE_PLATINUM_OVERWORLD_CONFIGURED = new ConfiguredFeature<>
+            (Feature.ORE, new OreFeatureConfig(
+                    OreConfiguredFeatures.BASE_STONE_OVERWORLD,
+                    VPBlocks.PLATINUMORE.getDefaultState(),
+                    3)); // vein size
+    public static PlacedFeature ORE_PLATINUM_OVERWORLD_PLACED = new PlacedFeature(
+            RegistryEntry.of(ORE_PLATINUM_OVERWORLD_CONFIGURED),
+            Arrays.asList(
+            CountPlacementModifier.of(2), // number of veins per chunk
+            SquarePlacementModifier.of(),
+            HeightRangePlacementModifier.uniform(YOffset.getBottom(), YOffset.fixed(15))
+    ));
+
+    private static final ConfiguredFeature<?, ?> ORE_RUBY_OVERWORLD_CONFIGURED = new ConfiguredFeature<>
+            (Feature.ORE, new OreFeatureConfig(
+                    OreConfiguredFeatures.BASE_STONE_OVERWORLD,
+                    VPBlocks.RUBYORE.getDefaultState(),
+                    1));
+    public static PlacedFeature ORE_RUBY_OVERWORLD_PLACED = new PlacedFeature(
+            RegistryEntry.of(ORE_RUBY_OVERWORLD_CONFIGURED),
+            Arrays.asList(
+            CountPlacementModifier.of(8), // number of veins per chunk
+            SquarePlacementModifier.of(),
+            HeightRangePlacementModifier.uniform(YOffset.getBottom(), YOffset.fixed(15))
+    ));
+
+    public static void vpOres() {
+        Registry.register(BuiltinRegistries.CONFIGURED_FEATURE, new Identifier(modid, "platinum_ore"), ORE_PLATINUM_OVERWORLD_CONFIGURED);
+        Registry.register(BuiltinRegistries.PLACED_FEATURE, new Identifier(modid, "platinum_ore"), ORE_PLATINUM_OVERWORLD_PLACED);
+        BiomeModifications.addFeature(BiomeSelectors.foundInOverworld(), GenerationStep.Feature.UNDERGROUND_ORES, RegistryKey.of(Registry.PLACED_FEATURE_KEY, new Identifier(modid, "platinum_ore")));
+
+        Registry.register(BuiltinRegistries.CONFIGURED_FEATURE, new Identifier(modid, "ruby_ore"), ORE_RUBY_OVERWORLD_CONFIGURED);
+        Registry.register(BuiltinRegistries.PLACED_FEATURE, new Identifier(modid, "ruby_ore"), ORE_RUBY_OVERWORLD_PLACED);
+        BiomeModifications.addFeature(BiomeSelectors.foundInOverworld(), GenerationStep.Feature.UNDERGROUND_ORES, RegistryKey.of(Registry.PLACED_FEATURE_KEY, new Identifier(modid, "ruby_ore")));
+    }
+}

src/main/java/tech/nevets/vplus/tools/AxeBase.java

@@ -5,7 +5,7 @@ import net.minecraft.item.ToolMaterial;
 import tech.nevets.vplus.items.VPItemGroups;
 
 public class AxeBase extends AxeItem {
-    public AxeBase(ToolMaterial toolMaterial) {
-        super(toolMaterial, 5, -3.0f, new Settings().group(VPItemGroups.TOOLS));
+    public AxeBase(ToolMaterial toolMaterial_1) {
+        super(toolMaterial_1, 5, -3.0f, new Settings().group(VPItemGroups.TOOLS));
     }
 }

src/main/java/tech/nevets/vplus/tools/HoeBase.java

@@ -5,7 +5,7 @@ import net.minecraft.item.ToolMaterial;
 import tech.nevets.vplus.items.VPItemGroups;
 
 public class HoeBase extends HoeItem {
-    public HoeBase(ToolMaterial toolMaterial) {
-        super(toolMaterial, -3, 0f, new Settings().group(VPItemGroups.TOOLS));
+    public HoeBase(ToolMaterial toolMaterial_1) {
+        super(toolMaterial_1, -3, 0f, new Settings().group(VPItemGroups.TOOLS));
     }
 }

src/main/java/tech/nevets/vplus/tools/PickaxeBase.java

@@ -5,7 +5,7 @@ import net.minecraft.item.ToolMaterial;
 import tech.nevets.vplus.items.VPItemGroups;
 
 public class PickaxeBase extends PickaxeItem {
-    public PickaxeBase(ToolMaterial toolMaterial) {
-        super(toolMaterial, 1, -2.8f, new Settings().group(VPItemGroups.TOOLS));
+    public PickaxeBase(ToolMaterial toolMaterial_1) {
+        super(toolMaterial_1, 1, -2.8f, new Settings().group(VPItemGroups.TOOLS));
     }
 }

src/main/java/tech/nevets/vplus/tools/ShovelBase.java

@@ -5,7 +5,7 @@ import net.minecraft.item.ToolMaterial;
 import tech.nevets.vplus.items.VPItemGroups;
 
 public class ShovelBase extends ShovelItem {
-    public ShovelBase(ToolMaterial toolMaterial) {
-        super(toolMaterial, 1, -3f, new Settings().group(VPItemGroups.TOOLS));
+    public ShovelBase(ToolMaterial toolMaterial_1) {
+        super(toolMaterial_1, 1, -3f, new Settings().group(VPItemGroups.TOOLS));
     }
 }

src/main/java/tech/nevets/vplus/tools/SwordBase.java

@@ -5,7 +5,7 @@ import net.minecraft.item.ToolMaterial;
 import tech.nevets.vplus.items.VPItemGroups;
 
 public class SwordBase extends SwordItem {
-    public SwordBase(ToolMaterial toolMaterial) {
-        super(toolMaterial, 2, -2.4f, new Settings().group(VPItemGroups.COMBAT));
+    public SwordBase(ToolMaterial toolMaterial_1) {
+        super(toolMaterial_1, 2, -2.4f, new Settings().group(VPItemGroups.COMBAT));
     }
 }

src/main/java/tech/nevets/vplus/tools/ToolMaterials.java

@@ -1,12 +1,13 @@
 package tech.nevets.vplus.tools;
 
-import java.util.function.Supplier;
 import net.minecraft.item.Items;
 import net.minecraft.item.ToolMaterial;
 import net.minecraft.recipe.Ingredient;
 import net.minecraft.util.Lazy;
 import tech.nevets.vplus.items.VPItems;
 
+import java.util.function.Supplier;
+
 public enum ToolMaterials implements ToolMaterial {
     COPPER (2, 200, 5.0F, 3.0F, 20, () -> Ingredient.ofItems(Items.COPPER_INGOT)),
     EMERALD(3, 750, 7.0F, 4.0F, 30, () -> Ingredient.ofItems(Items.EMERALD)),
@@ -25,7 +26,7 @@ public enum ToolMaterials implements ToolMaterial {
         this.miningSpeed = miningSpeed;
         this.attackDamage = attackDamage;
         this.enchantability = enchantability;
-        this.repairIngredient = new Lazy(repairIngredient);
+        this.repairIngredient = new Lazy<>(repairIngredient);
     }
 
     public int getDurability() {
@@ -49,6 +50,6 @@ public enum ToolMaterials implements ToolMaterial {
     }
 
     public Ingredient getRepairIngredient() {
-        return (Ingredient)this.repairIngredient.get();
+        return this.repairIngredient.get();
     }
 }

src/main/java/tech/nevets/vplus/tools/VPTools.java

@@ -3,6 +3,8 @@ package tech.nevets.vplus.tools;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 
+import static tech.nevets.vplus.Main.modid;
+
 public class VPTools {
 
     public static void vpTools() {
@@ -14,37 +16,37 @@ public class VPTools {
     }
 
     public static void initializeAxes() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_axe"), new AxeBase(ToolMaterials.COPPER));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_axe"), new AxeBase(ToolMaterials.EMERALD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_axe"), new AxeBase(ToolMaterials.PLATINUM));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_axe"), new AxeBase(ToolMaterials.RUBY));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_axe"), new AxeBase(ToolMaterials.COPPER));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_axe"), new AxeBase(ToolMaterials.EMERALD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_axe"), new AxeBase(ToolMaterials.PLATINUM));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_axe"), new AxeBase(ToolMaterials.RUBY));
     }
 
     public static void initializeHoes() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_hoe"), new HoeBase(ToolMaterials.COPPER));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_hoe"), new HoeBase(ToolMaterials.EMERALD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_hoe"), new HoeBase(ToolMaterials.PLATINUM));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_hoe"), new HoeBase(ToolMaterials.RUBY));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_hoe"), new HoeBase(ToolMaterials.COPPER));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_hoe"), new HoeBase(ToolMaterials.EMERALD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_hoe"), new HoeBase(ToolMaterials.PLATINUM));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_hoe"), new HoeBase(ToolMaterials.RUBY));
     }
 
     public static void initializePickaxes() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_pickaxe"), new PickaxeBase(ToolMaterials.COPPER));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_pickaxe"), new PickaxeBase(ToolMaterials.EMERALD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_pickaxe"), new PickaxeBase(ToolMaterials.PLATINUM));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_pickaxe"), new PickaxeBase(ToolMaterials.RUBY));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_pickaxe"), new PickaxeBase(ToolMaterials.COPPER));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_pickaxe"), new PickaxeBase(ToolMaterials.EMERALD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_pickaxe"), new PickaxeBase(ToolMaterials.PLATINUM));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_pickaxe"), new PickaxeBase(ToolMaterials.RUBY));
     }
 
     public static void initializeShovels() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_shovel"), new ShovelBase(ToolMaterials.COPPER));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_shovel"), new ShovelBase(ToolMaterials.EMERALD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_shovel"), new ShovelBase(ToolMaterials.PLATINUM));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_shovel"), new ShovelBase(ToolMaterials.RUBY));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_shovel"), new ShovelBase(ToolMaterials.COPPER));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_shovel"), new ShovelBase(ToolMaterials.EMERALD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_shovel"), new ShovelBase(ToolMaterials.PLATINUM));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_shovel"), new ShovelBase(ToolMaterials.RUBY));
     }
 
     public static void initializeSwords() {
-        Registry.register(Registry.ITEM, new Identifier("vplus", "copper_sword"), new SwordBase(ToolMaterials.COPPER));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "emerald_sword"), new SwordBase(ToolMaterials.EMERALD));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "platinum_sword"), new SwordBase(ToolMaterials.PLATINUM));
-        Registry.register(Registry.ITEM, new Identifier("vplus", "ruby_sword"), new SwordBase(ToolMaterials.RUBY));
+        Registry.register(Registry.ITEM, new Identifier(modid, "copper_sword"), new SwordBase(ToolMaterials.COPPER));
+        Registry.register(Registry.ITEM, new Identifier(modid, "emerald_sword"), new SwordBase(ToolMaterials.EMERALD));
+        Registry.register(Registry.ITEM, new Identifier(modid, "platinum_sword"), new SwordBase(ToolMaterials.PLATINUM));
+        Registry.register(Registry.ITEM, new Identifier(modid, "ruby_sword"), new SwordBase(ToolMaterials.RUBY));
     }
 }

src/main/java/tech/nevets/vplus/worldgen/VPOreGen.java

@@ -1,10 +0,0 @@
-package tech.nevets.vplus.worldgen;
-
-public class VPOreGen {
-
-    public VPOreGen() {
-    }
-
-    public static void generateOres() {
-    }
-}

src/main/java/tech/nevets/vplus/worldgen/features/VPOreConfiguredFeatures.java

@@ -1,28 +0,0 @@
-package tech.nevets.vplus.worldgen.features;
-
-import net.minecraft.util.registry.RegistryEntry;
-import net.minecraft.world.gen.feature.*;
-import tech.nevets.vplus.VPBlocks;
-
-import java.util.List;
-
-public class VPOreConfiguredFeatures extends OreConfiguredFeatures {
-    public static final List<OreFeatureConfig.Target> SAPPHIRE_ORES;
-    public static final List<OreFeatureConfig.Target> RUBY_ORES;
-    public static final List<OreFeatureConfig.Target> JADE_ORES;
-    public static final RegistryEntry<ConfiguredFeature<OreFeatureConfig, ?>> ORE_SAPPHIRE;
-    public static final RegistryEntry<ConfiguredFeature<OreFeatureConfig, ?>> ORE_RUBY;
-    public static final RegistryEntry<ConfiguredFeature<OreFeatureConfig, ?>> ORE_JADE;
-
-    public VPOreConfiguredFeatures() {
-    }
-
-    static {
-        SAPPHIRE_ORES = List.of(OreFeatureConfig.createTarget(STONE_ORE_REPLACEABLES, VPBlocks.SAPPHIRE_ORE.getDefaultState()));
-        RUBY_ORES = List.of(OreFeatureConfig.createTarget(STONE_ORE_REPLACEABLES, VPBlocks.RUBY_ORE.getDefaultState()));
-        JADE_ORES = List.of(OreFeatureConfig.createTarget(STONE_ORE_REPLACEABLES, VPBlocks.RUBY_ORE.getDefaultState()));
-        ORE_SAPPHIRE = ConfiguredFeatures.register("ore_sapphire", Feature.ORE, new OreFeatureConfig(List.of(OreFeatureConfig.createTarget(STONE_ORE_REPLACEABLES, VPBlocks.SAPPHIRE_ORE.getDefaultState())), 4));
-        ORE_RUBY = ConfiguredFeatures.register("ore_ruby", Feature.ORE, new OreFeatureConfig(List.of(OreFeatureConfig.createTarget(STONE_ORE_REPLACEABLES, VPBlocks.RUBY_ORE.getDefaultState())), 3));
-        ORE_JADE = ConfiguredFeatures.register("ore_jade", Feature.ORE, new OreFeatureConfig(List.of(OreFeatureConfig.createTarget(STONE_ORE_REPLACEABLES, VPBlocks.JADE_ORE.getDefaultState())), 2));
-    }
-}

src/main/java/tech/nevets/vplus/worldgen/features/VPPlacedFeatures.java

@@ -1,37 +0,0 @@
-package tech.nevets.vplus.worldgen.features;
-
-import net.minecraft.util.registry.RegistryEntry;
-import net.minecraft.world.gen.YOffset;
-import net.minecraft.world.gen.feature.OrePlacedFeatures;
-import net.minecraft.world.gen.feature.PlacedFeature;
-import net.minecraft.world.gen.feature.PlacedFeatures;
-import net.minecraft.world.gen.placementmodifier.*;
-
-import java.util.List;
-
-public class VPPlacedFeatures extends OrePlacedFeatures {
-    public static final RegistryEntry<PlacedFeature> ORE_SAPPHIRE;
-    public static final RegistryEntry<PlacedFeature> ORE_RUBY;
-    public static final RegistryEntry<PlacedFeature> ORE_JADE;
-
-    public VPPlacedFeatures() {
-    }
-
-    private static List<PlacementModifier> modifiers(PlacementModifier countModifier, PlacementModifier heightModifier) {
-        return List.of(countModifier, SquarePlacementModifier.of(), heightModifier, BiomePlacementModifier.of());
-    }
-
-    private static List<PlacementModifier> modifiersWithCount(int count, PlacementModifier heightModifier) {
-        return modifiers(CountPlacementModifier.of(count), heightModifier);
-    }
-
-    private static List<PlacementModifier> modifiersWithRarity(int chance, PlacementModifier heightModifier) {
-        return modifiers(RarityFilterPlacementModifier.of(chance), heightModifier);
-    }
-
-    static {
-        ORE_SAPPHIRE = PlacedFeatures.register("ore_sapphire", VPOreConfiguredFeatures.ORE_SAPPHIRE, modifiersWithCount(4, HeightRangePlacementModifier.trapezoid(YOffset.fixed(0), YOffset.fixed(24))));
-        ORE_RUBY = PlacedFeatures.register("ore_ruby", VPOreConfiguredFeatures.ORE_RUBY, modifiersWithCount(3, HeightRangePlacementModifier.uniform(YOffset.fixed(-12), YOffset.fixed(0))));
-        ORE_JADE = PlacedFeatures.register("ore_jade", VPOreConfiguredFeatures.ORE_SAPPHIRE, modifiersWithCount(2, HeightRangePlacementModifier.trapezoid(YOffset.fixed(-24), YOffset.fixed(-12))));
-    }
-}

src/main/resources/assets/vplus/blockstates/vertical_mangrove_slab.json

@@ -0,0 +1,8 @@
+{
+    "variants": {
+        "facing=north": { "model": "block/mangrove_slab", "x": 90, "uvlock": true },
+		"facing=east": { "model": "block/mangrove_slab", "x": 90, "y": 90, "uvlock": true },
+		"facing=south": { "model": "block/mangrove_slab", "x": 90, "y": 180, "uvlock": true },
+		"facing=west": { "model": "block/mangrove_slab", "x": 90, "y": 270, "uvlock": true }
+    }
+}

src/main/resources/assets/vplus/lang/en_us.json

@@ -81,6 +81,7 @@
   "block.vplus.vertical_dark_oak_slab":"Vertical Dark Oak Slab",
   "block.vplus.vertical_crimson_slab":"Vertical Crimson Slab",
   "block.vplus.vertical_warped_slab":"Vertical Warped Slab",
+  "block.vplus.vertical_mangrove_slab":"Vertical Mangrove Slab",
   "block.vplus.vertical_stone_slab":"Vertical Stone Slab",
   "block.vplus.vertical_smooth_stone_slab":"Vertical Smooth Stone Slab",
   "block.vplus.vertical_sandstone_slab":"Vertical Sandstone Slab",

src/main/resources/assets/vplus/models/block/vertical_mangrove_slab.json

@@ -0,0 +1,8 @@
+{
+  "parent": "vplus:block/vertical_slab",
+  "textures": {
+    "bottom": "minecraft:block/mangrove_planks",
+    "top": "minecraft:block/mangrove_planks",
+    "side": "minecraft:block/mangrove_planks"
+  }
+}

src/main/resources/assets/vplus/models/item/vertical_mangrove_slab.json

@@ -0,0 +1,3 @@
+{
+    "parent": "vplus:block/vertical_mangrove_slab"
+}

src/main/resources/data/minecraft/tags/blocks/mineable/axe.json

@@ -0,0 +1,14 @@
+{
+  "replace": false,
+  "values": [
+    "vplus:vertical_oak_slab",
+    "vplus:vertical_spruce_slab",
+    "vplus:vertical_birch_slab",
+    "vplus:vertical_jungle_slab",
+    "vplus:vertical_acacia_slab",
+    "vplus:vertical_dark_oak_slab",
+    "vplus:vertical_crimson_slab",
+    "vplus:vertical_warped_slab",
+    "vplus:vertical_mangrove_slab"
+  ]
+}

src/main/resources/data/minecraft/tags/blocks/mineable/pickaxe.json

@@ -0,0 +1,39 @@
+{
+  "replace": false,
+  "values": [
+    "vplus:platinum_block",
+    "vplus:platinum_ore",
+    "vplus:ruby_block",
+    "vplus:ruby_ore",
+    "vplus:vertical_stone_slab",
+    "vplus:vertical_smooth_stone_slab",
+    "vplus:vertical_sandstone_slab",
+    "vplus:vertical_cut_sandstone_slab",
+    "vplus:vertical_cobblestone_slab",
+    "vplus:vertical_brick_slab",
+    "vplus:vertical_stone_brick_slab",
+    "vplus:vertical_nether_brick_slab",
+    "vplus:vertical_quartz_slab",
+    "vplus:vertical_red_sandstone_slab",
+    "vplus:vertical_cut_red_sandstone_slab",
+    "vplus:vertical_purpur_slab",
+    "vplus:vertical_prismarine_slab",
+    "vplus:vertical_prismarine_brick_slab",
+    "vplus:vertical_dark_prismarine_slab",
+    "vplus:vertical_polished_granite_slab",
+    "vplus:vertical_mossy_stone_brick_slab",
+    "vplus:vertical_polished_diorite_slab",
+    "vplus:vertical_mossy_cobblestone_slab",
+    "vplus:vertical_end_stone_brick_slab",
+    "vplus:vertical_smooth_sandstone_slab",
+    "vplus:vertical_smooth_quartz_slab",
+    "vplus:vertical_granite_slab",
+    "vplus:vertical_andesite_slab",
+    "vplus:vertical_red_nether_brick_slab",
+    "vplus:vertical_polished_andesite_slab",
+    "vplus:vertical_diorite_slab",
+    "vplus:vertical_blackstone_slab",
+    "vplus:vertical_polished_blackstone_slab",
+    "vplus:vertical_polished_blackstone_brick_slab"
+  ]
+}

src/main/resources/data/minecraft/tags/blocks/needs_iron_tool.json

@@ -0,0 +1,7 @@
+{
+  "replace": false,
+  "values": [
+    "vplus:platinum_ore",
+    "vplus:ruby_ore"
+  ]
+}

src/main/resources/data/vplus/loot_tables/blocks/vertical_mangrove_slab.json

@@ -0,0 +1,19 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "vplus:vertical_mangrove_slab"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ]
+}

src/main/resources/data/vplus/recipes/vertical_mangrove_slab.json

@@ -0,0 +1,11 @@
+{
+    "type": "minecraft:crafting_shapeless",
+    "ingredients": [
+        {
+            "item": "minecraft:mangrove_slab"
+        }
+    ],
+    "result": {
+        "item": "vplus:vertical_mangrove_slab"
+    }
+}

src/main/resources/data/vplus/tags/blocks/vertical_slabs.json

@@ -9,6 +9,7 @@
     "vplus:vertical_dark_oak_slab",
     "vplus:vertical_crimson_slab",
     "vplus:vertical_warped_slab",
+    "vplus:vertical_mangrove_slab",
     "vplus:vertical_stone_slab",
     "vplus:vertical_smooth_stone_slab",
     "vplus:vertical_sandstone_slab",

src/main/resources/fabric.mod.json

@@ -37,9 +37,9 @@
   ],
 
   "depends": {
-    "fabricloader": ">=0.14.6",
+    "fabricloader": ">=0.12.9",
     "fabric": "*",
-    "minecraft": "~1.19",
+    "minecraft": "1.19.x",
     "java": ">=17"
   },
   "suggests": {

src/main/resources/vplus.accesswidener

@@ -1,2 +0,0 @@
-accessWidener	v1 named
-accessible method net/minecraft/world/gen/densityfunction/DensityFunctions createSurfaceNoiseRouter (Lnet/minecraft/util/registry/Registry;boolean;boolean;)Lnet/minecraft/world/gen/noise/NoiseRouter;