update to 1.21

blockPropertyDocumentation.txt

@@ -20,9 +20,10 @@
         nether_ore, bone, netherite, ancient_debris, lodestone, chain,
         nether_gold_ore, gilded_blackstone, candle, amethyst_block,
         amethyst_cluster, small_amethyst_bud, medium_amethyst_bud,
-        large_amethyst_bud, tuff, calcite, dripstone_block,
-        pointed_dripstone, copper, cave_vines, spore_blossom, azalea,
-        flowering_azalea, moss_carpet, pink_petals, moss_block, big_dripleaf,
+        large_amethyst_bud, tuff, tuff_bricks, polished_tuff, calcite,
+        dripstone_block, pointed_dripstone, copper, copper_bulb,
+        copper_grate, cave_vines, spore_blossom, azalea, flowering_azalea,
+        moss_carpet, pink_petals, moss_block, big_dripleaf,
         small_dripleaf, rooted_dirt, hanging_roots, azalea_leaves,
         sculk_sensor, sculk_catalyst, sculk, sculk_vein, sculk_shrieker,
         glow_lichen, deepslate, deepslate_bricks, deepslate_tiles,
@@ -31,7 +32,9 @@
         nether_wood_hanging_sign, bamboo_wood_hanging_sign, bamboo_wood,
         nether_wood, cherry_wood, cherry_sapling, cherry_leaves,
         cherry_wood_hanging_sign, chiseled_bookshelf, suspicious_sand,
-        suspicious_gravel, decorated_pot, decorated_pot_shatter
+        suspicious_gravel, decorated_pot, decorated_pot_shatter,
+        trial_spawner, sponge, wet_sponge, vault, heavy_core,
+        cobweb
     changes how the block sounds
 
 "dropTableId" ~ string
@@ -55,7 +58,7 @@
 
 "slipperiness" ~ float
 
-"slowDownMultiplier" ~ float
+"movementVelocityMultiplier" ~ float
 
 "jumpVelocityMultiplier" ~ float
 

build.gradle

@@ -1,5 +1,6 @@
 plugins {
-	id 'fabric-loom' version '1.2-SNAPSHOT'
+	id "com.modrinth.minotaur" version "2.+"
+	id 'fabric-loom' version '1.7-SNAPSHOT'
 	id 'maven-publish'
 }
 
@@ -48,18 +49,11 @@ dependencies {
 	// Uncomment the following line to enable the deprecated Fabric API modules.
 	// These are included in the Fabric API production distribution and allow you to update your mod to the latest modules at a later more convenient time.
 
-
-	include(modApi(platform("de.siphalor.tweed4:tweed4-bom-$project.minecraft_major_version:$project.tweed_version")))
-	// Pick any modules you want to use, e.g.:
-	include(modApi("de.siphalor.tweed4:tweed4-base-$project.minecraft_major_version"))
-	include(modApi("de.siphalor.tweed4:tweed4-annotated-$project.minecraft_major_version"))
-	include(modApi("de.siphalor.tweed4:tweed4-data-$project.minecraft_major_version"))
-	include(modApi("de.siphalor.tweed4:tweed4-data-hjson-$project.minecraft_major_version"))
-	//include(modApi("de.siphalor.tweed4:tweed4-tailor-cloth-$project.minecraft_major_version"))
-	include(modApi("de.siphalor.tweed4:tweed4-tailor-screen-$project.minecraft_major_version"))
-
+    modImplementation  "maven.modrinth:midnightlib:${project.midnightlib_version}"
+    include "maven.modrinth:midnightlib:${project.midnightlib_version}"
 
     modImplementation("me.shedaniel.cloth:cloth-config-fabric:$project.cloth_config_version")
+
 	// modImplementation "net.fabricmc.fabric-api:fabric-api-deprecated:${project.fabric_version}"
 }
 
