Update README.md

Particles can no longer spawn under the world.
Particles no longer spawn in blocks, instead spawning in air.
Fixed bug present since 1.2.0, which meant particle amount was dependant on blocks around player.
New particle multiplier allowing greater control of particle amount.
New F3 screen text, allows user to debug particle amount.
Removed upper and lower limit buttons.

.github/workflows/build-release.yml

@@ -33,29 +33,10 @@ jobs:
         run: ./gradlew build --stacktrace
 
       - name: Upload artifacts to Modrinth, Curseforge and GitHub
-        uses: Kir-Antipov/mc-publish@v2.0
+        uses: Kir-Antipov/mc-publish@v3.3
         with:
           modrinth-id: jawg7zT1
           modrinth-token: ${{ secrets.MODRINTH_TOKEN }}
 
           curseforge-id: 594750
           curseforge-token: ${{ secrets.CURSEFORGE_TOKEN }}
-
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
-          files: build/libs/!(*-@(dev|sources|all)).jar
-
-          version-type: release
-
-          loaders: fabric
-
-          java: 17
-
-          dependencies: |
-           fabric | depends | 0.46.0
-           P7dR8mSH | depends | 0.46.0
-           kirin | includes | 1.10.0-beta.2
-           modmenu | recommends | *
-           mOgUt4GM | recommends | *
-           
-          version-resolver: latest # Defaults to selecting the latest compatible version of Minecraft, using the tag from the fabric.mod.json

.gitignore

@@ -31,3 +31,4 @@ bin/
 # fabric
 
 run/
+BackupSrc/

README.md

@@ -6,7 +6,7 @@ I'm glad you asked! It's just a mod that adds the white ash particle from the Ba
 
 Now to the nitty gritty:
 It works by checking if the player has the sky above them while being below sea level and then scales the amount of particles based on depth.