@@ -79,7 +73,7 @@ processResources {
 }
 
 tasks.withType(JavaCompile).configureEach {
-	it.options.release = 17
+	it.options.release = 21
 }
 
 java {
@@ -88,8 +82,8 @@ java {
 	// If you remove this line, sources will not be generated.
 	withSourcesJar()
 
-	sourceCompatibility = JavaVersion.VERSION_17
-	targetCompatibility = JavaVersion.VERSION_17
+	sourceCompatibility = JavaVersion.VERSION_21
+	targetCompatibility = JavaVersion.VERSION_21
 }
 
 jar {
@@ -98,6 +92,16 @@ jar {
 	}
 }
 
+import com.modrinth.minotaur.dependencies.ModDependency
+
+modrinth {
+    projectId = 'vHsuCD0F' // The ID of your Modrinth project. Slugs will not work.
+    uploadFile = remapJar // Tells Minotaur to use the remapped jar
+    versionType = "alpha"
+    dependencies = [
+            new ModDependency('P7dR8mSH', 'required'), //required dependency on Fabric API
+    ]
+}
 // configure the maven publication
 publishing {
 	publications {

gradle.properties

@@ -1,18 +1,17 @@
 org.gradle.jvmargs  = -Xmx1G
 
 #Fabric properties
-minecraft_version=1.20.1
-minecraft_major_version=1.20
-yarn_mappings=1.20.1+build.9
-loader_version=0.14.21
+minecraft_version=1.21
+yarn_mappings=1.21+build.8
+loader_version=0.15.11
 
-#Fabric api
-fabric_version=0.84.0+1.20.1
+# Fabric API
+fabric_version=0.100.6+1.21
 
 #Mod properties
-mod_version         = 0.10.1
+mod_version         = 0.10.2
 maven_group         = quimufu.simple_creator
 archives_base_name  = simple_creator
 
-tweed_version=1.3.0+mc1.20-pre1
-cloth_config_version=11.0.99
+cloth_config_version=15.0.127
+midnightlib_version=1.5.7-fabric

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/quimufu/simple_creator/BlockResourceLoader.java

@@ -4,7 +4,6 @@ import com.google.common.collect.Maps;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonObject;
-import net.fabricmc.fabric.api.item.v1.FabricItemSettings;
 import net.fabricmc.fabric.api.itemgroup.v1.ItemGroupEvents;
 import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings;
 import net.fabricmc.fabric.api.registry.FlammableBlockRegistry;
@@ -12,15 +11,17 @@ import net.minecraft.block.AbstractBlock;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.MapColor;
-import net.minecraft.block.enums.Instrument;
+import net.minecraft.block.enums.NoteBlockInstrument;
 import net.minecraft.block.piston.PistonBehavior;
 import net.minecraft.entity.EntityType;
 import net.minecraft.item.BlockItem;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemGroup;
+import net.minecraft.loot.LootTable;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.RegistryKeys;
 import net.minecraft.sound.BlockSoundGroup;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.Pair;
@@ -58,6 +59,7 @@ public class BlockResourceLoader extends GenericManualResourceLoader<Pair<Block,
     @Override
     protected Pair<Block, Item> deserialize(Pair<Identifier, JsonObject> e) {
         JsonObject jo = e.getRight();
+        log(Level.INFO, e.getRight().toString());
 
         // get block information
         BlockSettingsPojo bspj = GSON.fromJson(jo, BlockSettingsPojo.class);
@@ -70,7 +72,7 @@ public class BlockResourceLoader extends GenericManualResourceLoader<Pair<Block,
         RegistryKey<ItemGroup> g = ItemResourceLoader.findGroup(group);
         //create block and corresponding item
         Block resB = new Block(bs);
-        Item resI = new BlockItem(resB, new FabricItemSettings());
+        Item resI = new BlockItem(resB, new Item.Settings());
         ItemGroupEvents.modifyEntriesEvent(g).register(content -> content.add(resI));
 
         int burnChance = bspj.burnChance;
@@ -89,7 +91,7 @@ public class BlockResourceLoader extends GenericManualResourceLoader<Pair<Block,
         fabricBlockSettings
                 .collidable(bspj.collidable)
                 .slipperiness(bspj.slipperiness)
-                .velocityMultiplier(bspj.slowDownMultiplier)
+                .velocityMultiplier(bspj.movementVelocityMultiplier)
                 .jumpVelocityMultiplier(bspj.jumpVelocityMultiplier)
                 .sounds(getSoundGroup(bspj.soundGroup))
                 .drops(getDropTableId(bspj.dropTableId))
@@ -140,73 +142,49 @@ public class BlockResourceLoader extends GenericManualResourceLoader<Pair<Block,
         return fabricBlockSettings;
     }
 
-    private Instrument getInstrument(String instrument) {
-        switch (instrument.toUpperCase()) {
-            case "HARP":
-                return Instrument.HARP;
-            case "BASEDRUM":
-                return Instrument.BASEDRUM;
-            case "SNARE":
-                return Instrument.SNARE;
-            case "HAT":
-                return Instrument.HAT;
-            case "BASS":
-                return Instrument.BASS;
-            case "FLUTE":
-                return Instrument.FLUTE;
-            case "BELL":
-                return Instrument.BELL;
-            case "GUITAR":
-                return Instrument.GUITAR;
-            case "CHIME":
-                return Instrument.CHIME;
-            case "XYLOPHONE":
-                return Instrument.XYLOPHONE;
-            case "IRON_XYLOPHONE":
-                return Instrument.IRON_XYLOPHONE;
-            case "COW_BELL":
-                return Instrument.COW_BELL;
-            case "DIDGERIDOO":
-                return Instrument.DIDGERIDOO;
-            case "BIT":
-                return Instrument.BIT;
-            case "BANJO":
-                return Instrument.BANJO;
-            case "PLING":
-                return Instrument.PLING;
-            case "ZOMBIE":
-                return Instrument.ZOMBIE;
-            case "SKELETON":
-                return Instrument.SKELETON;
-            case "CREEPER":
-                return Instrument.CREEPER;
-            case "DRAGON":
-                return Instrument.DRAGON;
-            case "WITHER_SKELETON":
-                return Instrument.WITHER_SKELETON;
-            case "PIGLIN":
-                return Instrument.PIGLIN;
-            case "CUSTOM_HEAD":
-                return Instrument.CUSTOM_HEAD;
-            default:
+    private NoteBlockInstrument getInstrument(String instrument) {
+        return switch (instrument.toUpperCase()) {
+            case "HARP" -> NoteBlockInstrument.HARP;
+            case "BASEDRUM" -> NoteBlockInstrument.BASEDRUM;
+            case "SNARE" -> NoteBlockInstrument.SNARE;
+            case "HAT" -> NoteBlockInstrument.HAT;
+            case "BASS" -> NoteBlockInstrument.BASS;
+            case "FLUTE" -> NoteBlockInstrument.FLUTE;
+            case "BELL" -> NoteBlockInstrument.BELL;
+            case "GUITAR" -> NoteBlockInstrument.GUITAR;
+            case "CHIME" -> NoteBlockInstrument.CHIME;
+            case "XYLOPHONE" -> NoteBlockInstrument.XYLOPHONE;
+            case "IRON_XYLOPHONE" -> NoteBlockInstrument.IRON_XYLOPHONE;
+            case "COW_BELL" -> NoteBlockInstrument.COW_BELL;
+            case "DIDGERIDOO" -> NoteBlockInstrument.DIDGERIDOO;
+            case "BIT" -> NoteBlockInstrument.BIT;
+            case "BANJO" -> NoteBlockInstrument.BANJO;
+            case "PLING" -> NoteBlockInstrument.PLING;
+            case "ZOMBIE" -> NoteBlockInstrument.ZOMBIE;
+            case "SKELETON" -> NoteBlockInstrument.SKELETON;
+            case "CREEPER" -> NoteBlockInstrument.CREEPER;
+            case "DRAGON" -> NoteBlockInstrument.DRAGON;
+            case "WITHER_SKELETON" -> NoteBlockInstrument.WITHER_SKELETON;
+            case "PIGLIN" -> NoteBlockInstrument.PIGLIN;
+            case "CUSTOM_HEAD" -> NoteBlockInstrument.CUSTOM_HEAD;
+            default -> {
                 log(Level.WARN, "Instrument " + instrument + " not found, using harp");
-                return Instrument.HARP;
+                yield NoteBlockInstrument.HARP;
             }
+        };
 
     }
 
     private AbstractBlock.OffsetType getOffset(String modelOffset) {
-        switch (modelOffset.toUpperCase()) {
-            case "NONE":
-                return AbstractBlock.OffsetType.NONE;
-            case "XZ":
-                return AbstractBlock.OffsetType.XZ;
-            case "XYZ":
-                return AbstractBlock.OffsetType.XYZ;
-            default:
+        return switch (modelOffset.toUpperCase()) {
+            case "NONE" -> AbstractBlock.OffsetType.NONE;
+            case "XZ" -> AbstractBlock.OffsetType.XZ;
+            case "XYZ" -> AbstractBlock.OffsetType.XYZ;
+            default -> {
                 log(Level.WARN, "ModelOffset " + modelOffset + " not found, using none");
-                return AbstractBlock.OffsetType.NONE;
+                yield AbstractBlock.OffsetType.NONE;
             }
+        };
 
     }
 
@@ -235,386 +213,221 @@ public class BlockResourceLoader extends GenericManualResourceLoader<Pair<Block,
     }
 
     private PistonBehavior getPistonBehavior(String pistonBehavior) {
-        switch (pistonBehavior.toUpperCase()) {
-            case "NORMAL" -> {
-                return PistonBehavior.NORMAL;
-            }
-            case "DESTROY" -> {
-                return PistonBehavior.DESTROY;
-            }
-            case "BLOCK" -> {
-                return PistonBehavior.BLOCK;
-            }
-            case "IGNORE" -> {
-                return PistonBehavior.IGNORE;
-            }
-            case "PUSH_ONLY" -> {
-                return PistonBehavior.PUSH_ONLY;
-            }
+        return switch (pistonBehavior.toUpperCase()) {
+            case "NORMAL" -> PistonBehavior.NORMAL;
+            case "DESTROY" -> PistonBehavior.DESTROY;
+            case "BLOCK" -> PistonBehavior.BLOCK;
+            case "IGNORE" -> PistonBehavior.IGNORE;
+            case "PUSH_ONLY" -> PistonBehavior.PUSH_ONLY;
             default -> {
                 log(Level.WARN, "Piston Behavior " + pistonBehavior + " not found, using normal");
-                return PistonBehavior.NORMAL;
-            }
+                yield PistonBehavior.NORMAL;
             }
+        };
     }
 
 
     private MapColor getMapColor(String color) {
-        switch (color.toUpperCase()) {
-            case "CLEAR":
-                return MapColor.CLEAR;
-            case "PALE_GREEN":
-                return MapColor.PALE_GREEN;
-            case "PALE_YELLOW":
-                return MapColor.PALE_YELLOW;
-            case "WHITE_GRAY":
-                return MapColor.WHITE_GRAY;
-            case "BRIGHT_RED":
-                return MapColor.BRIGHT_RED;
-            case "PALE_PURPLE":
-                return MapColor.PALE_PURPLE;
-            case "IRON_GRAY":
-                return MapColor.IRON_GRAY;
-            case "DARK_GREEN":
-                return MapColor.DARK_GREEN;
-            case "WHITE":
-                return MapColor.WHITE;
-            case "LIGHT_BLUE_GRAY":
-                return MapColor.LIGHT_BLUE_GRAY;
-            case "DIRT_BROWN":
-                return MapColor.DIRT_BROWN;
-            case "STONE_GRAY":
-                return MapColor.STONE_GRAY;
-            case "WATER_BLUE":
-                return MapColor.WATER_BLUE;
-            case "OAK_TAN":
-                return MapColor.OAK_TAN;
-            case "OFF_WHITE":
-                return MapColor.OFF_WHITE;
-            case "ORANGE":
-                return MapColor.ORANGE;
-            case "MAGENTA":
-                return MapColor.MAGENTA;
-            case "LIGHT_BLUE":
-                return MapColor.LIGHT_BLUE;
-            case "YELLOW":
-                return MapColor.YELLOW;
-            case "LIME":
-                return MapColor.LIME;
-            case "PINK":
-                return MapColor.PINK;
-            case "GRAY":
-                return MapColor.GRAY;
-            case "LIGHT_GRAY":
-                return MapColor.LIGHT_GRAY;
-            case "CYAN":
-                return MapColor.CYAN;
-            case "PURPLE":
-                return MapColor.PURPLE;
-            case "BLUE":
-                return MapColor.BLUE;
-            case "BROWN":
-                return MapColor.BROWN;
-            case "GREEN":
-                return MapColor.GREEN;
-            case "RED":
-                return MapColor.RED;
-            case "BLACK":
-                return MapColor.BLACK;
-            case "GOLD":
-                return MapColor.GOLD;
-            case "DIAMOND_BLUE":
-                return MapColor.DIAMOND_BLUE;
-            case "LAPIS_BLUE":
-                return MapColor.LAPIS_BLUE;
-            case "EMERALD_GREEN":
-                return MapColor.EMERALD_GREEN;
-            case "SPRUCE_BROWN":
-                return MapColor.SPRUCE_BROWN;
-            case "DARK_RED":
-                return MapColor.DARK_RED;
-            case "TERRACOTTA_WHITE":
-                return MapColor.TERRACOTTA_WHITE;
-            case "TERRACOTTA_ORANGE":
-                return MapColor.TERRACOTTA_ORANGE;
-            case "TERRACOTTA_MAGENTA":
-                return MapColor.TERRACOTTA_MAGENTA;
-            case "TERRACOTTA_LIGHT_BLUE":
-                return MapColor.TERRACOTTA_LIGHT_BLUE;
-            case "TERRACOTTA_YELLOW":
-                return MapColor.TERRACOTTA_YELLOW;
-            case "TERRACOTTA_LIME":
-                return MapColor.TERRACOTTA_LIME;
-            case "TERRACOTTA_PINK":
-                return MapColor.TERRACOTTA_PINK;
-            case "TERRACOTTA_GRAY":
-                return MapColor.TERRACOTTA_GRAY;
-            case "TERRACOTTA_LIGHT_GRAY":
-                return MapColor.TERRACOTTA_LIGHT_GRAY;
-            case "TERRACOTTA_CYAN":
-                return MapColor.TERRACOTTA_CYAN;
-            case "TERRACOTTA_PURPLE":
-                return MapColor.TERRACOTTA_PURPLE;
-            case "TERRACOTTA_BLUE":
-                return MapColor.TERRACOTTA_BLUE;
-            case "TERRACOTTA_BROWN":
-                return MapColor.TERRACOTTA_BROWN;
-            case "TERRACOTTA_GREEN":
-                return MapColor.TERRACOTTA_GREEN;
-            case "TERRACOTTA_RED":
-                return MapColor.TERRACOTTA_RED;
-            case "TERRACOTTA_BLACK":
-                return MapColor.TERRACOTTA_BLACK;
-            case "DULL_RED":
-                return MapColor.DULL_RED;
-            case "DULL_PINK":
-                return MapColor.DULL_PINK;
-            case "DARK_CRIMSON":
-                return MapColor.DARK_CRIMSON;
-            case "TEAL":
-                return MapColor.TEAL;
-            case "DARK_AQUA":
-                return MapColor.DARK_AQUA;
-            case "DARK_DULL_PINK":
-                return MapColor.DARK_DULL_PINK;
-            case "BRIGHT_TEAL":
-                return MapColor.BRIGHT_TEAL;
-            case "DEEPSLATE_GRAY":
-                return MapColor.DEEPSLATE_GRAY;
-            case "RAW_IRON_PINK":
-                return MapColor.RAW_IRON_PINK;
-            case "LICHEN_GREEN":
-                return MapColor.LICHEN_GREEN;
-
-            default:
+        return switch (color.toUpperCase()) {
+            case "CLEAR" -> MapColor.CLEAR;
+            case "PALE_GREEN" -> MapColor.PALE_GREEN;
+            case "PALE_YELLOW" -> MapColor.PALE_YELLOW;
+            case "WHITE_GRAY" -> MapColor.WHITE_GRAY;
+            case "BRIGHT_RED" -> MapColor.BRIGHT_RED;
+            case "PALE_PURPLE" -> MapColor.PALE_PURPLE;
+            case "IRON_GRAY" -> MapColor.IRON_GRAY;
+            case "DARK_GREEN" -> MapColor.DARK_GREEN;
+            case "WHITE" -> MapColor.WHITE;
+            case "LIGHT_BLUE_GRAY" -> MapColor.LIGHT_BLUE_GRAY;
+            case "DIRT_BROWN" -> MapColor.DIRT_BROWN;
+            case "STONE_GRAY" -> MapColor.STONE_GRAY;
+            case "WATER_BLUE" -> MapColor.WATER_BLUE;
+            case "OAK_TAN" -> MapColor.OAK_TAN;
+            case "OFF_WHITE" -> MapColor.OFF_WHITE;
+            case "ORANGE" -> MapColor.ORANGE;
+            case "MAGENTA" -> MapColor.MAGENTA;
+            case "LIGHT_BLUE" -> MapColor.LIGHT_BLUE;
+            case "YELLOW" -> MapColor.YELLOW;
+            case "LIME" -> MapColor.LIME;
+            case "PINK" -> MapColor.PINK;
+            case "GRAY" -> MapColor.GRAY;
+            case "LIGHT_GRAY" -> MapColor.LIGHT_GRAY;
+            case "CYAN" -> MapColor.CYAN;
+            case "PURPLE" -> MapColor.PURPLE;
+            case "BLUE" -> MapColor.BLUE;
+            case "BROWN" -> MapColor.BROWN;
+            case "GREEN" -> MapColor.GREEN;
+            case "RED" -> MapColor.RED;
+            case "BLACK" -> MapColor.BLACK;
+            case "GOLD" -> MapColor.GOLD;
+            case "DIAMOND_BLUE" -> MapColor.DIAMOND_BLUE;
+            case "LAPIS_BLUE" -> MapColor.LAPIS_BLUE;
+            case "EMERALD_GREEN" -> MapColor.EMERALD_GREEN;
+            case "SPRUCE_BROWN" -> MapColor.SPRUCE_BROWN;
+            case "DARK_RED" -> MapColor.DARK_RED;
+            case "TERRACOTTA_WHITE" -> MapColor.TERRACOTTA_WHITE;
+            case "TERRACOTTA_ORANGE" -> MapColor.TERRACOTTA_ORANGE;
+            case "TERRACOTTA_MAGENTA" -> MapColor.TERRACOTTA_MAGENTA;
+            case "TERRACOTTA_LIGHT_BLUE" -> MapColor.TERRACOTTA_LIGHT_BLUE;
+            case "TERRACOTTA_YELLOW" -> MapColor.TERRACOTTA_YELLOW;
+            case "TERRACOTTA_LIME" -> MapColor.TERRACOTTA_LIME;
+            case "TERRACOTTA_PINK" -> MapColor.TERRACOTTA_PINK;
+            case "TERRACOTTA_GRAY" -> MapColor.TERRACOTTA_GRAY;
+            case "TERRACOTTA_LIGHT_GRAY" -> MapColor.TERRACOTTA_LIGHT_GRAY;
+            case "TERRACOTTA_CYAN" -> MapColor.TERRACOTTA_CYAN;
+            case "TERRACOTTA_PURPLE" -> MapColor.TERRACOTTA_PURPLE;
+            case "TERRACOTTA_BLUE" -> MapColor.TERRACOTTA_BLUE;
+            case "TERRACOTTA_BROWN" -> MapColor.TERRACOTTA_BROWN;
+            case "TERRACOTTA_GREEN" -> MapColor.TERRACOTTA_GREEN;
+            case "TERRACOTTA_RED" -> MapColor.TERRACOTTA_RED;
+            case "TERRACOTTA_BLACK" -> MapColor.TERRACOTTA_BLACK;
+            case "DULL_RED" -> MapColor.DULL_RED;
+            case "DULL_PINK" -> MapColor.DULL_PINK;
+            case "DARK_CRIMSON" -> MapColor.DARK_CRIMSON;
+            case "TEAL" -> MapColor.TEAL;
+            case "DARK_AQUA" -> MapColor.DARK_AQUA;
+            case "DARK_DULL_PINK" -> MapColor.DARK_DULL_PINK;
+            case "BRIGHT_TEAL" -> MapColor.BRIGHT_TEAL;
+            case "DEEPSLATE_GRAY" -> MapColor.DEEPSLATE_GRAY;
+            case "RAW_IRON_PINK" -> MapColor.RAW_IRON_PINK;
+            case "LICHEN_GREEN" -> MapColor.LICHEN_GREEN;
+            default -> {
                 log(Level.WARN, "MapColor " + color + " not found, using pink");
-                return MapColor.PINK;
+                yield MapColor.PINK;
             }
+        };
     }
 
-    private Identifier getDropTableId(String s) {
+    private RegistryKey<LootTable> getDropTableId(String s) {
         if (s == null)
             return null;
         Identifier i = Identifier.tryParse(s);
         if (i == null) {
             log(Level.WARN, "Drop table invalid " + s + ", using default");
-            i = null;
         }
-        return i;
+        return RegistryKey.of(RegistryKeys.LOOT_TABLE, i);
     }
 
     private BlockSoundGroup getSoundGroup(String s) {
-        switch (s.toUpperCase()) {
-            case "INTENTIONALLY_EMPTY":
-                return BlockSoundGroup.INTENTIONALLY_EMPTY;
-            case "WOOD":
-                return BlockSoundGroup.WOOD;
-            case "GRAVEL":
-                return BlockSoundGroup.GRAVEL;
-            case "GRASS":
-                return BlockSoundGroup.GRASS;
-            case "LILY_PAD":
-                return BlockSoundGroup.LILY_PAD;
-            case "STONE":
-                return BlockSoundGroup.STONE;
-            case "METAL":
-                return BlockSoundGroup.METAL;
-            case "GLASS":
-                return BlockSoundGroup.GLASS;
-            case "WOOL":
-                return BlockSoundGroup.WOOL;
-            case "SAND":
-                return BlockSoundGroup.SAND;
-            case "SNOW":
-                return BlockSoundGroup.SNOW;
-            case "POWDER_SNOW":
-                return BlockSoundGroup.POWDER_SNOW;
-            case "LADDER":
-                return BlockSoundGroup.LADDER;
-            case "ANVIL":
-                return BlockSoundGroup.ANVIL;
-            case "SLIME":
-                return BlockSoundGroup.SLIME;
-            case "HONEY":
-                return BlockSoundGroup.HONEY;
-            case "WET_GRASS":
-                return BlockSoundGroup.WET_GRASS;
-            case "CORAL":
-                return BlockSoundGroup.CORAL;
-            case "BAMBOO":
-                return BlockSoundGroup.BAMBOO;
-            case "BAMBOO_SAPLING":
-                return BlockSoundGroup.BAMBOO_SAPLING;
-            case "SCAFFOLDING":
-                return BlockSoundGroup.SCAFFOLDING;
-            case "SWEET_BERRY_BUSH":
-                return BlockSoundGroup.SWEET_BERRY_BUSH;
-            case "CROP":
-                return BlockSoundGroup.CROP;
-            case "STEM":
-                return BlockSoundGroup.STEM;
-            case "VINE":
-                return BlockSoundGroup.VINE;
-            case "NETHER_WART":
-                return BlockSoundGroup.NETHER_WART;
-            case "LANTERN":
-                return BlockSoundGroup.LANTERN;
-            case "NETHER_STEM":
-                return BlockSoundGroup.NETHER_STEM;
-            case "NYLIUM":
-                return BlockSoundGroup.NYLIUM;
-            case "FUNGUS":
-                return BlockSoundGroup.FUNGUS;
-            case "ROOTS":
-                return BlockSoundGroup.ROOTS;
-            case "SHROOMLIGHT":
-                return BlockSoundGroup.SHROOMLIGHT;
-            case "WEEPING_VINES":
-                return BlockSoundGroup.WEEPING_VINES;
-            case "WEEPING_VINES_LOW_PITCH":
-                return BlockSoundGroup.WEEPING_VINES_LOW_PITCH;
-            case "SOUL_SAND":
-                return BlockSoundGroup.SOUL_SAND;
-            case "SOUL_SOIL":
-                return BlockSoundGroup.SOUL_SOIL;
-            case "BASALT":
-                return BlockSoundGroup.BASALT;
-            case "WART_BLOCK":
-                return BlockSoundGroup.WART_BLOCK;
-            case "NETHERRACK":
-                return BlockSoundGroup.NETHERRACK;
-            case "NETHER_BRICKS":
-                return BlockSoundGroup.NETHER_BRICKS;
-            case "NETHER_SPROUTS":
-                return BlockSoundGroup.NETHER_SPROUTS;
-            case "NETHER_ORE":
-                return BlockSoundGroup.NETHER_ORE;
-            case "BONE":
-                return BlockSoundGroup.BONE;
-            case "NETHERITE":
-                return BlockSoundGroup.NETHERITE;
-            case "ANCIENT_DEBRIS":
-                return BlockSoundGroup.ANCIENT_DEBRIS;
-            case "LODESTONE":
-                return BlockSoundGroup.LODESTONE;
-            case "CHAIN":
-                return BlockSoundGroup.CHAIN;
-            case "NETHER_GOLD_ORE":
-                return BlockSoundGroup.NETHER_GOLD_ORE;
-            case "GILDED_BLACKSTONE":
-                return BlockSoundGroup.GILDED_BLACKSTONE;
-            case "CANDLE":
-                return BlockSoundGroup.CANDLE;
-            case "AMETHYST_BLOCK":
-                return BlockSoundGroup.AMETHYST_BLOCK;
-            case "AMETHYST_CLUSTER":
-                return BlockSoundGroup.AMETHYST_CLUSTER;
-            case "SMALL_AMETHYST_BUD":
-                return BlockSoundGroup.SMALL_AMETHYST_BUD;
-            case "MEDIUM_AMETHYST_BUD":
-                return BlockSoundGroup.MEDIUM_AMETHYST_BUD;
-            case "LARGE_AMETHYST_BUD":
-                return BlockSoundGroup.LARGE_AMETHYST_BUD;
-            case "TUFF":
-                return BlockSoundGroup.TUFF;
-            case "CALCITE":
-                return BlockSoundGroup.CALCITE;
-            case "DRIPSTONE_BLOCK":
-                return BlockSoundGroup.DRIPSTONE_BLOCK;
-            case "POINTED_DRIPSTONE":
-                return BlockSoundGroup.POINTED_DRIPSTONE;
-            case "COPPER":
-                return BlockSoundGroup.COPPER;
-            case "CAVE_VINES":
-                return BlockSoundGroup.CAVE_VINES;
-            case "SPORE_BLOSSOM":
-                return BlockSoundGroup.SPORE_BLOSSOM;
-            case "AZALEA":
-                return BlockSoundGroup.AZALEA;
-            case "FLOWERING_AZALEA":
-                return BlockSoundGroup.FLOWERING_AZALEA;
-            case "MOSS_CARPET":
-                return BlockSoundGroup.MOSS_CARPET;
-            case "PINK_PETALS":
-                return BlockSoundGroup.PINK_PETALS;
-            case "MOSS_BLOCK":
-                return BlockSoundGroup.MOSS_BLOCK;
-            case "BIG_DRIPLEAF":
-                return BlockSoundGroup.BIG_DRIPLEAF;
-            case "SMALL_DRIPLEAF":
-                return BlockSoundGroup.SMALL_DRIPLEAF;
-            case "ROOTED_DIRT":
-                return BlockSoundGroup.ROOTED_DIRT;
-            case "HANGING_ROOTS":
-                return BlockSoundGroup.HANGING_ROOTS;
-            case "AZALEA_LEAVES":
-                return BlockSoundGroup.AZALEA_LEAVES;
-            case "SCULK_SENSOR":
-                return BlockSoundGroup.SCULK_SENSOR;
-            case "SCULK_CATALYST":
-                return BlockSoundGroup.SCULK_CATALYST;
-            case "SCULK":
-                return BlockSoundGroup.SCULK;
-            case "SCULK_VEIN":
-                return BlockSoundGroup.SCULK_VEIN;
-            case "SCULK_SHRIEKER":
-                return BlockSoundGroup.SCULK_SHRIEKER;
-            case "GLOW_LICHEN":
-                return BlockSoundGroup.GLOW_LICHEN;
-            case "DEEPSLATE":
-                return BlockSoundGroup.DEEPSLATE;
-            case "DEEPSLATE_BRICKS":
-                return BlockSoundGroup.DEEPSLATE_BRICKS;
-            case "DEEPSLATE_TILES":
-                return BlockSoundGroup.DEEPSLATE_TILES;
-            case "POLISHED_DEEPSLATE":
-                return BlockSoundGroup.POLISHED_DEEPSLATE;
-            case "FROGLIGHT":
-                return BlockSoundGroup.FROGLIGHT;
-            case "FROGSPAWN":
-                return BlockSoundGroup.FROGSPAWN;
-            case "MANGROVE_ROOTS":
-                return BlockSoundGroup.MANGROVE_ROOTS;
-            case "MUDDY_MANGROVE_ROOTS":
-                return BlockSoundGroup.MUDDY_MANGROVE_ROOTS;
-            case "MUD":
-                return BlockSoundGroup.MUD;
-            case "MUD_BRICKS":
-                return BlockSoundGroup.MUD_BRICKS;
-            case "PACKED_MUD":
-                return BlockSoundGroup.PACKED_MUD;
-            case "HANGING_SIGN":
-                return BlockSoundGroup.HANGING_SIGN;
-            case "NETHER_WOOD_HANGING_SIGN":
-                return BlockSoundGroup.NETHER_WOOD_HANGING_SIGN;
-            case "BAMBOO_WOOD_HANGING_SIGN":
-                return BlockSoundGroup.BAMBOO_WOOD_HANGING_SIGN;
-            case "BAMBOO_WOOD":
-                return BlockSoundGroup.BAMBOO_WOOD;
-            case "NETHER_WOOD":
-                return BlockSoundGroup.NETHER_WOOD;
-            case "CHERRY_WOOD":
-                return BlockSoundGroup.CHERRY_WOOD;
-            case "CHERRY_SAPLING":
-                return BlockSoundGroup.CHERRY_SAPLING;
-            case "CHERRY_LEAVES":
-                return BlockSoundGroup.CHERRY_LEAVES;
-            case "CHERRY_WOOD_HANGING_SIGN":
-                return BlockSoundGroup.CHERRY_WOOD_HANGING_SIGN;
-            case "CHISELED_BOOKSHELF":
-                return BlockSoundGroup.CHISELED_BOOKSHELF;
-            case "SUSPICIOUS_SAND":
-                return BlockSoundGroup.SUSPICIOUS_SAND;
-            case "SUSPICIOUS_GRAVEL":
-                return BlockSoundGroup.SUSPICIOUS_GRAVEL;
-            case "DECORATED_POT":
-                return BlockSoundGroup.DECORATED_POT;
-            case "DECORATED_POT_SHATTER":
-                return BlockSoundGroup.DECORATED_POT_SHATTER;
-            default:
+        return switch (s.toUpperCase()) {
+            case "INTENTIONALLY_EMPTY" -> BlockSoundGroup.INTENTIONALLY_EMPTY;
+            case "WOOD" -> BlockSoundGroup.WOOD;
+            case "GRAVEL" -> BlockSoundGroup.GRAVEL;
+            case "GRASS" -> BlockSoundGroup.GRASS;
+            case "LILY_PAD" -> BlockSoundGroup.LILY_PAD;
+            case "STONE" -> BlockSoundGroup.STONE;
+            case "METAL" -> BlockSoundGroup.METAL;
+            case "GLASS" -> BlockSoundGroup.GLASS;
+            case "WOOL" -> BlockSoundGroup.WOOL;
+            case "SAND" -> BlockSoundGroup.SAND;
+            case "SNOW" -> BlockSoundGroup.SNOW;
+            case "POWDER_SNOW" -> BlockSoundGroup.POWDER_SNOW;
+            case "LADDER" -> BlockSoundGroup.LADDER;
+            case "ANVIL" -> BlockSoundGroup.ANVIL;
+            case "SLIME" -> BlockSoundGroup.SLIME;
+            case "HONEY" -> BlockSoundGroup.HONEY;
+            case "WET_GRASS" -> BlockSoundGroup.WET_GRASS;
+            case "CORAL" -> BlockSoundGroup.CORAL;
+            case "BAMBOO" -> BlockSoundGroup.BAMBOO;
+            case "BAMBOO_SAPLING" -> BlockSoundGroup.BAMBOO_SAPLING;
+            case "SCAFFOLDING" -> BlockSoundGroup.SCAFFOLDING;
+            case "SWEET_BERRY_BUSH" -> BlockSoundGroup.SWEET_BERRY_BUSH;
+            case "CROP" -> BlockSoundGroup.CROP;
+            case "STEM" -> BlockSoundGroup.STEM;
+            case "VINE" -> BlockSoundGroup.VINE;
+            case "NETHER_WART" -> BlockSoundGroup.NETHER_WART;
+            case "LANTERN" -> BlockSoundGroup.LANTERN;
+            case "NETHER_STEM" -> BlockSoundGroup.NETHER_STEM;
+            case "NYLIUM" -> BlockSoundGroup.NYLIUM;
+            case "FUNGUS" -> BlockSoundGroup.FUNGUS;
+            case "ROOTS" -> BlockSoundGroup.ROOTS;
+            case "SHROOMLIGHT" -> BlockSoundGroup.SHROOMLIGHT;
+            case "WEEPING_VINES" -> BlockSoundGroup.WEEPING_VINES;
+            case "WEEPING_VINES_LOW_PITCH" -> BlockSoundGroup.WEEPING_VINES_LOW_PITCH;
+            case "SOUL_SAND" -> BlockSoundGroup.SOUL_SAND;
+            case "SOUL_SOIL" -> BlockSoundGroup.SOUL_SOIL;
+            case "BASALT" -> BlockSoundGroup.BASALT;
+            case "WART_BLOCK" -> BlockSoundGroup.WART_BLOCK;
+            case "NETHERRACK" -> BlockSoundGroup.NETHERRACK;
+            case "NETHER_BRICKS" -> BlockSoundGroup.NETHER_BRICKS;
+            case "NETHER_SPROUTS" -> BlockSoundGroup.NETHER_SPROUTS;
+            case "NETHER_ORE" -> BlockSoundGroup.NETHER_ORE;
+            case "BONE" -> BlockSoundGroup.BONE;
+            case "NETHERITE" -> BlockSoundGroup.NETHERITE;
+            case "ANCIENT_DEBRIS" -> BlockSoundGroup.ANCIENT_DEBRIS;
+            case "LODESTONE" -> BlockSoundGroup.LODESTONE;
+            case "CHAIN" -> BlockSoundGroup.CHAIN;
+            case "NETHER_GOLD_ORE" -> BlockSoundGroup.NETHER_GOLD_ORE;
+            case "GILDED_BLACKSTONE" -> BlockSoundGroup.GILDED_BLACKSTONE;
+            case "CANDLE" -> BlockSoundGroup.CANDLE;
+            case "AMETHYST_BLOCK" -> BlockSoundGroup.AMETHYST_BLOCK;
+            case "AMETHYST_CLUSTER" -> BlockSoundGroup.AMETHYST_CLUSTER;
+            case "SMALL_AMETHYST_BUD" -> BlockSoundGroup.SMALL_AMETHYST_BUD;
+            case "MEDIUM_AMETHYST_BUD" -> BlockSoundGroup.MEDIUM_AMETHYST_BUD;
+            case "LARGE_AMETHYST_BUD" -> BlockSoundGroup.LARGE_AMETHYST_BUD;
+            case "TUFF" -> BlockSoundGroup.TUFF;
+            case "TUFF_BRICKS" -> BlockSoundGroup.TUFF_BRICKS;
+            case "POLISHED_TUFF" -> BlockSoundGroup.POLISHED_TUFF;
+            case "CALCITE" -> BlockSoundGroup.CALCITE;
+            case "DRIPSTONE_BLOCK" -> BlockSoundGroup.DRIPSTONE_BLOCK;
+            case "POINTED_DRIPSTONE" -> BlockSoundGroup.POINTED_DRIPSTONE;
+            case "COPPER" -> BlockSoundGroup.COPPER;
+            case "COPPER_BULB" -> BlockSoundGroup.COPPER_BULB;
+            case "COPPER_GRATE" -> BlockSoundGroup.COPPER_GRATE;
+            case "CAVE_VINES" -> BlockSoundGroup.CAVE_VINES;
+            case "SPORE_BLOSSOM" -> BlockSoundGroup.SPORE_BLOSSOM;
+            case "AZALEA" -> BlockSoundGroup.AZALEA;
+            case "FLOWERING_AZALEA" -> BlockSoundGroup.FLOWERING_AZALEA;
+            case "MOSS_CARPET" -> BlockSoundGroup.MOSS_CARPET;
+            case "PINK_PETALS" -> BlockSoundGroup.PINK_PETALS;
+            case "MOSS_BLOCK" -> BlockSoundGroup.MOSS_BLOCK;
+            case "BIG_DRIPLEAF" -> BlockSoundGroup.BIG_DRIPLEAF;
+            case "SMALL_DRIPLEAF" -> BlockSoundGroup.SMALL_DRIPLEAF;
+            case "ROOTED_DIRT" -> BlockSoundGroup.ROOTED_DIRT;
+            case "HANGING_ROOTS" -> BlockSoundGroup.HANGING_ROOTS;
+            case "AZALEA_LEAVES" -> BlockSoundGroup.AZALEA_LEAVES;
+            case "SCULK_SENSOR" -> BlockSoundGroup.SCULK_SENSOR;
+            case "SCULK_CATALYST" -> BlockSoundGroup.SCULK_CATALYST;
+            case "SCULK" -> BlockSoundGroup.SCULK;
+            case "SCULK_VEIN" -> BlockSoundGroup.SCULK_VEIN;
+            case "SCULK_SHRIEKER" -> BlockSoundGroup.SCULK_SHRIEKER;
+            case "GLOW_LICHEN" -> BlockSoundGroup.GLOW_LICHEN;
+            case "DEEPSLATE" -> BlockSoundGroup.DEEPSLATE;
+            case "DEEPSLATE_BRICKS" -> BlockSoundGroup.DEEPSLATE_BRICKS;
+            case "DEEPSLATE_TILES" -> BlockSoundGroup.DEEPSLATE_TILES;
+            case "POLISHED_DEEPSLATE" -> BlockSoundGroup.POLISHED_DEEPSLATE;
+            case "FROGLIGHT" -> BlockSoundGroup.FROGLIGHT;
+            case "FROGSPAWN" -> BlockSoundGroup.FROGSPAWN;
+            case "MANGROVE_ROOTS" -> BlockSoundGroup.MANGROVE_ROOTS;
+            case "MUDDY_MANGROVE_ROOTS" -> BlockSoundGroup.MUDDY_MANGROVE_ROOTS;
+            case "MUD" -> BlockSoundGroup.MUD;
+            case "MUD_BRICKS" -> BlockSoundGroup.MUD_BRICKS;
+            case "PACKED_MUD" -> BlockSoundGroup.PACKED_MUD;
+            case "HANGING_SIGN" -> BlockSoundGroup.HANGING_SIGN;
+            case "NETHER_WOOD_HANGING_SIGN" -> BlockSoundGroup.NETHER_WOOD_HANGING_SIGN;
+            case "BAMBOO_WOOD_HANGING_SIGN" -> BlockSoundGroup.BAMBOO_WOOD_HANGING_SIGN;
+            case "BAMBOO_WOOD" -> BlockSoundGroup.BAMBOO_WOOD;
+            case "NETHER_WOOD" -> BlockSoundGroup.NETHER_WOOD;
+            case "CHERRY_WOOD" -> BlockSoundGroup.CHERRY_WOOD;
+            case "CHERRY_SAPLING" -> BlockSoundGroup.CHERRY_SAPLING;
+            case "CHERRY_LEAVES" -> BlockSoundGroup.CHERRY_LEAVES;
+            case "CHERRY_WOOD_HANGING_SIGN" -> BlockSoundGroup.CHERRY_WOOD_HANGING_SIGN;
+            case "CHISELED_BOOKSHELF" -> BlockSoundGroup.CHISELED_BOOKSHELF;
+            case "SUSPICIOUS_SAND" -> BlockSoundGroup.SUSPICIOUS_SAND;
+            case "SUSPICIOUS_GRAVEL" -> BlockSoundGroup.SUSPICIOUS_GRAVEL;
+            case "DECORATED_POT" -> BlockSoundGroup.DECORATED_POT;
+            case "DECORATED_POT_SHATTER" -> BlockSoundGroup.DECORATED_POT_SHATTER;
+            case "TRIAL_SPAWNER" -> BlockSoundGroup.TRIAL_SPAWNER;
+            case "SPONGE" -> BlockSoundGroup.SPONGE;
+            case "WET_SPONGE" -> BlockSoundGroup.WET_SPONGE;
+            case "VAULT" -> BlockSoundGroup.VAULT;
+            case "HEAVY_CORE" -> BlockSoundGroup.HEAVY_CORE;
+            case "COBWEB" -> BlockSoundGroup.COBWEB;
+            default -> {
                 log(Level.WARN, "Sound group " + s + " not found, using stone");
-                return BlockSoundGroup.STONE;
+                yield BlockSoundGroup.STONE;
             }
+        };
     }
 
 

src/main/java/quimufu/simple_creator/BlockSettingsPojo.java

@@ -10,7 +10,7 @@ public class BlockSettingsPojo {
     public float explosionResistance = 6.0F;
     public float hardness = 1.5F;
     public float slipperiness = 0.6F;
-    public float slowDownMultiplier = 1.0F;
+    public float movementVelocityMultiplier = 1.0F;
     public float jumpVelocityMultiplier = 1.0F;
     public boolean opaque = true;
     public boolean allowsSpawning = true;

src/main/java/quimufu/simple_creator/GenericManualResourceLoader.java

@@ -88,7 +88,7 @@ public abstract class GenericManualResourceLoader<T> {
                         continue;
                     }
                     String entryName = blockJsonName.substring(0,blockJsonName.length()-5);
-                    Identifier identifier = new Identifier(modId, entryName);
+                    Identifier identifier = Identifier.of(modId, entryName);
 
                     try (Reader reader = new FileReader(entryJson)) {
                         JsonObject jsonObject = gson.fromJson(reader, JsonObject.class);

src/main/java/quimufu/simple_creator/ItemResourceLoader.java

@@ -3,15 +3,16 @@ package quimufu.simple_creator;
 import com.google.common.collect.Maps;
 import com.google.gson.*;
 import net.fabricmc.fabric.api.itemgroup.v1.ItemGroupEvents;
+import net.minecraft.component.type.FoodComponent;
 import net.minecraft.entity.effect.StatusEffect;
 import net.minecraft.entity.effect.StatusEffectInstance;
-import net.minecraft.item.FoodComponent;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemGroup;
 import net.minecraft.item.ItemGroups;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.JsonHelper;
 import net.minecraft.util.Pair;
@@ -86,12 +87,10 @@ public class ItemResourceLoader extends GenericManualResourceLoader<Item> {
     private static FoodComponent deserializeFoodComponent(JsonObject jo) {
         FoodComponent fc;
         FoodComponent.Builder fcb = new FoodComponent.Builder();
-        fcb.hunger(JsonHelper.getInt(jo, "hunger", 4));
+        fcb.nutrition(JsonHelper.getInt(jo, "hunger", 4));
         fcb.saturationModifier(JsonHelper.getFloat(jo, "saturationModifier", 0.3F));
         if (JsonHelper.getBoolean(jo, "isAlwaysEdible", false))
             fcb.alwaysEdible();
-        if (JsonHelper.getBoolean(jo, "isWolfFood", false))
-            fcb.meat();
         if (JsonHelper.getBoolean(jo, "isFast", false))
             fcb.snack();
         if (JsonHelper.hasArray(jo, "effects")) {
@@ -104,7 +103,7 @@ public class ItemResourceLoader extends GenericManualResourceLoader<Item> {
 
     private static void deserializeEffects(FoodComponent.Builder fcb, JsonArray ja) {
         for (JsonElement e : ja) {
-            StatusEffect type;
+            RegistryEntry<StatusEffect> type;
             int duration = 0;
             int amplifier = 0;
             boolean ambient = false;
@@ -114,9 +113,9 @@ public class ItemResourceLoader extends GenericManualResourceLoader<Item> {
             String effect = JsonHelper.getString(jo, "effect");
             Identifier ei = Identifier.tryParse(effect);
             if (ei != null) {
-                StatusEffect se = Registries.STATUS_EFFECT.get(ei);
-                if (se != null) {
-                    type = se;
+                Optional<RegistryEntry.Reference<StatusEffect>> se = Registries.STATUS_EFFECT.getEntry(ei);
+                if (se.isPresent()) {
+                    type = se.get();
                 } else {
                     log(Level.WARN, "Effect " + ei + " not found, skipping");
                     continue;
@@ -136,7 +135,7 @@ public class ItemResourceLoader extends GenericManualResourceLoader<Item> {
 
     private static Rarity findRarity(String filter) {
         for (Rarity r : Rarity.values()) {
-            if (r.name().toLowerCase().equals(filter.toLowerCase()))
+            if (r.name().equalsIgnoreCase(filter))
                 return r;
         }
         log(Level.WARN, "Rarity " + filter + " not found, using common");

src/main/java/quimufu/simple_creator/SimpleCreatorConfig.java

@@ -1,19 +1,12 @@
 package quimufu.simple_creator;
 
-import com.google.common.base.CaseFormat;
-import de.siphalor.tweed4.annotated.AConfigEntry;
-import de.siphalor.tweed4.annotated.ATweedConfig;
-import de.siphalor.tweed4.config.ConfigEnvironment;
-import de.siphalor.tweed4.config.ConfigScope;
+import eu.midnightdust.lib.config.MidnightConfig;
 
+public class SimpleCreatorConfig extends MidnightConfig {
 
-@ATweedConfig(serializer = "tweed4:hjson", scope = ConfigScope.GAME, environment = ConfigEnvironment.UNIVERSAL, tailors = {"tweed4:lang_json_descriptions", "tweed4:coat", "tweed4:json_schema"}, casing = CaseFormat.LOWER_HYPHEN)
-//@ClothData(modid = "tweed4_testmod")
-public class SimpleCreatorConfig {
+    @Comment(category = "text")
+    public static Comment explanation;
 
-	@AConfigEntry(name = "enableTestThings", comment = "Enables included test Blocks and Items")
+    @Entry(category = "text", name = "Enables included test Blocks and Items")
     public static boolean enableTestThings = false;
-
-
-    public static boolean extendedLogging = false;
 }

src/main/java/quimufu/simple_creator/SimpleCreatorMod.java

@@ -1,9 +1,6 @@
 package quimufu.simple_creator;
 
-import de.siphalor.tweed4.Tweed;
-import de.siphalor.tweed4.config.ConfigEnvironment;
-import de.siphalor.tweed4.config.ConfigLoader;
-import de.siphalor.tweed4.config.TweedRegistry;
+import eu.midnightdust.lib.config.MidnightConfig;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.loader.api.FabricLoader;
@@ -28,15 +25,12 @@ public class SimpleCreatorMod implements ModInitializer {
 
     @Override
     public void onInitialize() {
-        log(Level.INFO, "Initializing");
-        Tweed.runEntryPoints();
+        log(Level.INFO, "Simply creating Blocks and Items");
+        MidnightConfig.init(MOD_ID, SimpleCreatorConfig.class);
 
-        ConfigLoader.initialReload(
-                TweedRegistry.getConfigFile(MOD_ID),
-                FabricLoader.getInstance().getEnvironmentType() == EnvType.SERVER ? ConfigEnvironment.SERVER : ConfigEnvironment.UNIVERSAL
-        );
         irl.load();
         brl.load();
+        log(Level.INFO, "Simply created!");
     }
 
     public static void log(Level level, String message) {

src/main/java/quimufu/simple_creator/SimpleCreatorModClient.java

@@ -20,70 +20,43 @@ public class SimpleCreatorModClient implements ClientModInitializer {
     }
 
     private net.minecraft.client.render.RenderLayer getRenderLayer(String renderLayer) {
-        switch (renderLayer.toUpperCase()){
-            case "SOLID":
-                return RenderLayer.getSolid();
-            case "CUTOUT_MIPPED":
-                return RenderLayer.getCutoutMipped();
-            case "CUTOUT":
-                return RenderLayer.getCutout();
-            case "TRANSLUCENT":
-                return RenderLayer.getTranslucent();
-            case "TRANSLUCENT_MOVING_BLOCK":
-                return RenderLayer.getTranslucentMovingBlock();
-            case "TRANSLUCENT_NO_CRUMBLING":
-                return RenderLayer.getTranslucentNoCrumbling();
-            case "LEASH":
-                return RenderLayer.getLeash();
-            case "WATER_MASK":
-                return RenderLayer.getWaterMask();
-            case "ARMOR_GLINT":
-                return RenderLayer.getArmorGlint();
-            case "ARMOR_ENTITY_GLINT":
-                return RenderLayer.getArmorEntityGlint();
-            case "GLINT_TRANSLUCENT":
-                return RenderLayer.getGlintTranslucent();
-            case "GLINT":
-                return RenderLayer.getGlint();
-            case "DIRECT_GLINT":
-                return RenderLayer.getDirectGlint();
-            case "ENTITY_GLINT":
-                return RenderLayer.getEntityGlint();
-            case "DIRECT_ENTITY_GLINT":
-                return RenderLayer.getDirectEntityGlint();
-            case "TEXT_BACKGROUND":
-                return RenderLayer.getTextBackground();
-            case "TEXT_BACKGROUND_SEE_THROUGH":
-                return RenderLayer.getTextBackgroundSeeThrough();
-            case "LIGHTNING":
-                return RenderLayer.getLightning();
-            case "TRIPWIRE":
-                return RenderLayer.getTripwire();
-            case "END_PORTAL":
-                return RenderLayer.getEndPortal();
-            case "END_GATEWAY":
-                return RenderLayer.getEndGateway();
-            case "LINES":
-                return RenderLayer.getLines();
-            case "LINE_STRIP":
-                return RenderLayer.getLineStrip();
-            case "DEBUG_FILLED_BOX":
-                return RenderLayer.getDebugFilledBox();
-            case "DEBUG_QUADS":
-                return RenderLayer.getDebugQuads();
-            case "DEBUG_SECTION_QUADS":
-                return RenderLayer.getDebugSectionQuads();
-            case "GUI":
-                return RenderLayer.getGui();
-            case "GUI_OVERLAY":
-                return RenderLayer.getGuiOverlay();
-            case "GUI_TEXT_HIGHLIGHT":
-                return RenderLayer.getGuiTextHighlight();
-            case "GUI_GHOST_RECIPE_OVERLAY":
-                return RenderLayer.getGuiGhostRecipeOverlay();
-            default:
+        return switch (renderLayer.toUpperCase()) {
+            case "SOLID" -> RenderLayer.getSolid();
+            case "CUTOUT_MIPPED" -> RenderLayer.getCutoutMipped();
+            case "CUTOUT" -> RenderLayer.getCutout();
+            case "TRANSLUCENT" -> RenderLayer.getTranslucent();
+            case "TRANSLUCENT_MOVING_BLOCK" -> RenderLayer.getTranslucentMovingBlock();
+            case "LEASH" -> RenderLayer.getLeash();
+            case "WATER_MASK" -> RenderLayer.getWaterMask();
+            case "ARMOR_ENTITY_GLINT" -> RenderLayer.getArmorEntityGlint();
+            case "GLINT_TRANSLUCENT" -> RenderLayer.getGlintTranslucent();
+            case "GLINT" -> RenderLayer.getGlint();
+            case "ENTITY_GLINT" -> RenderLayer.getEntityGlint();
+            case "DIRECT_ENTITY_GLINT" -> RenderLayer.getDirectEntityGlint();
+            case "TEXT_BACKGROUND" -> RenderLayer.getTextBackground();
+            case "TEXT_BACKGROUND_SEE_THROUGH" -> RenderLayer.getTextBackgroundSeeThrough();
+            case "LIGHTNING" -> RenderLayer.getLightning();
+            case "DRAGON_RAYS" -> RenderLayer.getDragonRays();
+            case "DRAGON_RAYS_DEPTH" -> RenderLayer.getDragonRaysDepth();
+            case "TRIPWIRE" -> RenderLayer.getTripwire();
+            case "END_PORTAL" -> RenderLayer.getEndPortal();
+            case "END_GATEWAY" -> RenderLayer.getEndGateway();
+            case "FAST_CLOUDS" -> RenderLayer.getFastClouds();
+            case "FANCY_CLOUDS" -> RenderLayer.getFancyClouds();
+            case "LINES" -> RenderLayer.getLines();
+            case "LINE_STRIP" -> RenderLayer.getLineStrip();
+            case "DEBUG_FILLED_BOX" -> RenderLayer.getDebugFilledBox();
+            case "DEBUG_QUADS" -> RenderLayer.getDebugQuads();
+            case "DEBUG_STRUCTURE_QUADS" -> RenderLayer.getDebugStructureQuads();
+            case "DEBUG_SECTION_QUADS" -> RenderLayer.getDebugSectionQuads();
+            case "GUI" -> RenderLayer.getGui();
+            case "GUI_OVERLAY" -> RenderLayer.getGuiOverlay();
+            case "GUI_TEXT_HIGHLIGHT" -> RenderLayer.getGuiTextHighlight();
+            case "GUI_GHOST_RECIPE_OVERLAY" -> RenderLayer.getGuiGhostRecipeOverlay();
+            default -> {
                 SimpleCreatorMod.log(Level.INFO, "Could not find renderLayer " + renderLayer + " using solid");
-                return RenderLayer.getSolid();
-        }
+                yield RenderLayer.getSolid();
+            }
+        };
     }
 }

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

@@ -1,6 +1,6 @@
 {
-  "text.autoconfig.simple_creator.title": "Simple Item/Block Creator Settings",
-  "text.autoconfig.simple_creator.option.enableTestThings": "Enable a test item and block",
+  "simple_creator.midnightconfig.title": "Simple Item/Block Creator Settings",
+  "simple_creator.midnightconfig.enableTestThings": "Enable a test item and block",
   "item.simple_creator.test_item": "Forbidden Fruit",
   "block.simple_creator.test_block": "Fast jumpy wooly diamond-dropping block of Eternal Fire"
 }

src/main/resources/data/simple_creator/blocks/test_block.json

@@ -9,7 +9,7 @@
   "explosionResistance": 5.0,
   "hardness": 0.5,
   "slipperiness": 0.6,
-  "slowDownMultiplier": 2.0,
+  "movementVelocityMultiplier": 2.0,
   "jumpVelocityMultiplier": 2.0,
   "opaque": true,
   "itemGroup": "minecraft:building_blocks",