-<br><br>It has a config system that you can access using Mod Menu, most things you can change in-game, but to change the particle you'll need to open the config file manually :) 
+<br><br>It has a config system that you can access using Mod Menu.
 <br>
 ## Dependencies
 Cave Dust requires the [Fabric API](https://www.curseforge.com/minecraft/mc-mods/fabric-api) but everything else Cave Dust *needs* is included.

build.gradle

@@ -1,5 +1,5 @@
 plugins {
-	id 'fabric-loom' version '0.11-SNAPSHOT'
+	id 'fabric-loom' version '1.2-SNAPSHOT'
 	id 'maven-publish'
 }
 

gradle.properties

@@ -3,18 +3,17 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 	# check these on https://fabricmc.net/develop
-	minecraft_version=1.18.1
-	yarn_mappings=1.18.1+build.22
-	loader_version=0.12.11
+	minecraft_version=1.19.3
+	yarn_mappings=1.19.3+build.5
+	loader_version=0.14.13
 
 # Mod Properties
-	mod_version = 1.2.0
+	mod_version = 1.4.0
 	maven_group = com.lizistired
 	archives_base_name = cave_dust
 
 # Dependencies
-	fabric_version=0.46.4+1.18
-    clothconfig_version = 6.1.48
-	modmenu_version = 3.0.1
-	minelp_version=4.4.0-beta.2
-	kirin_version=1.10.0-beta.2
+	fabric_version=0.72.0+1.19.3
+    clothconfig_version =9.0.94
+	modmenu_version =5.1.0-beta.3
+	kirin_version=1.13.2

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -32,10 +32,10 @@
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:
 #         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
 #
 #   Important for patching:
 #

src/main/java/net/lizistired/cavedust/CaveDust.java

@@ -1,11 +1,11 @@
 package net.lizistired.cavedust;
 
 //minecraft imports
-import net.lizistired.cavedust.mixin.ClientWorldAccessor;
+import net.minecraft.block.Blocks;
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.particle.ParticleTypes;
+import net.minecraft.registry.Registries;
 import net.minecraft.text.Text;
-import net.minecraft.text.TranslatableText;
-import net.minecraft.util.Util;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 //other imports
@@ -25,7 +25,7 @@ import static net.lizistired.cavedust.utils.KeybindingHelper.*;
 
 public class CaveDust implements ClientModInitializer {
 	//logger
-	public static final Logger LOGGER = LoggerFactory.getLogger("caveDust");
+	public static final Logger LOGGER = LoggerFactory.getLogger("cavedust");
 	//make class static
 	private static CaveDust instance;
 	public static CaveDust getInstance() {
@@ -35,11 +35,14 @@ public class CaveDust implements ClientModInitializer {
 		instance = this;
 	}
 	//config assignment
-	private static CaveDustConfig config;
-	public CaveDustConfig getConfig() {
+	private static net.lizistired.cavedust.CaveDustConfig config;
+	public net.lizistired.cavedust.CaveDustConfig getConfig() {
 		return config;
 	}
 
+	public static int WHITE_ASH_ID = Registries.PARTICLE_TYPE.getRawId(ParticleTypes.WHITE_ASH);
+	public static int PARTICLE_AMOUNT = 0;
+
 
 	@Override
 	public void onInitializeClient() {
@@ -57,12 +60,12 @@ public class CaveDust implements ClientModInitializer {
 		if (keyBinding1.wasPressed()){
 			getConfig().toggleCaveDust();
 			LOGGER.info("Toggled dust");
-			client.player.sendSystemMessage(new TranslatableText("debug.cavedust.toggle." + config.getCaveDustEnabled()), Util.NIL_UUID);
+			client.player.sendMessage(Text.translatable("debug.cavedust.toggle." + config.getCaveDustEnabled()), false);
 		}
 		if (keyBinding2.wasPressed()){
 			getConfig().load();
 			LOGGER.info("Reloaded config");
-			client.player.sendSystemMessage(new TranslatableText("debug.cavedust.reload"), Util.NIL_UUID);
+			client.player.sendMessage(Text.translatable("debug.cavedust.reload"), false);
 		}
 
 		//ensure world is not null
@@ -71,22 +74,24 @@ public class CaveDust implements ClientModInitializer {
 		//LOGGER.info(String.valueOf(((ClientWorldAccessor) client.world.getLevelProperties()).getFlatWorld()));
 		// )
 		double probabilityNormalized = normalize(config.getLowerLimit(), config.getUpperLimit(), client.player.getBlockY());
+		PARTICLE_AMOUNT = (int) (probabilityNormalized * config.getParticleMultiplier() * config.getParticleMultiplierMultiplier());
 
-		for (int i = 0; i < probabilityNormalized * config.getParticleMultiplier() * 10; i++) {
+		for (int i = 0; i < PARTICLE_AMOUNT; i++) {
 			try {
-				double x = client.player.getPos().getX() + generateRandomDouble(config.getDimensionsMinX(), config.getDimensionsMaxX());
-				double y = client.player.getPos().getY() + generateRandomDouble(config.getDimensionsMinX(), config.getDimensionsMaxY());
-				double z = client.player.getPos().getZ() + generateRandomDouble(config.getDimensionsMinX(), config.getDimensionsMaxZ());
+				double x = client.player.getPos().getX() + generateRandomDouble(config.getDimensionsX() * -1, config.getDimensionsX());
+				double y = client.player.getPos().getY() + generateRandomDouble(config.getDimensionsY() * -1, config.getDimensionsY());
+				double z = client.player.getPos().getZ() + generateRandomDouble(config.getDimensionsZ() * -1, config.getDimensionsZ());
 				BlockPos particlePos = new BlockPos(x, y, z);
 
-				if (!shouldParticlesSpawn(client, config, particlePos)){return;}
-
-
+				if (shouldParticlesSpawn(client, config, particlePos)) {
+					if (client.world.getBlockState(particlePos).isAir()) {
 						world.addParticle(config.getParticle(), x, y, z, config.getVelocityRandomnessRandom(), config.getVelocityRandomnessRandom(), config.getVelocityRandomnessRandom());
 					}
+				}
+			}
 			catch (NullPointerException e) {
 				LOGGER.error(String.valueOf(e));
-				getConfig().setParticle("minecraft:white_ash");
+				getConfig().setParticleID(WHITE_ASH_ID);
 			}
 		}
 	}

src/main/java/net/lizistired/cavedust/CaveDustConfig.java

@@ -1,111 +1,76 @@
 package net.lizistired.cavedust;
 
 import net.lizistired.cavedust.utils.JsonFile;
+import net.minecraft.client.MinecraftClient;
 import net.minecraft.particle.ParticleEffect;
 import net.minecraft.particle.ParticleTypes;
+import net.minecraft.registry.Registries;
+import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
-import net.minecraft.util.registry.Registry;
 import static net.lizistired.cavedust.CaveDust.*;
 import static net.lizistired.cavedust.utils.MathHelper.*;
 
 import java.nio.file.Path;
 
 public class CaveDustConfig extends JsonFile {
-    private transient final CaveDust CaveDust;
+    private transient final net.lizistired.cavedust.CaveDust CaveDust;
 
 
-    private int dimensionMaxX = 5;
-    private int dimensionMaxY = 5;
-    private int dimensionMaxZ = 5;
-    private int dimensionMinX = -5;
-    private int dimensionMinY = -5;
-    private int dimensionMinZ = -5;
+    private int dimensionX = 5;
+    private int dimensionY = 5;
+    private int dimensionZ = 5;
     private int velocityRandomness = 1;
 
     private boolean caveDustEnabled = true;
-    private String particleName = "white_ash";
     private boolean seaLevelCheck = true;
     private boolean superFlatStatus = false;
-    //private boolean enhancedDetection = true;
     private float upperLimit = 64;
     private float lowerLimit = -64;
     private int particleMultiplier = 1;
 
-    public CaveDustConfig(Path file, CaveDust caveDust) {
+    private int particleMultiplierMultiplier = 10;
+
+    private int particleID = WHITE_ASH_ID;
+
+    public CaveDustConfig(Path file, net.lizistired.cavedust.CaveDust caveDust) {
         super(file);
         this.CaveDust = caveDust;
     }
 
-    public float setDimensionsMinX(float size){
-        if (this.dimensionMinX != size) {
-            this.dimensionMinX = (int)size;
+    public float setDimensionsX(float size){
+        if (this.dimensionX != size) {
+            this.dimensionX = (int)size;
             save();
         }
-        return getDimensionsMinX();
+        return getDimensionsX();
     }
 
-    public float setDimensionsMinY(float size){
-        if (this.dimensionMinY != size) {
-            this.dimensionMinY = (int)size;
+    public float setDimensionsY(float size){
+        if (this.dimensionY != size) {
+            this.dimensionY = (int)size;
             save();
         }
-        return getDimensionsMinY();
+        return getDimensionsY();
     }
 
-    public float setDimensionsMinZ(float size){
-        if (this.dimensionMinZ != size) {
-            this.dimensionMinZ = (int)size;
+    public float setDimensionsZ(float size){
+        if (this.dimensionZ != size) {
+            this.dimensionZ = (int)size;
             save();
         }
-        return getDimensionsMinZ();
+        return getDimensionsZ();
     }
 
-    public float getDimensionsMinX(){
-        return dimensionMinX;
+    public float getDimensionsX(){
+        return dimensionX;
     }
 
-    public float getDimensionsMinY(){
-        return dimensionMinY;
+    public float getDimensionsY(){
+        return dimensionY;
     }
 
-    public float getDimensionsMinZ(){
-        return dimensionMinZ;
-    }
-
-    public float setDimensionsMaxX(float size){
-        if (this.dimensionMaxX != size) {
-            this.dimensionMaxX = (int)size;
-            save();
-        }
-        return getDimensionsMaxX();
-    }
-
-    public float setDimensionsMaxY(float size){
-        if (this.dimensionMaxY != size) {
-            this.dimensionMaxY = (int)size;
-            save();
-        }
-        return getDimensionsMaxY();
-    }
-
-    public float setDimensionsMaxZ(float size){
-        if (this.dimensionMaxZ != size) {
-            this.dimensionMaxZ = (int)size;
-            save();
-        }
-        return getDimensionsMaxZ();
-    }
-
-    public float getDimensionsMaxX(){
-        return dimensionMaxX;
-    }
-
-    public float getDimensionsMaxY(){
-        return dimensionMaxY;
-    }
-
-    public float getDimensionsMaxZ(){
-        return dimensionMaxZ;
+    public float getDimensionsZ(){
+        return dimensionZ;
     }
 
     public float setUpperLimit(float upperLimit){
@@ -150,6 +115,16 @@ public class CaveDustConfig extends JsonFile {
         return getParticleMultiplier();
     }
 
+    public int getParticleMultiplierMultiplier(){
+        return particleMultiplierMultiplier;
+    }
+
+    public float setParticleMultiplierMultiplier(float particleMultiplierMultiplier){
+        this.particleMultiplierMultiplier = (int) particleMultiplierMultiplier;
+        save();
+        return getParticleMultiplierMultiplier();
+    }
+
     public boolean toggleCaveDust(){
         caveDustEnabled = !caveDustEnabled;
         save();
@@ -161,17 +136,17 @@ public class CaveDustConfig extends JsonFile {
     }
 
     public ParticleEffect setParticle(String particleType){
-        particleName = particleType;
+        //particleName = particleType;
         save();
         return getParticle();
     }
 
     public ParticleEffect getParticle(){
         try {
-            return (ParticleEffect) Registry.PARTICLE_TYPE.get(new Identifier(particleName.toLowerCase()));
+            return (ParticleEffect) Registries.PARTICLE_TYPE.get(new Identifier(Registries.PARTICLE_TYPE.getEntry(getParticleID()).get().getKey().get().getValue().toString().toLowerCase()));
         } catch (ClassCastException e) {
-            LOGGER.error(e + "\nThere was an error loading the specified particle from the config, make sure a valid particle name is specified. Falling back to \"minecraft:white_ash\".");
-            particleName = "minecraft:white_ash";
+            MinecraftClient.getInstance().player.sendMessage(Text.literal("Issue loading particle, defaulting to white ash particle!"), false);
+            setParticleID(WHITE_ASH_ID);
             save();
             return ParticleTypes.WHITE_ASH;
         }
@@ -212,33 +187,42 @@ public class CaveDustConfig extends JsonFile {
         return getSuperFlatStatus();
     }
 
-    /*public boolean getEnhancedDetection(){
-        return enhancedDetection;
+    public void iterateParticle(){
+        if(getParticleID() > Registries.PARTICLE_TYPE.size() - 2) {
+            particleID = 1;
+            save();
+        } else {
+            particleID = getParticleID() + 1;
+            save();
+        }
     }
 
-    public boolean setEnhancedDetection(){
-        enhancedDetection = !enhancedDetection;
+    public void setParticleID(int particleID){
+        this.particleID = particleID;
         save();
-        return getEnhancedDetection();
-    }*/
+    }
+
+    public int getParticleID(){
+        if ((!Registries.PARTICLE_TYPE.getEntry(particleID).isPresent())) {
+            setParticleID(WHITE_ASH_ID);
+        }
+        return particleID;
+    }
 
     public void resetConfig(){
-        dimensionMinX = -5;
-        dimensionMinY = -5;
-        dimensionMinZ = -5;
-
-        dimensionMaxX = 5;
-        dimensionMaxY = 5;
-        dimensionMaxZ = 5;
+        dimensionX = 5;
+        dimensionY = 5;
+        dimensionZ = 5;
 
         upperLimit = 64;
         lowerLimit = -64;
 
         particleMultiplier = 1;
+        particleMultiplierMultiplier = 10;
 
         seaLevelCheck = true;
         caveDustEnabled = true;
-        particleName = "minecraft:white_ash";
+        particleID = WHITE_ASH_ID;
         save();
     }
 }

src/main/java/net/lizistired/cavedust/ModMenuConfigScreen.java

@@ -5,13 +5,14 @@ import com.minelittlepony.common.client.gui.element.*;
 import net.lizistired.cavedust.utils.TranslatableTextHelper;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.text.TranslatableText;
-
-import javax.annotation.Nullable;
+import net.minecraft.particle.ParticleEffect;
+import net.minecraft.registry.Registries;
+import net.minecraft.text.Text;
+import org.jetbrains.annotations.Nullable;
 
 public class ModMenuConfigScreen extends GameGui {
     public ModMenuConfigScreen(@Nullable Screen parent) {
-        super(new TranslatableText("menu.cavedust.title"), parent);
+        super(Text.translatable("menu.cavedust.title"), parent);
     }
 
     @Override
@@ -20,89 +21,87 @@ public class ModMenuConfigScreen extends GameGui {
         int row = height / 4 + 14;
 
         CaveDustConfig config = CaveDust.getInstance().getConfig();
-        TranslatableTextHelper transText = new TranslatableTextHelper();
+        TranslatableTextHelper transText = new TranslatableTextHelper();;
         config.load();
 
         addButton(new Label(width / 2, 30)).setCentered().getStyle()
                 .setText(getTitle());
 
-        addButton(new Button(left, row += -60).onClick(sender -> {
-            sender.getStyle().setText("menu.cavedust.global." + config.toggleCaveDust()).setTooltip(new TranslatableText("menu.cavedust.global.tooltip." + config.getCaveDustEnabled()));
+        addButton(new Button(left += -110, row += -60).onClick(sender -> {
+            sender.getStyle().setText("menu.cavedust.global." + config.toggleCaveDust()).setTooltip(Text.translatable("menu.cavedust.global.tooltip." + config.getCaveDustEnabled()));
         })).getStyle()
                 .setText("menu.cavedust.global." + config.getCaveDustEnabled())
-                .setTooltip(new TranslatableText("menu.cavedust.global.tooltip." + config.getCaveDustEnabled()));
+                .setTooltip(Text.translatable("menu.cavedust.global.tooltip." + config.getCaveDustEnabled()));
 
         /*addButton(new Button(left, row += 24).onClick(sender -> {
-            sender.getStyle().setText("menu.cavedust.enhanceddetection." + config.setEnhancedDetection()).setTooltip(new TranslatableText("menu.cavedust.enhanceddetection.tooltip"));
+            sender.getStyle().setText("menu.cavedust.enhanceddetection." + config.setEnhancedDetection()).setTooltip(Text.translatable("menu.cavedust.enhanceddetection.tooltip"));
         })).getStyle()
                 .setText("menu.cavedust.enhanceddetection." + config.getEnhancedDetection())
-                .setTooltip(new TranslatableText("menu.cavedust.enhanceddetection.tooltip"));*/
+                .setTooltip(Text.translatable("menu.cavedust.enhanceddetection.tooltip"));*/
 
         addButton(new Button(left, row += 24).onClick(sender -> {
-            sender.getStyle().setText("menu.cavedust.superflatstatus." + config.setSuperFlatStatus()).setTooltip(new TranslatableText("menu.cavedust.superflatstatus.tooltip"));
+            sender.getStyle().setText("menu.cavedust.superflatstatus." + config.setSuperFlatStatus()).setTooltip(Text.translatable("menu.cavedust.superflatstatus.tooltip"));
         })).getStyle()
                 .setText("menu.cavedust.superflatstatus." + config.getSuperFlatStatus())
-                .setTooltip(new TranslatableText("menu.cavedust.superflatstatus.tooltip"));
+                .setTooltip(Text.translatable("menu.cavedust.superflatstatus.tooltip"));
 
-        addButton(new Slider(left += -110, row += 24, -50, 0, config.getDimensionsMinX()))
-                .onChange(config::setDimensionsMinX)
-                .setTextFormat(transText::formatMinX)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.minX.tooltip"));
 
-        addButton(new Slider(left, row += 24, -50, 0, config.getDimensionsMinY()))
-                .onChange(config::setDimensionsMinY)
-                .setTextFormat(transText::formatMinY)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.minY.tooltip"));
 
-        addButton(new Slider(left, row += 24, -50, 0, config.getDimensionsMinZ()))
-                .onChange(config::setDimensionsMinZ)
-                .setTextFormat(transText::formatMinZ)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.minZ.tooltip"));
-
-        addButton(new Slider(left += 220, row += -48, 0, 50, config.getDimensionsMaxX()))
-                .onChange(config::setDimensionsMaxX)
-                .setTextFormat(transText::formatMaxX)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.maxX.tooltip"));
-
-        addButton(new Slider(left, row += 24, 0, 50, config.getDimensionsMaxY()))
-                .onChange(config::setDimensionsMaxY)
-                .setTextFormat(transText::formatMaxY)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.maxY.tooltip"));
-
-        addButton(new Slider(left, row += 24, 0, 50, config.getDimensionsMaxZ()))
-                .onChange(config::setDimensionsMaxZ)
-                .setTextFormat(transText::formatMaxZ)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.maxZ.tooltip"));
-
-        addButton(new Slider(left += -110, row += 24, -64, 319, config.getUpperLimit()))
+        /*addButton(new Slider(left, row += 48, -64, 319, config.getUpperLimit()))
                 .onChange(config::setUpperLimit)
                 .setTextFormat(transText::formatUpperLimit)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.upperlimit.tooltip"));
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.upperlimit.tooltip"));
 
         addButton(new Slider(left, row += 24, -64, 319, config.getLowerLimit()))
                 .onChange(config::setLowerLimit)
                 .setTextFormat(transText::formatLowerLimit)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.lowerlimit.tooltip"));
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.lowerlimit.tooltip"));*/
 
         addButton(new Slider(left, row += 24, 1, 100, config.getParticleMultiplier()))
                 .onChange(config::setParticleMultiplier)
                 .setTextFormat(transText::formatParticleMultiplier)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.particlemultiplier.tooltip"));
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.particlemultiplier.tooltip"));
+
+        addButton(new Slider(left, row += 24, 1, 100, config.getParticleMultiplierMultiplier()))
+                .onChange(config::setParticleMultiplierMultiplier)
+                .setTextFormat(transText::formatParticleMultiplierMultiplier)
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.particlemultipliermultiplier.tooltip"));
+        addButton(new Button(left, row += 24).onClick(sender ->{
+            config.iterateParticle();
+            sender.getStyle().setText("Particle: " + (getNameOfParticle()));
+        })).getStyle().setText("Particle: " + (getNameOfParticle()))
+                .setTooltip(Text.translatable("menu.cavedust.particle.tooltip"));
+
+        addButton(new Slider(left += 220, row -= 96, 1, 50, config.getDimensionsX()))
+                .onChange(config::setDimensionsX)
+                .setTextFormat(transText::formatMaxX)
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.X.tooltip"));
+
+        addButton(new Slider(left, row += 24, 1, 50, config.getDimensionsY()))
+                .onChange(config::setDimensionsY)
+                .setTextFormat(transText::formatMaxY)
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.Y.tooltip"));
+
+        addButton(new Slider(left, row += 24, 1, 50, config.getDimensionsZ()))
+                .onChange(config::setDimensionsZ)
+                .setTextFormat(transText::formatMaxZ)
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.Z.tooltip"));
 
         addButton(new Slider(left, row += 24, 0, 10, config.getVelocityRandomness()))
                 .onChange(config::setVelocityRandomness)
                 .setTextFormat(transText::formatVelocityRandomness)
-                .getStyle().setTooltip(new TranslatableText("menu.cavedust.velocityrandomness.tooltip"));
+                .getStyle().setTooltip(Text.translatable("menu.cavedust.velocityrandomness.tooltip"));
 
 
-        addButton(new Button(left, row += 24).onClick(sender -> {
+        addButton(new Button(left -= 110, row += 60).onClick(sender -> {
             config.resetConfig();
             finish();
-        })).getStyle().setText(new TranslatableText("menu.cavedust.reset")).setTooltip(new TranslatableText("menu.cavedust.reset.tooltip"));
+        })).getStyle().setText(Text.translatable("menu.cavedust.reset")).setTooltip(Text.translatable("menu.cavedust.reset.tooltip"));
 
-        addButton(new Button(left, row += 60)
+        addButton(new Button(left, row += 24)
                 .onClick(sender -> finish())).getStyle()
                 .setText("gui.done");
+
     }
 
 
@@ -111,4 +110,9 @@ public class ModMenuConfigScreen extends GameGui {
         renderBackground(matrices);
         super.render(matrices, mouseX, mouseY, partialTicks);
     }
+    private String getNameOfParticle(){
+        CaveDustConfig config = CaveDust.getInstance().getConfig();
+        config.load();
+        return Registries.PARTICLE_TYPE.getEntry(config.getParticleID()).get().getKey().get().getValue().toString();
+    }
 }

src/main/java/net/lizistired/cavedust/mixin/MixinDebugScreenOverlay.java

@@ -1,48 +1,24 @@
 package net.lizistired.cavedust.mixin;
 
-
-import net.lizistired.cavedust.CaveDustConfig;
 import net.minecraft.client.gui.hud.DebugHud;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-import java.lang.management.BufferPoolMXBean;
-import java.lang.management.ManagementFactory;
 import java.util.List;
-import java.util.Objects;
-import static net.lizistired.cavedust.utils.MathHelper.*;
+
+import static net.lizistired.cavedust.CaveDust.PARTICLE_AMOUNT;
 import static net.lizistired.cavedust.utils.ParticleSpawnUtil.shouldParticlesSpawn;
 
 @Mixin(DebugHud.class)
 public abstract class MixinDebugScreenOverlay {
-    @Unique
-    private static final List<BufferPoolMXBean> pools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
-
-    @Unique
-    private static final BufferPoolMXBean directPool;
-
-    static {
-        BufferPoolMXBean found = null;
-
-        for (BufferPoolMXBean pool : pools) {
-            if (pool.getName().equals("direct")) {
-                found = pool;
-                break;
-            }
-        }
-
-        directPool = Objects.requireNonNull(found);
-    }
     @Inject(method = "getRightText", at = @At("RETURN"))
     private void appendShaderPackText(CallbackInfoReturnable<List<String>> cir) {
         List<String> messages = cir.getReturnValue();
 
         messages.add("");
-        messages.add("Should particles spawn: " + shouldParticlesSpawn);
+        messages.add("Particle amount evaluated: " + PARTICLE_AMOUNT);
         messages.add("");
     }
 }

src/main/java/net/lizistired/cavedust/utils/KeybindingHelper.java

@@ -2,7 +2,6 @@ package net.lizistired.cavedust.utils;
 
 import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
 import net.minecraft.client.option.KeyBinding;
-import net.minecraft.client.option.StickyKeyBinding;
 import net.minecraft.client.util.InputUtil;
 import org.lwjgl.glfw.GLFW;
 

src/main/java/net/lizistired/cavedust/utils/ParticleSpawnUtil.java

@@ -7,7 +7,6 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
 import java.util.Objects;
-import java.util.Optional;
 
 import static net.minecraft.world.biome.BiomeKeys.LUSH_CAVES;
 
@@ -27,9 +26,9 @@ public class ParticleSpawnUtil {
         if (!config.getCaveDustEnabled()
                 || client.isPaused()
                 || client.world == null
-                || !client.world.getDimension().isBedWorking()
+                || !client.world.getDimension().bedWorks()
                 || Objects.requireNonNull(client.player).isSubmergedInWater()
-                || Objects.equals(client.world.getBiomeKey(Objects.requireNonNull(client.player.getBlockPos())), Optional.of(LUSH_CAVES)))
+                || client.world.getBiome(Objects.requireNonNull(client.player.getBlockPos())).matchesKey(LUSH_CAVES))
         {
             timer = 0;
             shouldParticlesSpawn = false;
@@ -66,9 +65,10 @@ public class ParticleSpawnUtil {
         if (!config.getCaveDustEnabled()
                 || client.isPaused()
                 || client.world == null
-                || !client.world.getDimension().isBedWorking()
-                || Objects.requireNonNull(client.player).isSubmergedInWater()
-                || Objects.equals(client.world.getBiomeKey(Objects.requireNonNull(pos)), Optional.of(LUSH_CAVES)))
+                || !client.world.getDimension().bedWorks()
+                || (client.world.getBottomY() > pos.getY())
+                || client.world.getBiome(Objects.requireNonNull(pos)).matchesKey(LUSH_CAVES))
+
         {
             timer = 0;
             shouldParticlesSpawn = false;

src/main/java/net/lizistired/cavedust/utils/TranslatableTextHelper.java

@@ -2,37 +2,33 @@ package net.lizistired.cavedust.utils;
 
 import com.minelittlepony.common.client.gui.element.AbstractSlider;
 import net.minecraft.text.Text;
-import net.minecraft.text.TranslatableText;
+
+import javax.swing.*;
 
 public class TranslatableTextHelper {
-    public Text formatMinX(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.minX", (int)Math.floor(slider.getValue()));
-    }
-    public Text formatMinY(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.minY", (int)Math.floor(slider.getValue()));
-    }
-    public Text formatMinZ(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.minZ", (int)Math.floor(slider.getValue()));
-    }
     public Text formatMaxX(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.maxX", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.X", (int)Math.floor(slider.getValue()));
     }
     public Text formatMaxY(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.maxY", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.Y", (int)Math.floor(slider.getValue()));
     }
     public Text formatMaxZ(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.maxZ", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.Z", (int)Math.floor(slider.getValue()));
     }
     public Text formatUpperLimit(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.upperlimit", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.upperlimit", (int)Math.floor(slider.getValue()));
     }
     public Text formatLowerLimit(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.lowerlimit", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.lowerlimit", (int)Math.floor(slider.getValue()));
     }
     public Text formatParticleMultiplier(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.particlemultiplier", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.particlemultiplier", (int)Math.floor(slider.getValue()));
+    }
+
+    public Text formatParticleMultiplierMultiplier(AbstractSlider<Float> slider) {
+        return Text.translatable("menu.cavedust.particlemultipliermultiplier", (int)Math.floor(slider.getValue()));
     }
     public Text formatVelocityRandomness(AbstractSlider<Float> slider) {
-        return new TranslatableText("menu.cavedust.velocityrandomness", (int)Math.floor(slider.getValue()));
+        return Text.translatable("menu.cavedust.velocityrandomness", (int) Math.floor(slider.getValue()));
     }
 }

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

@@ -4,26 +4,22 @@
   "menu.cavedust.global.true": "Cave Dust: Enabled",
   "menu.cavedust.global.tooltip.false": "Enable cave dust particles?",
   "menu.cavedust.global.tooltip.true": "Disable cave dust particles?",
-  "menu.cavedust.minX": "Minimum X: %s",
-  "menu.cavedust.minY": "Minimum Y: %s",
-  "menu.cavedust.minZ": "Minimum Z: %s",
-  "menu.cavedust.maxX": "Maximum X: %s",
-  "menu.cavedust.maxY": "Maximum Y: %s",
-  "menu.cavedust.maxZ": "Maximum Z: %s",
-  "menu.cavedust.minX.tooltip": "Minimum X: %s",
-  "menu.cavedust.minY.tooltip": "Minimum Y: %s",
-  "menu.cavedust.minZ.tooltip": "Minimum Z: %s",
-  "menu.cavedust.maxX.tooltip": "Maximum X: %s",
-  "menu.cavedust.maxY.tooltip": "Maximum Y: %s",
-  "menu.cavedust.maxZ.tooltip": "Maximum Z: %s",
-  "menu.cavedust.upperlimit": "Upper limit: %s",
-  "menu.cavedust.lowerlimit": "Lower limit: %s",
+  "menu.cavedust.X": "X bounds: %s",
+  "menu.cavedust.Y": "Y bounds: %s",
+  "menu.cavedust.Z": "Z bounds: %s",
+  "menu.cavedust.X.tooltip": "X axis bounds for particle spawning.",
+  "menu.cavedust.Y.tooltip": "Y axis bounds for particle spawning.",
+  "menu.cavedust.Z.tooltip": "Z axis bounds for particle spawning.",
+  "menu.cavedust.upperlimit": "Upper limit height: %s",
+  "menu.cavedust.lowerlimit": "Lower limit height: %s",
   "menu.cavedust.upperlimit.tooltip": "The height where particles will fade out and stop spawning (uses player y).",
   "menu.cavedust.lowerlimit.tooltip": "The height where particles spawn the most (uses player y).",
   "menu.cavedust.reset": "Reset settings",
   "menu.cavedust.reset.tooltip": "Are you sure you want to reset all settings?",
-  "menu.cavedust.particlemultiplier": "Particle multiplier: %s",
-  "menu.cavedust.particlemultiplier.tooltip": "Multiplies the amount of particles at any given depth.",
+  "menu.cavedust.particlemultiplier": "Particle amount: %s",
+  "menu.cavedust.particlemultiplier.tooltip": "Amount of particles to spawn at any given depth.",
+  "menu.cavedust.particlemultipliermultiplier": "Particle multiplier: %s",
+  "menu.cavedust.particlemultipliermultiplier.tooltip": "Multiplies particle amount.",
   "menu.cavedust.velocityrandomness": "Velocity randomness: %s",
   "menu.cavedust.velocityrandomness.tooltip": "The randomness of the velocity of the particles.",
   "menu.cavedust.enhanceddetection.true": "Enhanced detection: Enabled",
@@ -32,6 +28,8 @@
   "menu.cavedust.superflatstatus.true": "Superflat particles: Enabled",
   "menu.cavedust.superflatstatus.false": "Superflat particles: Disabled",
   "menu.cavedust.superflatstatus.tooltip": "Should particles spawn on superflat worlds?",
+  "menu.cavedust.particle": "Particle: ",
+  "menu.cavedust.particle.tooltip": "Particle to spawn. Click to cycle.",
 
   "key.cavedust.reload": "Reload Config",
   "key.cavedust.toggle": "Toggle Particles",

src/main/resources/dust.mixins.json

@@ -4,7 +4,8 @@
   "package": "net.lizistired.cavedust.mixin",
   "compatibilityLevel": "JAVA_16",
   "mixins": [
-    "ClientWorldAccessor"
+    "ClientWorldAccessor",
+    "MixinDebugScreenOverlay"
   ],
   "client": [
   ],

src/main/resources/fabric.mod.json

@@ -26,9 +26,9 @@
     "dust.mixins.json"
   ],
   "depends": {
-    "fabricloader": ">=0.12.11",
+    "fabricloader": ">=0.14.5",
     "fabric": "*",
-    "minecraft": "<=1.18.1",
+    "minecraft": ">=1.19-beta.5",
     "java": ">=17"
   },
   "suggests": {