Fixed toggleability for Vein Miner

revert Made head movement lock expire as soon as teleported

.gitea/workflows/build.yml

@@ -0,0 +1,32 @@
+name: build
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Validate Gradle wrapper
+        uses: gradle/actions/wrapper-validation@v4
+
+      - name: Setup JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'microsoft'
+
+      - name: Make Gradle wrapper executable
+        run: chmod +x ./gradlew
+
+      - name: Build
+        run: ./gradlew build
+
+      - name: Capture build artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: Artifacts
+          path: build/libs/

README.md

@@ -3,8 +3,10 @@
 # ![Logo](https://i.imgur.com/ktkHND1.png)
 
 This mod is FAR FROM FINISHED, and initially just created for our private Survival Server.
-As a challenge I'm trying to make it as user-friendly as possible. (It ain't there yet tho ;) )
-## Current feature-set
+As a challenge I'm trying to make it as user-friendly as possible.
+# Current feature-set
+
+## Server Side
 
 ### Features
 - Custom join message  
@@ -24,19 +26,51 @@ As a challenge I'm trying to make it as user-friendly as possible. (It ain't the
   - Version "control"
 - Shared Ender Chest
   - Shared EC Access control (via config)
+  - Open/close EC block while opening/closing SEC
+  - Play open & close sounds
 - Vein miner  
 ![VeinMiner](https://i.imgur.com/zOXWMNa.gif)
-
+- Chat Calculator
 
 ### Commands
 - /spectator | Essentially server-side free-cam, you get put in spectator and are able to fly around, once you use the command again you get put back to where you were.
 - /slimechunk (/sc) | See if you're currently in a slimechunk
 
-### Misc
-- Updated icon
+## Client Side
 
-## Features to come
+- Teleportation Angle Viewer for [this machine](https://www.youtube.com/watch?v=FnUE-ZaALLw)
+  - Toggleable pitch/yaw lock while teleporting  
+    ![Teleportation Keybindings](https://i.imgur.com/gjO1H3d.png)
+- Remove game fog (lava, water, etc.)
+  - All types individually toggleable
+- Mod Menu integration
+  - Automatic config adaption (currently booleans only)
+- Remove darkness effect
+  - Toggleable
+- Keybinding for /camera
 
+# Currently working on
+
+## Client Side
+
+- [x] Render block entities from a longer range
+  - [x] Toggleable via GUI
+  - [x] Configurable value
+    - [x] In GUI
+- [x] Rework Mod Menu integration to be more flexible
+  - The following types are accepted:
+    - String
+    - Boolean
+    - Float
+    - Integer
+
+# To-do
+
+## General
+- Rework config system
+  - Store server settings in world folder for better singleplayer use
+
+## Server Side
 - Telekinesis
 
 Other than that no more features!

build.gradle

@@ -11,11 +11,22 @@ base {
 }
 
 repositories {
-	// Add repositories to retrieve artifacts from in here.
-	// You should only use this when depending on other mods because
-	// Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
-	// See https://docs.gradle.org/current/userguide/declaring_repositories.html
-	// for more information about repositories.
+	maven {
+		name = "Terraformers"
+		url = "https://maven.terraformersmc.com/"
+	}
+}
+
+loom {
+	splitEnvironmentSourceSets()
+
+	mods {
+		"survivalfabric" {
+			sourceSet sourceSets.main
+			sourceSet sourceSets.client
+		}
+	}
+
 }
 
 fabricApi {
@@ -26,13 +37,13 @@ fabricApi {
 
 dependencies {
 	// To change the versions see the gradle.properties file
-	minecraft "net.minecraft:minecraft:${project.minecraft_version}"
+	minecraft "com.mojang:minecraft:${project.minecraft_version}"
 	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
 	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 
 	// Fabric API. This is technically optional, but you probably want it anyway.
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-	
+	modImplementation("com.terraformersmc:modmenu:${project.modmenu_version}")
 }
 
 processResources {

gradle.properties

@@ -4,14 +4,16 @@ org.gradle.parallel=true
 
 # Fabric Properties
 # check these on https://fabricmc.net/develop
-minecraft_version=1.21.4
-yarn_mappings=1.21.4+build.8
+minecraft_version=1.21.5
+yarn_mappings=1.21.5+build.1
 loader_version=0.16.10
 
 # Mod Properties
-mod_version=1.3.0
+mod_version=1.4.1
 maven_group=wtf.hak.survivalfabric
 archives_base_name=survivalfabric
 
 # Dependencies
-fabric_version=0.119.0+1.21.4
+fabric_version=0.119.5+1.21.5
+
+modmenu_version=14.0.0-rc.2

src/client/java/wtf/hak/survivalfabric/SurvivalFabricClient.java

@@ -0,0 +1,23 @@
+package wtf.hak.survivalfabric;
+
+import net.fabricmc.api.ClientModInitializer;
+import wtf.hak.survivalfabric.config.client.ClientConfigManager;
+import wtf.hak.survivalfabric.features.AngleViewer;
+import wtf.hak.survivalfabric.features.RemoveDarknessEffect;
+import wtf.hak.survivalfabric.features.SFKeyBindings;
+
+public class SurvivalFabricClient implements ClientModInitializer {
+
+    @Override
+    public void onInitializeClient() {
+
+        // Config
+        ClientConfigManager.getConfig();
+
+        // Features
+        AngleViewer.register();
+        RemoveDarknessEffect.register();
+        SFKeyBindings.register();
+
+    }
+}

src/client/java/wtf/hak/survivalfabric/config/client/ClientConfig.java

@@ -0,0 +1,16 @@
+package wtf.hak.survivalfabric.config.client;
+
+public class ClientConfig {
+    public String configVersion = "1.0";
+
+    public boolean renderNetherFog = false;
+    public boolean renderOverworldFog = false;
+    public boolean renderEndFog = false;
+    public boolean renderLavaFog = false;
+    public boolean renderWaterFog = false;
+    public boolean renderSnowFog = false;
+    public boolean removeDarknessEffect = true;
+    public boolean lockTeleportHeadMovement = true;
+    public boolean manipulateBlockEntityDistance = true;
+    public int blockEntityRange = 512;
+}

src/client/java/wtf/hak/survivalfabric/config/client/ClientConfigManager.java

@@ -0,0 +1,55 @@
+package wtf.hak.survivalfabric.config.client;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import net.fabricmc.loader.api.FabricLoader;
+import wtf.hak.survivalfabric.config.Config;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class ClientConfigManager {
+
+    private static final File CONFIG_FILE = FabricLoader.getInstance().getConfigDir().resolve("survivalfabric-client.json").toFile();
+    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
+
+    private static ClientConfig INSTANCE;
+
+    public static ClientConfig getConfig() {
+        if (INSTANCE == null) {
+            return load();
+        } else
+            return INSTANCE;
+    }
+
+    public static ClientConfig load() {
+        try (FileReader reader = new FileReader(CONFIG_FILE)) {
+            INSTANCE = GSON.fromJson(reader, ClientConfig.class);
+            if (INSTANCE.configVersion.equalsIgnoreCase(new Config().configVersion)) {
+                return INSTANCE;
+            }
+            INSTANCE.configVersion = new ClientConfig().configVersion;
+            save(INSTANCE);
+            return INSTANCE;
+        } catch (IOException e) {
+            ClientConfig config = new ClientConfig();
+            INSTANCE = config;
+            save(config);
+            return config;
+        }
+    }
+
+    public static void save() {
+        save(INSTANCE);
+    }
+
+    public static void save(ClientConfig config) {
+        try (FileWriter writer = new FileWriter(CONFIG_FILE)) {
+            GSON.toJson(config, writer);
+        } catch (IOException e) {
+            System.out.println("Error saving config: " + e.getMessage());
+        }
+    }
+}

src/client/java/wtf/hak/survivalfabric/features/AngleViewer.java

@@ -0,0 +1,75 @@
+package wtf.hak.survivalfabric.features;
+
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.option.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+public class AngleViewer {
+
+    private static final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+    public static boolean PREVENT_HEAD_MOVEMENT = false;
+
+    public static void register() {
+        for (Angle angle : Angle.values()) {
+            KeyBinding keyBinding = KeyBindingHelper.registerKeyBinding(new KeyBinding(
+                    "key.survivalfabric." + angle.name().toLowerCase(),
+                    InputUtil.Type.KEYSYM,
+                    GLFW.GLFW_DONT_CARE,
+                    "category.survivalfabric.tpangles"
+            ));
+
+            ClientTickEvents.END_CLIENT_TICK.register(mc -> {
+                while (keyBinding.wasPressed()) {
+                    ClientPlayerEntity player = mc.player;
+                    if (player == null) return;
+                    player.setYaw(angle.yaw);
+                    player.setPitch(angle.pitch);
+
+                    PREVENT_HEAD_MOVEMENT = true;
+
+                    scheduler.schedule(() -> {
+                        if (player == null) return;
+                        PREVENT_HEAD_MOVEMENT = false;
+                        player.setPitch(-90);
+                        PREVENT_HEAD_MOVEMENT = true;
+                        scheduler.schedule(() -> PREVENT_HEAD_MOVEMENT = false, 1500, TimeUnit.MILLISECONDS);
+                    }, 1500, TimeUnit.MILLISECONDS);
+                }
+            });
+        }
+    }
+
+    public enum Angle {
+        ANGLE0(-65.19f, -54.23f),
+        ANGLE1(-24.86f, -54.23f),
+        ANGLE2(-65.02f, -41.68f),
+        ANGLE3(-25.03f, -41.71f),
+        ANGLE4(24.81f, -54.23f),
+        ANGLE5(65.14f, -54.23f),
+        ANGLE6(24.98f, -41.68f),
+        ANGLE7(64.97f, -41.71f),
+        ANGLE8(114.81f, -54.23f),
+        ANGLE9(155.14f, -54.23f),
+        ANGLE10(114.98f, -41.68f),
+        ANGLE11(154.97f, -41.71f),
+        ANGLE12(204.81f, -54.23f),
+        ANGLE13(245.14f, -54.23f),
+        ANGLE14(204.98f, -41.68f),
+        ANGLE15(244.97f, -41.71f);
+
+        public final float yaw;
+        public final float pitch;
+
+        Angle(float yaw, float pitch) {
+            this.yaw = yaw;
+            this.pitch = pitch;
+        }
+    }
+}

src/client/java/wtf/hak/survivalfabric/features/RemoveDarknessEffect.java

@@ -0,0 +1,19 @@
+package wtf.hak.survivalfabric.features;
+
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.minecraft.entity.effect.StatusEffectInstance;
+import net.minecraft.entity.effect.StatusEffects;
+import wtf.hak.survivalfabric.config.client.ClientConfigManager;
+
+public class RemoveDarknessEffect {
+
+    public static void register() {
+        ClientTickEvents.END_CLIENT_TICK.register(client -> {
+            if (client.player != null && ClientConfigManager.getConfig().removeDarknessEffect) {
+                StatusEffectInstance darknessEffect = client.player.getStatusEffect(StatusEffects.DARKNESS);
+                if (darknessEffect != null)
+                    client.player.removeStatusEffect(darknessEffect.getEffectType());
+            }
+        });
+    }
+}

src/client/java/wtf/hak/survivalfabric/features/SFKeyBindings.java

@@ -0,0 +1,22 @@
+package wtf.hak.survivalfabric.features;
+
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
+import net.minecraft.client.option.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+import org.lwjgl.glfw.GLFW;
+
+public class SFKeyBindings {
+
+    private static final KeyBinding CAMERA_BIND = KeyBindingHelper.registerKeyBinding(new KeyBinding("key.survivalfabric.camera", InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_PERIOD, "category.survivalfabric.survivalfabric"));
+
+    public static void register() {
+        ClientTickEvents.END_CLIENT_TICK.register(client -> {
+            if(client.player != null) {
+                if (CAMERA_BIND.wasPressed()) {
+                    client.player.networkHandler.sendChatCommand("camera");
+                }
+            }
+        });
+    }
+}

src/client/java/wtf/hak/survivalfabric/mixin/client/BackgroundRendererMixin.java

@@ -0,0 +1,47 @@
+package wtf.hak.survivalfabric.mixin.client;
+
+import net.minecraft.block.enums.CameraSubmersionType;
+import net.minecraft.client.render.BackgroundRenderer;
+import net.minecraft.client.render.Camera;
+import net.minecraft.client.render.Fog;
+import net.minecraft.client.render.FogShape;
+import net.minecraft.world.World;
+import org.joml.Vector4f;
+import org.spongepowered.asm.mixin.Mixin;
+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 static wtf.hak.survivalfabric.config.client.ClientConfigManager.getConfig;
+
+@Mixin(value = BackgroundRenderer.class, priority = 910)
+public abstract class BackgroundRendererMixin {
+
+    @Unique
+    private static final Fog EMPTY_FOG = new Fog(-8.0f, 1_000_000.0F, FogShape.CYLINDER, 0, 0, 0, 0);
+
+    @Inject(method = "applyFog", at = @At("RETURN"), cancellable = true)
+    private static void applyFog(Camera camera, BackgroundRenderer.FogType fogType, Vector4f color, float viewDistance, boolean thickenFog, float tickProgress, CallbackInfoReturnable<Fog> cir) {
+        CameraSubmersionType submersion = camera.getSubmersionType();
+        boolean renderFog = true;
+
+        switch (submersion) {
+            case NONE -> {
+                World world = camera.getFocusedEntity().getWorld();
+                if ((world.getRegistryKey() == World.OVERWORLD && !getConfig().renderOverworldFog)
+                        || (world.getRegistryKey() == World.NETHER && !getConfig().renderNetherFog)
+                        || (world.getRegistryKey() == World.END && !getConfig().renderEndFog)) {
+                    renderFog = false;
+                }
+            }
+            case WATER -> renderFog = getConfig().renderWaterFog;
+            case LAVA -> renderFog = getConfig().renderLavaFog;
+            case POWDER_SNOW -> renderFog = getConfig().renderSnowFog;
+        }
+
+        if (!renderFog) {
+            cir.setReturnValue(EMPTY_FOG);
+        }
+    }
+}

src/client/java/wtf/hak/survivalfabric/mixin/client/BlockEntityRendererMixin.java

@@ -0,0 +1,19 @@
+package wtf.hak.survivalfabric.mixin.client;
+
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.client.render.block.entity.BlockEntityRenderer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import wtf.hak.survivalfabric.config.client.ClientConfigManager;
+
+@Mixin(BlockEntityRenderer.class)
+public interface BlockEntityRendererMixin<T extends BlockEntity> {
+
+    @Inject(method = "getRenderDistance", at = @At("HEAD"), cancellable = true)
+    private void getRenderDistance(CallbackInfoReturnable<Integer> cir) {
+        if(ClientConfigManager.getConfig().manipulateBlockEntityDistance)
+            cir.setReturnValue(ClientConfigManager.getConfig().blockEntityRange);
+    }
+}

src/client/java/wtf/hak/survivalfabric/mixin/client/EntityMixin.java

@@ -0,0 +1,32 @@
+package wtf.hak.survivalfabric.mixin.client;
+
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import wtf.hak.survivalfabric.config.client.ClientConfigManager;
+import wtf.hak.survivalfabric.features.AngleViewer;
+
+@Mixin(Entity.class)
+public abstract class EntityMixin {
+
+    @Inject(method = "setYaw", at = @At("HEAD"), cancellable = true)
+    private void preventYawChange(float yaw, CallbackInfo ci) {
+        if ((Object) this instanceof ClientPlayerEntity player) {
+            if (player.isMainPlayer() && AngleViewer.PREVENT_HEAD_MOVEMENT && ClientConfigManager.getConfig().lockTeleportHeadMovement) {
+                ci.cancel();
+            }
+        }
+    }
+
+    @Inject(method = "setPitch", at = @At("HEAD"), cancellable = true)
+    private void preventPitchChange(float pitch, CallbackInfo ci) {
+        if ((Object) this instanceof ClientPlayerEntity player) {
+            if (player.isMainPlayer() && AngleViewer.PREVENT_HEAD_MOVEMENT && ClientConfigManager.getConfig().lockTeleportHeadMovement) {
+                ci.cancel();
+            }
+        }
+    }
+}

src/client/java/wtf/hak/survivalfabric/modmenu/ConfigScreen.java

@@ -0,0 +1,599 @@
+package wtf.hak.survivalfabric.modmenu;
+
+import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.text.Text;
+import net.minecraft.util.math.MathHelper;
+import wtf.hak.survivalfabric.config.client.ClientConfig;
+import wtf.hak.survivalfabric.config.client.ClientConfigManager;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConfigScreen extends Screen {
+
+    private static final int OPTION_HEIGHT = 25;
+    private static final int SCROLL_BAR_WIDTH = 6;
+    private static final int TOP_PADDING = 40;
+    private static final int BOTTOM_PADDING = 35;
+    private static final int SIDE_PADDING = 20;
+    private final Screen parent;
+    private final List<ConfigOption<?>> options = new ArrayList<>();
+    private TextFieldWidget activeTextField = null;
+    private float scrollPosition = 0.0F;
+    private boolean scrolling = false;
+    private int contentHeight = 0;
+
+    public ConfigScreen(Screen parent) {
+        super(Text.literal("Survival Fabric - Client Config"));
+        this.parent = parent;
+    }
+
+    @Override
+    protected void init() {
+        options.clear();
+
+        int listWidth = this.width - (SIDE_PADDING * 2);
+        int listHeight = this.height - TOP_PADDING - BOTTOM_PADDING;
+        int listLeft = SIDE_PADDING;
+        int listTop = TOP_PADDING;
+
+        int index = 0;
+        for (Field field : ClientConfig.class.getFields()) {
+            try {
+                Class<?> type = field.getType();
+                String name = formatFieldName(field.getName());
+
+                ConfigOption<?> option = null;
+                if (type == boolean.class) {
+                    boolean value = field.getBoolean(ClientConfigManager.getConfig());
+                    option = new BooleanConfigOption(
+                            name,
+                            field,
+                            value,
+                            listLeft,
+                            listTop + (index * OPTION_HEIGHT) - (int) scrollPosition,
+                            listWidth
+                    );
+                } else if (type == int.class) {
+                    int value = field.getInt(ClientConfigManager.getConfig());
+                    option = new IntegerConfigOption(
+                            name,
+                            field,
+                            value,
+                            listLeft,
+                            listTop + (index * OPTION_HEIGHT) - (int) scrollPosition,
+                            listWidth
+                    );
+                } else if (type == float.class) {
+                    float value = field.getFloat(ClientConfigManager.getConfig());
+                    option = new FloatConfigOption(
+                            name,
+                            field,
+                            value,
+                            listLeft,
+                            listTop + (index * OPTION_HEIGHT) - (int) scrollPosition,
+                            listWidth
+                    );
+                } else if (type == String.class) {
+                    String value = (String) field.get(ClientConfigManager.getConfig());
+                    option = new StringConfigOption(
+                            name,
+                            field,
+                            value,
+                            listLeft,
+                            listTop + (index * OPTION_HEIGHT) - (int) scrollPosition,
+                            listWidth
+                    );
+                }
+
+                if (option != null) {
+                    options.add(option);
+                    index++;
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        for (ConfigOption<?> option : options) {
+            if (option instanceof NumericConfigOption) {
+                ((NumericConfigOption<?>) option).createTextField(this.client);
+            }
+        }
+
+        contentHeight = options.size() * OPTION_HEIGHT;
+
+        this.addDrawableChild(ButtonWidget.builder(
+                Text.translatable("gui.done"),
+                button -> this.client.setScreen(parent)
+        ).dimensions(this.width / 2 - 100, this.height - 27, 200, 20).build());
+    }
+
+    @Override
+    public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+        this.renderBackground(context, mouseX, mouseY, delta);
+
+        int titleX = (this.width / 2) - (this.textRenderer.getWidth(this.title) / 2);
+        context.drawText(this.textRenderer, this.title, titleX, 15, 0xFFFFFF, true);
+
+        int listWidth = this.width - (SIDE_PADDING * 2);
+        int listHeight = this.height - TOP_PADDING - BOTTOM_PADDING;
+        int listLeft = SIDE_PADDING;
+        int listTop = TOP_PADDING;
+
+        context.drawBorder(listLeft, listTop, listLeft + listWidth, listTop + listHeight, 0x00000000);
+
+        context.enableScissor(
+                listLeft,
+                listTop,
+                listLeft + listWidth,
+                listTop + listHeight
+        );
+
+        for (int i = 0; i < options.size(); i++) {
+            ConfigOption<?> option = options.get(i);
+            option.y = listTop + (i * OPTION_HEIGHT) - (int) scrollPosition;
+
+            if (option instanceof NumericConfigOption) {
+                ((NumericConfigOption<?>) option).updateTextFieldPosition();
+            }
+
+            if (option.y < listTop + listHeight && option.y + OPTION_HEIGHT > listTop) {
+                option.render(context, mouseX, mouseY, delta);
+            }
+        }
+
+        context.disableScissor();
+
+        if (contentHeight > listHeight) {
+            int scrollBarHeight = Math.max(20, (int) ((float) listHeight / (float) contentHeight * listHeight));
+            int scrollBarY = listTop + (int) ((scrollPosition / (contentHeight - listHeight)) * (listHeight - scrollBarHeight));
+
+            context.fill(
+                    listLeft + listWidth + 2,
+                    listTop,
+                    listLeft + listWidth + 2 + SCROLL_BAR_WIDTH,
+                    listTop + listHeight,
+                    0xFF404040
+            );
+
+            context.fill(
+                    listLeft + listWidth + 2,
+                    scrollBarY,
+                    listLeft + listWidth + 2 + SCROLL_BAR_WIDTH,
+                    scrollBarY + scrollBarHeight,
+                    scrolling ? 0xFFAAAAAA : 0xFF808080
+            );
+        }
+
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        int listWidth = this.width - (SIDE_PADDING * 2);
+        int listHeight = this.height - TOP_PADDING - BOTTOM_PADDING;
+        int listLeft = SIDE_PADDING;
+        int listTop = TOP_PADDING;
+
+        boolean handledByTextField = false;
+
+        activeTextField = null;
+
+        if (mouseX >= listLeft &&
+                mouseX <= listLeft + listWidth &&
+                mouseY >= listTop &&
+                mouseY <= listTop + listHeight) {
+
+            for (ConfigOption<?> option : options) {
+                if (option instanceof NumericConfigOption<?> numOption &&
+                        option.y >= listTop &&
+                        option.y + OPTION_HEIGHT <= listTop + listHeight) {
+
+                    TextFieldWidget textField = numOption.getTextField();
+
+                    if (textField.isMouseOver(mouseX, mouseY)) {
+                        textField.setFocused(true);
+                        activeTextField = textField;
+                        handledByTextField = true;
+
+                        for (ConfigOption<?> otherOption : options) {
+                            if (otherOption instanceof NumericConfigOption && otherOption != option) {
+                                ((NumericConfigOption<?>) otherOption).getTextField().setFocused(false);
+                            }
+                        }
+
+                        return true;
+                    } else {
+                        textField.setFocused(false);
+                    }
+                }
+            }
+        }
+
+        if (contentHeight > listHeight &&
+                mouseX >= listLeft + listWidth + 2 &&
+                mouseX <= listLeft + listWidth + 2 + SCROLL_BAR_WIDTH &&
+                mouseY >= listTop &&
+                mouseY <= listTop + listHeight) {
+
+            scrolling = true;
+            return true;
+        }
+
+        // Check if clicked on an option
+        if (mouseX >= listLeft &&
+                mouseX <= listLeft + listWidth &&
+                mouseY >= listTop &&
+                mouseY <= listTop + listHeight) {
+
+            for (ConfigOption<?> option : options) {
+                if (option.isMouseOver(mouseX, mouseY) && option.y >= listTop && option.y + OPTION_HEIGHT <= listTop + listHeight) {
+                    option.onClick(mouseX, mouseY);
+                    return true;
+                }
+            }
+        }
+
+        return super.mouseClicked(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (activeTextField != null && activeTextField.isFocused()) {
+            return activeTextField.keyPressed(keyCode, scanCode, modifiers);
+        }
+
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+
+    @Override
+    public boolean charTyped(char chr, int modifiers) {
+        if (activeTextField != null && activeTextField.isFocused()) {
+            return activeTextField.charTyped(chr, modifiers);
+        }
+
+        return super.charTyped(chr, modifiers);
+    }
+
+    @Override
+    public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        scrolling = false;
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int button, double deltaX, double deltaY) {
+        int listHeight = this.height - TOP_PADDING - BOTTOM_PADDING;
+        int listTop = TOP_PADDING;
+
+        if (scrolling && contentHeight > listHeight) {
+            float scrollAmount = (float) deltaY / (listHeight - Math.max(20, (int) ((float) listHeight / (float) contentHeight * listHeight)));
+            float maxScroll = contentHeight - listHeight;
+
+            scrollPosition = MathHelper.clamp(scrollPosition + scrollAmount * maxScroll, 0.0F, maxScroll);
+            return true;
+        }
+
+        return super.mouseDragged(mouseX, mouseY, button, deltaX, deltaY);
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double horizontalAmount, double verticalAmount) {
+        int listWidth = this.width - (SIDE_PADDING * 2);
+        int listHeight = this.height - TOP_PADDING - BOTTOM_PADDING;
+        int listLeft = SIDE_PADDING;
+        int listTop = TOP_PADDING;
+
+        if (mouseX >= listLeft &&
+                mouseX <= listLeft + listWidth &&
+                mouseY >= listTop &&
+                mouseY <= listTop + listHeight &&
+                contentHeight > listHeight) {
+
+            float maxScroll = contentHeight - listHeight;
+            scrollPosition = MathHelper.clamp(scrollPosition - (float) verticalAmount * 10, 0.0F, maxScroll);
+            return true;
+        }
+
+        return super.mouseScrolled(mouseX, mouseY, horizontalAmount, verticalAmount);
+    }
+
+    private String formatFieldName(String rawName) {
+        StringBuilder result = new StringBuilder();
+        char[] chars = rawName.toCharArray();
+        result.append(Character.toUpperCase(chars[0]));
+        for (int i = 1; i < chars.length; i++) {
+            if (Character.isUpperCase(chars[i])) {
+                result.append(' ');
+            }
+            result.append(chars[i]);
+        }
+        return result.toString();
+    }
+
+    /**
+     * Base class for all config options
+     */
+    private abstract class ConfigOption<T> {
+        protected final String name;
+        protected final Field field;
+        protected final int width;
+        protected T value;
+        protected int x;
+        protected int y;
+
+        public ConfigOption(String name, Field field, T initialValue, int x, int y, int width) {
+            this.name = name;
+            this.field = field;
+            this.value = initialValue;
+            this.x = x;
+            this.y = y;
+            this.width = width;
+        }
+
+        public abstract void render(DrawContext context, int mouseX, int mouseY, float delta);
+
+        public abstract void onClick(double mouseX, double mouseY);
+
+        public boolean isMouseOver(double mouseX, double mouseY) {
+            return mouseX >= x && mouseX <= x + width && mouseY >= y && mouseY <= y + OPTION_HEIGHT;
+        }
+
+        protected abstract void saveValue();
+    }
+
+    /**
+     * Implementation for boolean config options
+     */
+    private class BooleanConfigOption extends ConfigOption<Boolean> {
+        private static final int BUTTON_WIDTH = 40;
+        private static final int BUTTON_HEIGHT = 20;
+
+        public BooleanConfigOption(String name, Field field, Boolean initialValue, int x, int y, int width) {
+            super(name, field, initialValue, x, y, width);
+        }
+
+        @Override
+        public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+            context.drawText(textRenderer, name, x + 5, y + (OPTION_HEIGHT - 8) / 2, 0xFFFFFF, true);
+
+            int buttonX = x + width - BUTTON_WIDTH - 5;
+            int buttonY = y + (OPTION_HEIGHT - BUTTON_HEIGHT) / 2;
+
+            boolean hovered = isButtonHovered(mouseX, mouseY);
+            int buttonColor = hovered ? 0xFF404040 : 0xFF303030;
+            int buttonBorder = hovered ? 0xFFCCCCCC : 0xFF808080;
+
+            context.fill(buttonX, buttonY, buttonX + BUTTON_WIDTH, buttonY + BUTTON_HEIGHT, buttonBorder);
+            context.fill(buttonX + 1, buttonY + 1, buttonX + BUTTON_WIDTH - 1, buttonY + BUTTON_HEIGHT - 1, buttonColor);
+
+            String buttonText = value ? "true" : "false";
+            int textColor = value ? 0x00be00 : 0xbe0000;
+            int textWidth = textRenderer.getWidth(buttonText);
+            context.drawText(
+                    textRenderer,
+                    buttonText,
+                    buttonX + (BUTTON_WIDTH - textWidth) / 2,
+                    buttonY + (BUTTON_HEIGHT - 8) / 2,
+                    textColor,
+                    true
+            );
+        }
+
+        public boolean isButtonHovered(double mouseX, double mouseY) {
+            int buttonX = x + width - BUTTON_WIDTH - 5;
+            int buttonY = y + (OPTION_HEIGHT - BUTTON_HEIGHT) / 2;
+            return mouseX >= buttonX && mouseX <= buttonX + BUTTON_WIDTH &&
+                    mouseY >= buttonY && mouseY <= buttonY + BUTTON_HEIGHT;
+        }
+
+        @Override
+        public void onClick(double mouseX, double mouseY) {
+            if (isButtonHovered(mouseX, mouseY)) {
+                value = !value;
+                saveValue();
+            }
+        }
+
+        @Override
+        protected void saveValue() {
+            try {
+                // Update config and save
+                field.setBoolean(ClientConfigManager.getConfig(), value);
+                ClientConfigManager.save();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Implementation for String config options
+     */
+    private class StringConfigOption extends ConfigOption<String> {
+        private static final int FIELD_WIDTH = 60;
+        private static final int FIELD_HEIGHT = 16;
+        protected TextFieldWidget textField;
+
+        public StringConfigOption(String name, Field field, String initialValue, int x, int y, int width) {
+            super(name, field, initialValue, x, y, width);
+        }
+
+        public void createTextField(net.minecraft.client.MinecraftClient client) {
+            int fieldX = x + width - FIELD_WIDTH - 5;
+            int fieldY = y + (OPTION_HEIGHT - FIELD_HEIGHT) / 2;
+
+            textField = new TextFieldWidget(
+                    textRenderer,
+                    fieldX,
+                    fieldY,
+                    FIELD_WIDTH,
+                    FIELD_HEIGHT,
+                    Text.literal("")
+            );
+
+            textField.setText(value);
+            textField.setMaxLength(10);
+            textField.setChangedListener(this::onTextChanged);
+        }
+
+        public TextFieldWidget getTextField() {
+            return textField;
+        }
+
+        public void updateTextFieldPosition() {
+            if (textField != null) {
+                int fieldX = x + width - FIELD_WIDTH - 5;
+                int fieldY = y + (OPTION_HEIGHT - FIELD_HEIGHT) / 2;
+                textField.setX(fieldX);
+                textField.setY(fieldY);
+            }
+        }
+
+        @Override
+        public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+            context.drawText(textRenderer, name, x + 5, y + (OPTION_HEIGHT - 8) / 2, 0xFFFFFF, true);
+
+            if (textField != null) {
+                textField.render(context, mouseX, mouseY, delta);
+            }
+        }
+
+        @Override
+        public void onClick(double mouseX, double mouseY) {
+        }
+
+        public void onTextChanged(String text) {
+            try {
+                value = text;
+                saveValue();
+            } catch (NumberFormatException e) {}
+        }
+
+        @Override
+        protected void saveValue() {
+            try {
+                field.set(ClientConfigManager.getConfig(), value);
+                ClientConfigManager.save();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Base class for numeric config options (int and float)
+     */
+    private abstract class NumericConfigOption<T extends Number> extends ConfigOption<T> {
+        private static final int FIELD_WIDTH = 60;
+        private static final int FIELD_HEIGHT = 16;
+        protected TextFieldWidget textField;
+
+        public NumericConfigOption(String name, Field field, T initialValue, int x, int y, int width) {
+            super(name, field, initialValue, x, y, width);
+        }
+
+        public void createTextField(net.minecraft.client.MinecraftClient client) {
+            int fieldX = x + width - FIELD_WIDTH - 5;
+            int fieldY = y + (OPTION_HEIGHT - FIELD_HEIGHT) / 2;
+
+            textField = new TextFieldWidget(
+                    textRenderer,
+                    fieldX,
+                    fieldY,
+                    FIELD_WIDTH,
+                    FIELD_HEIGHT,
+                    Text.literal("")
+            );
+
+            textField.setText(value.toString());
+            textField.setMaxLength(10);
+            textField.setChangedListener(this::onTextChanged);
+        }
+
+        public TextFieldWidget getTextField() {
+            return textField;
+        }
+
+        public void updateTextFieldPosition() {
+            if (textField != null) {
+                int fieldX = x + width - FIELD_WIDTH - 5;
+                int fieldY = y + (OPTION_HEIGHT - FIELD_HEIGHT) / 2;
+                textField.setX(fieldX);
+                textField.setY(fieldY);
+            }
+        }
+
+        @Override
+        public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+            context.drawText(textRenderer, name, x + 5, y + (OPTION_HEIGHT - 8) / 2, 0xFFFFFF, true);
+
+            if (textField != null) {
+                textField.render(context, mouseX, mouseY, delta);
+            }
+        }
+
+        @Override
+        public void onClick(double mouseX, double mouseY) {}
+
+        protected abstract void onTextChanged(String text);
+    }
+
+    /**
+     * Implementation for integer config options
+     */
+    private class IntegerConfigOption extends NumericConfigOption<Integer> {
+        public IntegerConfigOption(String name, Field field, Integer initialValue, int x, int y, int width) {
+            super(name, field, initialValue, x, y, width);
+        }
+
+        @Override
+        protected void onTextChanged(String text) {
+            try {
+                value = Integer.parseInt(text);
+                saveValue();
+            } catch (NumberFormatException e) {}
+        }
+
+        @Override
+        protected void saveValue() {
+            try {
+                field.setInt(ClientConfigManager.getConfig(), value);
+                ClientConfigManager.save();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Implementation for float config options
+     */
+    private class FloatConfigOption extends NumericConfigOption<Float> {
+        public FloatConfigOption(String name, Field field, Float initialValue, int x, int y, int width) {
+            super(name, field, initialValue, x, y, width);
+        }
+
+        @Override
+        protected void onTextChanged(String text) {
+            try {
+                value = Float.parseFloat(text);
+                saveValue();
+            } catch (NumberFormatException e) {}
+        }
+
+        @Override
+        protected void saveValue() {
+            try {
+                field.setFloat(ClientConfigManager.getConfig(), value);
+                ClientConfigManager.save();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

src/client/java/wtf/hak/survivalfabric/modmenu/ModMenuIntegration.java

@@ -0,0 +1,15 @@
+package wtf.hak.survivalfabric.modmenu;
+
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import com.terraformersmc.modmenu.api.ModMenuApi;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+@Environment(EnvType.CLIENT)
+public class ModMenuIntegration implements ModMenuApi {
+
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory() {
+        return ConfigScreen::new;
+    }
+}

src/client/resources/survivalfabric.client.mixins.json

@@ -0,0 +1,13 @@
+{
+  "required": true,
+  "package": "wtf.hak.survivalfabric.mixin.client",
+  "compatibilityLevel": "JAVA_21",
+  "client": [
+    "BackgroundRendererMixin",
+    "BlockEntityRendererMixin",
+    "EntityMixin"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

src/main/java/wtf/hak/survivalfabric/SurvivalFabric.java

@@ -1,7 +1,6 @@
 package wtf.hak.survivalfabric;
 
 import net.fabricmc.api.ModInitializer;
-
 import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerEntityEvents;
 import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
@@ -11,8 +10,8 @@ import org.slf4j.LoggerFactory;
 import wtf.hak.survivalfabric.commands.ReloadConfigCommand;
 import wtf.hak.survivalfabric.commands.SlimeChunkCommand;
 import wtf.hak.survivalfabric.commands.SpectatorCommand;
-import wtf.hak.survivalfabric.sharedenderchest.SharedEnderChest;
-import wtf.hak.survivalfabric.veinminer.VeinMinerEvents;
+import wtf.hak.survivalfabric.features.sharedenderchest.SharedEnderChest;
+import wtf.hak.survivalfabric.features.veinminer.VeinMinerEvents;
 
 import static wtf.hak.survivalfabric.config.ConfigManager.getConfig;
 
@@ -24,19 +23,18 @@ public class SurvivalFabric implements ModInitializer {
 
     @Override
     public void onInitialize() {
-		CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> SpectatorCommand.register(dispatcher, new String[] { "spectator", "s", "S", "camera", "c", "C", }));
-		CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> ReloadConfigCommand.register(dispatcher, new String[] { "reloadsurvivalconfig" }));
-		CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> SlimeChunkCommand.register(dispatcher, new String[] { "slimechunk", "sc" }));
+        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> SpectatorCommand.register(dispatcher, "spectator", "s", "S", "camera", "c", "C"));
+        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> ReloadConfigCommand.register(dispatcher, "reloadsurvivalconfig"));
+        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> SlimeChunkCommand.register(dispatcher, "slimechunk", "sc"));
 
         if (getConfig().sharedEnderChestEnabled)
             new SharedEnderChest().onInitialize();
 
         if (getConfig().veinMinerEnabled) {
             PlayerBlockBreakEvents.BEFORE.register((world, player, pos, state, blockEntity) -> {
-				if (player instanceof ServerPlayerEntity serverPlayer) {
+                if (player instanceof ServerPlayerEntity serverPlayer && getConfig().veinMinerEnabled) {
                     return VeinMinerEvents.beforeBlockBreak(world, serverPlayer, pos, state);
-				}
-				else {
+                } else {
                     return true;
                 }
             });

src/main/java/wtf/hak/survivalfabric/commands/SlimeChunkCommand.java

@@ -6,11 +6,9 @@ import net.minecraft.server.command.CommandManager;
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.text.Text;
-import net.minecraft.util.math.random.CheckedRandom;
 import net.minecraft.util.math.random.ChunkRandom;
 import net.minecraft.util.math.random.Random;
 import net.minecraft.world.chunk.Chunk;
-import wtf.hak.survivalfabric.config.ConfigManager;
 
 import static wtf.hak.survivalfabric.config.ConfigManager.getConfig;
 

src/main/java/wtf/hak/survivalfabric/commands/SpectatorCommand.java

@@ -8,7 +8,7 @@ import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.text.Text;
 import net.minecraft.world.GameMode;
-import wtf.hak.survivalfabric.utils.Utils;
+import wtf.hak.survivalfabric.utils.PacketUtils;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -36,7 +36,7 @@ public class SpectatorCommand {
             player.teleport(data.world, data.x, data.y, data.z, Set.of(), data.yaw, data.pitch, false);
             player.changeGameMode(GameMode.SURVIVAL);
             spectating.remove(player);
-            Utils.updateListNames(player);
+            PacketUtils.updateListNames(player);
         } else {
 
             spectating.put(player, new LocationData(player
@@ -47,7 +47,7 @@ public class SpectatorCommand {
                     .getPitch(), player
                     .getServerWorld()));
             player.changeGameMode(GameMode.SPECTATOR);
-            Utils.updateListNames(player);
+            PacketUtils.updateListNames(player);
         }
         return 1;
     }

src/main/java/wtf/hak/survivalfabric/config/Config.java

@@ -38,6 +38,8 @@ public class Config {
     public boolean veinMinerEnabled = true;
     public int maxVeinSize = 99999;
 
+    public boolean chatCalcEnabled = true;
+
     public ScreenHandlerType<GenericContainerScreenHandler> screenHandlerType() {
         return switch (sharedEnderChestRows) {
             case 1 -> ScreenHandlerType.GENERIC_9X1;

src/main/java/wtf/hak/survivalfabric/features/sharedenderchest/SharedEnderChest.java

@@ -1,15 +1,9 @@
-package wtf.hak.survivalfabric.sharedenderchest;
+package wtf.hak.survivalfabric.features.sharedenderchest;
 
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-
-import net.fabricmc.fabric.api.event.player.UseBlockCallback;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
-
+import net.fabricmc.fabric.api.event.player.UseBlockCallback;
+import net.minecraft.block.Blocks;
 import net.minecraft.block.EnderChestBlock;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.inventory.Inventories;
@@ -23,11 +17,14 @@ import net.minecraft.server.MinecraftServer;
 import net.minecraft.sound.SoundCategory;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.text.Text;
-import net.minecraft.util.*;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.WorldSavePath;
 import net.minecraft.util.collection.DefaultedList;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
+import java.io.*;
+
 import static wtf.hak.survivalfabric.SurvivalFabric.LOGGER;
 import static wtf.hak.survivalfabric.config.ConfigManager.getConfig;
 
@@ -37,6 +34,51 @@ public class SharedEnderChest implements ServerLifecycleEvents.ServerStopping, S
 
     private long ticksUntilSave = -20;
 
+    public static void saveInventory(MinecraftServer server) {
+        File inventoryFile = getFile(server);
+        NbtCompound nbt = new NbtCompound();
+        DefaultedList<ItemStack> inventoryItemStacks = DefaultedList.ofSize(getConfig().sharedEnderChestRows * 9, ItemStack.EMPTY);
+        Inventories.writeNbt(nbt, sharedInventory.getList(inventoryItemStacks), server.getRegistryManager());
+        try (FileOutputStream inventoryFileOutputStream = new FileOutputStream(inventoryFile);
+             DataOutputStream inventoryFileDataOutput = new DataOutputStream(inventoryFileOutputStream)) {
+            inventoryFile.createNewFile();
+            NbtIo.writeCompressed(nbt, inventoryFileDataOutput);
+        } catch (Exception e) {
+            LOGGER.error("Error while saving Shared Ender Chest: " + e);
+        }
+    }
+
+    public static void openSharedEnderChest(PlayerEntity player, World world, BlockPos pos) {
+        fakeEnderChestOpen(world, pos, true);
+        sharedInventory.openedEnderChests.put(player, pos);
+        player.openHandledScreen(new SimpleNamedScreenHandlerFactory((int_1, playerInventory, playerEntity) ->
+                new GenericContainerScreenHandler(getConfig().screenHandlerType(), int_1, playerInventory, sharedInventory, getConfig().sharedEnderChestRows), Text.of(getConfig().sharedEnderChestName)));
+    }
+
+    public static void playEnderChestOpenSound(World world, BlockPos pos) {
+        world.playSound(null, pos, SoundEvents.BLOCK_ENDER_CHEST_OPEN, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.1F + 0.9F);
+    }
+
+    public static void playEnderChestCloseSound(World world, BlockPos pos) {
+        world.playSound(null, pos, SoundEvents.BLOCK_ENDER_CHEST_CLOSE, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.1F + 0.9F);
+    }
+
+    public static void fakeEnderChestOpen(World world, BlockPos pos, boolean open) {
+        if (!(world.getBlockState(pos).getBlock() instanceof EnderChestBlock)) {
+            return;
+        }
+
+        if (open)
+            playEnderChestOpenSound(world, pos);
+        else
+            playEnderChestCloseSound(world, pos);
+        world.addSyncedBlockEvent(pos, Blocks.ENDER_CHEST, 1, open ? 1 : 0);
+    }
+
+    private static File getFile(MinecraftServer server) {
+        return server.getSavePath(WorldSavePath.ROOT).resolve("sharedenderchest.sav").toFile();
+    }
+
     public void onServerStarted(MinecraftServer server) {
         File inventoryFile = getFile(server);
         if (inventoryFile.exists()) {
@@ -55,19 +97,6 @@ public class SharedEnderChest implements ServerLifecycleEvents.ServerStopping, S
         }
     }
 
-    public static void saveInventory(MinecraftServer server) {
-        File inventoryFile = getFile(server);
-        NbtCompound nbt = new NbtCompound();
-        DefaultedList<ItemStack> inventoryItemStacks = DefaultedList.ofSize(getConfig().sharedEnderChestRows * 9, ItemStack.EMPTY);
-        Inventories.writeNbt(nbt, sharedInventory.getList(inventoryItemStacks), server.getRegistryManager());
-        try (FileOutputStream inventoryFileOutputStream = new FileOutputStream(inventoryFile);
-             DataOutputStream inventoryFileDataOutput = new DataOutputStream(inventoryFileOutputStream)) {
-            inventoryFile.createNewFile();
-            NbtIo.writeCompressed(nbt, inventoryFileDataOutput);
-        } catch (Exception e) {
-            LOGGER.error("Error while saving Shared Ender Chest: " + e);
-        }
-    }
     public void onServerStopping(MinecraftServer server) {
         saveInventory(server);
     }
@@ -88,15 +117,13 @@ public class SharedEnderChest implements ServerLifecycleEvents.ServerStopping, S
                 if (!player.isSpectator()) {
                     if (!getConfig().sharedEnderChestLimitedAccess) {
                         if (world.isClient()) return ActionResult.SUCCESS;
-                        playEnderChestOpenSound(world, hitResult.getBlockPos());
-                        openSharedEnderChest(player);
+                        openSharedEnderChest(player, world, hitResult.getBlockPos());
                         return ActionResult.SUCCESS;
                     } else {
                         for (String name : getConfig().sharedEnderChestNames) {
                             if (name.toLowerCase().strip().equalsIgnoreCase(player.getNameForScoreboard().toLowerCase())) {
                                 if (world.isClient()) return ActionResult.SUCCESS;
-                                playEnderChestOpenSound(world, hitResult.getBlockPos());
-                                openSharedEnderChest(player);
+                                openSharedEnderChest(player, world, hitResult.getBlockPos());
                                 return ActionResult.SUCCESS;
                             }
                         }
@@ -113,17 +140,4 @@ public class SharedEnderChest implements ServerLifecycleEvents.ServerStopping, S
 
     }
 
-    public static void openSharedEnderChest(PlayerEntity player) {
-        player.openHandledScreen(new SimpleNamedScreenHandlerFactory((int_1, playerInventory, playerEntity) ->
-                new GenericContainerScreenHandler(getConfig().screenHandlerType(), int_1, playerInventory, sharedInventory, getConfig().sharedEnderChestRows), Text.of(getConfig().sharedEnderChestName)));
-    }
-
-    public static void playEnderChestOpenSound(World world, BlockPos pos) {
-        world.playSound(null, pos, SoundEvents.BLOCK_ENDER_CHEST_OPEN, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.1F + 0.9F);
-    }
-
-    private static File getFile(MinecraftServer server) {
-        return server.getSavePath(WorldSavePath.ROOT).resolve("sharedenderchest.sav").toFile();
-    }
-
 }

src/main/java/wtf/hak/survivalfabric/features/sharedenderchest/SharedInventory.java

@@ -1,14 +1,18 @@
-package wtf.hak.survivalfabric.sharedenderchest;
+package wtf.hak.survivalfabric.features.sharedenderchest;
+
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.inventory.Inventories;
 import net.minecraft.inventory.Inventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.collection.DefaultedList;
+import net.minecraft.util.math.BlockPos;
 
-import java.util.Iterator;
+import java.util.HashMap;
+import java.util.Map;
 
 public class SharedInventory implements Inventory {
 
+    public final Map<PlayerEntity, BlockPos> openedEnderChests = new HashMap<>();
     private final DefaultedList<ItemStack> stacks;
 
     public SharedInventory(int inventoryRows) {
@@ -19,28 +23,6 @@ public class SharedInventory implements Inventory {
         this.stacks = dl;
     }
 
-    /*
-    @Override
-    public void onClose(PlayerEntity player) {
-        Inventory.super.onClose(player);
-        EnderChestBlockEntity blockEntity = enderChests.remove(player);
-        if (blockEntity != null)
-            blockEntity.onClose(player);
-    }
-
-    @Override
-    public void onOpen(PlayerEntity player) {
-        Inventory.super.onOpen(player);
-        EnderChestBlockEntity blockEntity = enderChests.get(player);
-        if (blockEntity != null)
-            blockEntity.onOpen(player);
-    }
-
-    public void setBlockEntity(PlayerEntity player, EnderChestBlockEntity be) {
-        enderChests.put(player, be);
-    }
-    */
-
 
     public DefaultedList<ItemStack> getList(DefaultedList<ItemStack> dl) {
         dl = stacks;
@@ -54,7 +36,7 @@ public class SharedInventory implements Inventory {
 
     @Override
     public boolean isEmpty() {
-        Iterator<ItemStack> var1 = this.stacks.iterator();
+        var var1 = this.stacks.iterator();
 
         ItemStack itemStack_1;
         do {
@@ -62,7 +44,7 @@ public class SharedInventory implements Inventory {
                 return true;
             }
 
-            itemStack_1 = (ItemStack)var1.next();
+            itemStack_1 = var1.next();
         } while (itemStack_1.isEmpty());
 
         return false;
@@ -75,12 +57,7 @@ public class SharedInventory implements Inventory {
 
     @Override
     public ItemStack removeStack(int int_1, int int_2) {
-        ItemStack itemStack_1 = Inventories.splitStack(this.stacks, int_1, int_2);
-        if (!itemStack_1.isEmpty()) {
-            //this.container.onContentChanged(this);
-        }
-
-        return itemStack_1;
+        return Inventories.splitStack(this.stacks, int_1, int_2);
     }
 
     @Override
@@ -91,7 +68,6 @@ public class SharedInventory implements Inventory {
     @Override
     public void setStack(int i, ItemStack itemStack) {
         this.stacks.set(i, itemStack);
-        //this.container.onContentChanged(this);
     }
 
     @Override
@@ -108,4 +84,12 @@ public class SharedInventory implements Inventory {
     public void clear() {
         stacks.clear();
     }
+
+    @Override
+    public void onClose(PlayerEntity player) {
+        BlockPos pos = openedEnderChests.remove(player);
+        if (openedEnderChests.containsValue(pos))
+            return;
+        SharedEnderChest.fakeEnderChestOpen(player.getWorld(), pos, false);
+    }
 }

src/main/java/wtf/hak/survivalfabric/features/veinminer/Drill.java

@@ -1,10 +1,12 @@
-package wtf.hak.survivalfabric.veinminer;
+package wtf.hak.survivalfabric.features.veinminer;
 
 import net.minecraft.block.BlockState;
 import net.minecraft.util.math.BlockPos;
 
 public interface Drill {
     boolean canHandle(BlockState blockState);
+
     boolean isRightTool(BlockPos pos);
+
     boolean drill(BlockPos blockPos);
 }

src/main/java/wtf/hak/survivalfabric/features/veinminer/VeinMinerEvents.java

@@ -1,15 +1,14 @@
-package wtf.hak.survivalfabric.veinminer;
+package wtf.hak.survivalfabric.features.veinminer;
 
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.Entity;
-import net.minecraft.registry.Registries;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
-import wtf.hak.survivalfabric.veinminer.drills.LeavesDrill;
-import wtf.hak.survivalfabric.veinminer.drills.OreDrill;
-import wtf.hak.survivalfabric.veinminer.drills.WoodDrill;
+import wtf.hak.survivalfabric.features.veinminer.drills.LeavesDrill;
+import wtf.hak.survivalfabric.features.veinminer.drills.OreDrill;
+import wtf.hak.survivalfabric.features.veinminer.drills.WoodDrill;
 
 public class VeinMinerEvents {
 
@@ -25,8 +24,7 @@ public class VeinMinerEvents {
             boolean shouldContinue = !mine(session);
             session.finish();
             return shouldContinue;
-        }
-        else {
+        } else {
             return true;
         }
     }

src/main/java/wtf/hak/survivalfabric/features/veinminer/VeinMinerSession.java

@@ -1,21 +1,29 @@
-package wtf.hak.survivalfabric.veinminer;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
+package wtf.hak.survivalfabric.features.veinminer;
 
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
 
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+
 public class VeinMinerSession {
-    private static ArrayList<VeinMinerSession> sessions = new ArrayList<>();
+    private static final ArrayList<VeinMinerSession> sessions = new ArrayList<>();
 
     public ServerPlayerEntity player;
     public ServerWorld world;
     public Set<BlockPos> positions;
     public BlockPos initialPos;
 
+    private VeinMinerSession(ServerPlayerEntity player, ServerWorld world, BlockPos initialPos) {
+        this.player = player;
+        this.world = world;
+        this.initialPos = initialPos;
+        this.positions = new HashSet<>();
+        positions.add(initialPos);
+    }
+
     public static VeinMinerSession sessionForPlayer(ServerPlayerEntity player) {
         for (var session : sessions) {
             if (session.player == player) {
@@ -44,14 +52,6 @@ public class VeinMinerSession {
         sessions.remove(session);
     }
 
-    private VeinMinerSession(ServerPlayerEntity player, ServerWorld world, BlockPos initialPos) {
-        this.player = player;
-        this.world = world;
-        this.initialPos = initialPos;
-        this.positions = new HashSet<>();
-        positions.add(initialPos);
-    }
-
     public void addPosition(BlockPos pos) {
         positions.add(pos);
     }

src/main/java/wtf/hak/survivalfabric/features/veinminer/drills/DrillBase.java

@@ -1,15 +1,15 @@
-package wtf.hak.survivalfabric.veinminer.drills;
+package wtf.hak.survivalfabric.features.veinminer.drills;
+
 import net.minecraft.block.BlockState;
-
-import java.util.ArrayList;
-
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.text.MutableText;
 import net.minecraft.text.PlainTextContent;
 import net.minecraft.text.Text;
 import net.minecraft.util.math.BlockPos;
-import wtf.hak.survivalfabric.veinminer.Drill;
-import wtf.hak.survivalfabric.veinminer.VeinMinerSession;
+import wtf.hak.survivalfabric.features.veinminer.Drill;
+import wtf.hak.survivalfabric.features.veinminer.VeinMinerSession;
+
+import java.util.ArrayList;
 
 import static wtf.hak.survivalfabric.SurvivalFabric.LOGGER;
 
@@ -37,14 +37,6 @@ public class DrillBase implements Drill {
         return session.player.getMainHandStack().isSuitableFor(blockState);
     }
 
-    protected interface ForXYZHandler {
-        public void handle(BlockPos pos);
-    }
-
-    protected interface ForXYZCounter {
-        public int handle(BlockPos pos);
-    }
-
     protected void forXYZ(BlockPos pos, int max, ForXYZHandler handler) {
         forXYZ(pos, max, handlerPos -> {
             handler.handle(handlerPos);
@@ -75,20 +67,17 @@ public class DrillBase implements Drill {
         String[] order = new String[]{"x", "y", "z"};
         if (forceVertical) {
             order = new String[]{"y", "x", "z"};
-        }
-        else {
+        } else {
             ServerPlayerEntity player = session.player;
             boolean majorPitchChange = player.getPitch() < -45.0 || player.getPitch() > 45.0;
             boolean majorYawChange = (player.getYaw() > 45.0 && player.getYaw() < 135.0) || (player.getYaw() < -45.0 && player.getYaw() > -135.0);
             if (majorPitchChange) {
                 if (majorYawChange) {
                     order = new String[]{"y", "z", "x"};
-                }
-                else {
+                } else {
                     order = new String[]{"y", "x", "z"};
                 }
-            }
-            else {
+            } else {
                 if (majorYawChange) {
                     order = new String[]{"z", "y", "x"};
                 }
@@ -130,4 +119,12 @@ public class DrillBase implements Drill {
         session.player.sendMessage(text);
         LOGGER.info(message);
     }
+
+    protected interface ForXYZHandler {
+        void handle(BlockPos pos);
+    }
+
+    protected interface ForXYZCounter {
+        int handle(BlockPos pos);
+    }
 }

src/main/java/wtf/hak/survivalfabric/features/veinminer/drills/LeavesDrill.java

@@ -1,4 +1,4 @@
-package wtf.hak.survivalfabric.veinminer.drills;
+package wtf.hak.survivalfabric.features.veinminer.drills;
 
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
@@ -7,7 +7,7 @@ import net.minecraft.registry.tag.TagKey;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
-import wtf.hak.survivalfabric.veinminer.VeinMinerSession;
+import wtf.hak.survivalfabric.features.veinminer.VeinMinerSession;
 
 import java.util.ArrayDeque;
 
@@ -15,12 +15,12 @@ import static wtf.hak.survivalfabric.config.ConfigManager.getConfig;
 
 public class LeavesDrill extends DrillBase {
 
+    public static final TagKey<Block> leavesTag = TagKey.of(RegistryKeys.BLOCK, Identifier.of("survivalfabric", "leaves"));
+
     public LeavesDrill(VeinMinerSession session) {
         super(session);
     }
 
-    public static final TagKey<Block> leavesTag = TagKey.of(RegistryKeys.BLOCK, Identifier.of("survivalfabric", "leaves"));
-
     @Override
     public boolean canHandle(BlockState blockState) {
         return blockState.isIn(leavesTag);

src/main/java/wtf/hak/survivalfabric/features/veinminer/drills/OreDrill.java

@@ -1,4 +1,4 @@
-package wtf.hak.survivalfabric.veinminer.drills;
+package wtf.hak.survivalfabric.features.veinminer.drills;
 
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
@@ -6,23 +6,21 @@ import net.minecraft.registry.RegistryKeys;
 import net.minecraft.registry.tag.TagKey;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import wtf.hak.survivalfabric.features.veinminer.VeinMinerSession;
 
 import java.util.ArrayDeque;
 
-import net.minecraft.registry.Registries;
-import net.minecraft.util.math.BlockPos;
-import wtf.hak.survivalfabric.veinminer.VeinMinerSession;
-
 import static wtf.hak.survivalfabric.config.ConfigManager.getConfig;
 
 public class OreDrill extends DrillBase {
 
+    public static final TagKey<Block> oreTag = TagKey.of(RegistryKeys.BLOCK, Identifier.of("survivalfabric", "ore"));
+
     public OreDrill(VeinMinerSession session) {
         super(session);
     }
 
-    public static final TagKey<Block> oreTag = TagKey.of(RegistryKeys.BLOCK, Identifier.of("survivalfabric", "ore"));
-
     @Override
     public boolean canHandle(BlockState blockState) {
         return blockState.isIn(oreTag);

src/main/java/wtf/hak/survivalfabric/features/veinminer/drills/WoodDrill.java

@@ -1,29 +1,27 @@
-package wtf.hak.survivalfabric.veinminer.drills;
+package wtf.hak.survivalfabric.features.veinminer.drills;
 
+import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
+import net.minecraft.registry.Registries;
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.registry.tag.TagKey;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Identifier;
-
+import net.minecraft.util.math.BlockPos;
+import wtf.hak.survivalfabric.features.veinminer.VeinMinerSession;
 
 import java.util.ArrayDeque;
 
-import net.minecraft.block.Block;
-import net.minecraft.registry.Registries;
-import net.minecraft.util.math.BlockPos;
-import wtf.hak.survivalfabric.veinminer.VeinMinerSession;
-
 import static wtf.hak.survivalfabric.config.ConfigManager.getConfig;
 
 public class WoodDrill extends DrillBase {
 
+    public static final TagKey<Block> woodTag = TagKey.of(RegistryKeys.BLOCK, Identifier.of("survivalfabric", "wood"));
+
     public WoodDrill(VeinMinerSession session) {
         super(session);
     }
 
-    public static final TagKey<Block> woodTag = TagKey.of(RegistryKeys.BLOCK, Identifier.of("survivalfabric", "wood"));
-
     @Override
     public boolean canHandle(BlockState blockState) {
         return blockState.isIn(woodTag);
@@ -33,8 +31,8 @@ public class WoodDrill extends DrillBase {
     public boolean drill(BlockPos startPos) {
         ServerWorld world = session.world;
         int broken = 0;
-        ArrayDeque<BlockPos> pendingLogs = new ArrayDeque<BlockPos>();
-        ArrayDeque<BlockPos> logBlocks = new ArrayDeque<BlockPos>();
+        ArrayDeque<BlockPos> pendingLogs = new ArrayDeque<>();
+        ArrayDeque<BlockPos> logBlocks = new ArrayDeque<>();
         pendingLogs.add(startPos);
 
         String leavesBlockId = Registries.BLOCK.getId(world.getBlockState(startPos).getBlock()).toString().replace("_log", "_leaves");
@@ -57,11 +55,8 @@ public class WoodDrill extends DrillBase {
             }
         }
 
-        // second round, leaves
-        // The pending blocks are all air now,
         ArrayDeque<BlockPos> pendingLeaves = logBlocks;
         while (!pendingLeaves.isEmpty() && broken < getConfig().maxVeinSize) {
-            // remove the immediately surrounding leaves around the log blocks
             broken += forXYZ(pendingLeaves.remove(), 1, newPos -> {
                 int brokenLeaves = 0;
                 Block newBlock = world.getBlockState(newPos).getBlock();

src/main/java/wtf/hak/survivalfabric/mixin/PlayerManagerMixin.java

@@ -16,7 +16,6 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import wtf.hak.survivalfabric.commands.SpectatorCommand;
 import wtf.hak.survivalfabric.config.ConfigManager;
 
-import java.util.Objects;
 import java.util.Set;
 
 @Mixin(PlayerManager.class)
@@ -24,7 +23,7 @@ public abstract class PlayerManagerMixin {
 
     @Inject(method = {"onPlayerConnect"}, at = {@At(value = "INVOKE", target = "Lnet/minecraft/server/PlayerManager;broadcast(Lnet/minecraft/text/Text;Z)V")})
     public void onPlayerConnect(ClientConnection connection, ServerPlayerEntity player, ConnectedClientData clientData, CallbackInfo ci) {
-        if(ConfigManager.getConfig().joinMessageEnabled) {
+        if (ConfigManager.getConfig().joinMessageEnabled && !player.getServer().isSingleplayer()) {
             Text text = Text.literal(String.format(ConfigManager.getConfig().joinMessage, player.getName().getString()));
             player.sendMessage(text, false);
         }
@@ -50,10 +49,81 @@ public abstract class PlayerManagerMixin {
 
     @Inject(method = {"broadcast(Lnet/minecraft/network/message/SignedMessage;Lnet/minecraft/server/network/ServerPlayerEntity;Lnet/minecraft/network/message/MessageType$Parameters;)V"}, at = {@At("HEAD")}, cancellable = true)
     private void onBroadcast(SignedMessage message, ServerPlayerEntity sender, MessageType.Parameters parameters, CallbackInfo ci) {
-        if(sender != null && ConfigManager.getConfig().chatMessageEnabled) {
-            Text text = Text.literal(String.format(ConfigManager.getConfig().chatMessage, sender.getName().getString(), message.getContent().getString()));
-            Objects.requireNonNull(sender.getServer()).getPlayerManager().broadcast(text, false);
+        if (sender != null) {
+            String rawMessage = message.getContent().getString().trim();
+            boolean isCalcEnabled = ConfigManager.getConfig().chatCalcEnabled;
+            boolean isMsgEnabled = ConfigManager.getConfig().chatMessageEnabled;
+
+            String processedMessage = rawMessage;
+
+            if (isCalcEnabled) {
+                String expression = rawMessage.endsWith("=") ? rawMessage.substring(0, rawMessage.length() - 1).trim() : rawMessage;
+                try {
+                    String result = String.valueOf(evaluateExpression(expression));
+                    StringBuilder sb = new StringBuilder(rawMessage).append("§6");
+
+                    if (rawMessage.contains(" ")) sb.append(" ");
+                    if (!rawMessage.endsWith("=")) sb.append("=");
+                    if (rawMessage.contains(" ")) sb.append(" ");
+
+                    sb.append(result.endsWith(".0") ? result.substring(0, result.length() - 2) : result);
+                    processedMessage = sb.toString();
+                } catch (Exception ignored) {}
+            }
+
+            if (isMsgEnabled) {
+                String formatted = String.format(ConfigManager.getConfig().chatMessage, sender.getName().getString(), processedMessage);
+                sender.getServer().getPlayerManager().broadcast(Text.literal(formatted), false);
+            } else if (isCalcEnabled) {
+                String formatted = "<" + sender.getName().getString() + "> " + processedMessage;
+                sender.getServer().getPlayerManager().broadcast(Text.literal(formatted), false);
+            }
+
             ci.cancel();
         }
+
+    }
+
+    private double evaluateExpression(String expression) {
+        return evaluate(expression.replaceAll("\\s", ""), new int[]{0});
+    }
+
+    private double evaluate(String expr, int[] index) {
+        double value = parseTerm(expr, index);
+        while (index[0] < expr.length()) {
+            char op = expr.charAt(index[0]);
+            if (op != '+' && op != '-') break;
+            index[0]++;
+            double nextTerm = parseTerm(expr, index);
+            value = (op == '+') ? value + nextTerm : value - nextTerm;
+        }
+        return value;
+    }
+
+    private double parseTerm(String expr, int[] index) {
+        double value = parseFactor(expr, index);
+        while (index[0] < expr.length()) {
+            char op = expr.charAt(index[0]);
+            if (op != '*' && op != '/') break;
+            index[0]++;
+            double nextFactor = parseFactor(expr, index);
+            value = (op == '*') ? value * nextFactor : value / nextFactor;
+        }
+        return value;
+    }
+
+    private double parseFactor(String expr, int[] index) {
+        if (expr.charAt(index[0]) == '(') {
+            index[0]++;
+            double value = evaluate(expr, index);
+            index[0]++; // Skip closing ')'
+            return value;
+        }
+
+        int start = index[0];
+        while (index[0] < expr.length() && (Character.isDigit(expr.charAt(index[0])) || expr.charAt(index[0]) == '.')) {
+            index[0]++;
+        }
+        return Double.parseDouble(expr.substring(start, index[0]));
     }
 }

src/main/java/wtf/hak/survivalfabric/mixin/ServerWorldMixin.java

@@ -7,7 +7,7 @@ import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import wtf.hak.survivalfabric.utils.Utils;
+import wtf.hak.survivalfabric.utils.PacketUtils;
 
 @Mixin(ServerWorld.class)
 public class ServerWorldMixin {
@@ -15,7 +15,7 @@ public class ServerWorldMixin {
     @Inject(method = "onDimensionChanged", at = {@At("HEAD")})
     public void onDimensionChange(Entity entity, CallbackInfo ci) {
         if (entity instanceof ServerPlayerEntity) {
-            Utils.updateListNames((ServerPlayerEntity)entity);
+            PacketUtils.updateListNames((ServerPlayerEntity) entity);
         }
     }
 }

src/main/java/wtf/hak/survivalfabric/utils/PacketUtils.java

@@ -5,7 +5,7 @@ import net.minecraft.server.network.ServerPlayerEntity;
 
 import java.util.Objects;
 
-public class Utils {
+public class PacketUtils {
 
     public static void updateListNames(ServerPlayerEntity p) {
         for (ServerPlayerEntity sp : Objects.requireNonNull(p.getServer()).getPlayerManager().getPlayerList()) {

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

@@ -0,0 +1,21 @@
+{
+  "category.survivalfabric.tpangles": "Teleportation Angles",
+  "key.survivalfabric.angle0": "-65.19 / -54.23",
+  "key.survivalfabric.angle1": "-24.86 / -54.23",
+  "key.survivalfabric.angle2": "-65.02 / -41.68",
+  "key.survivalfabric.angle3": "-25.03 / -41.71",
+  "key.survivalfabric.angle4": "24.81 / -54.23",
+  "key.survivalfabric.angle5": "65.14 / -54.23",
+  "key.survivalfabric.angle6": "24.98 / -41.68",
+  "key.survivalfabric.angle7": "64.97 / -41.71",
+  "key.survivalfabric.angle8": "114.81 / -54.23",
+  "key.survivalfabric.angle9": "155.14 / -54.23",
+  "key.survivalfabric.angle10": "114.98 / -41.68",
+  "key.survivalfabric.angle11": "154.97 / -41.71",
+  "key.survivalfabric.angle12": "204.81 / -54.23",
+  "key.survivalfabric.angle13": "245.14 / -54.23",
+  "key.survivalfabric.angle14": "204.98 / -41.68",
+  "key.survivalfabric.angle15": "244.97 / -41.71",
+  "category.survivalfabric.survivalfabric": "Survival Fabric",
+  "key.survivalfabric.camera": "/camera"
+}

src/main/resources/data/survivalfabric/tags/block/ore.json

@@ -9,6 +9,6 @@
     "#minecraft:coal_ores",
     "#minecraft:copper_ores",
     "minecraft:ancient_debris",
-    "minecraft:magma_block"
+    "minecraft:nether_quartz_ore"
   ]
 }

src/main/resources/fabric.mod.json

@@ -9,7 +9,8 @@
   ],
   "contact": {
     "homepage": "https://hak.wtf",
-		"sources": "https://git.hak.wtf/hkuijlman/SurvivalFabric"
+    "sources": "https://git.hak.wtf/hkuijlman/SurvivalFabric",
+    "issues": "https://git.hak.wtf/hkuijlman/SurvivalFabric/issues"
   },
   "license": "CC0-1.0",
   "icon": "assets/survivalfabric/icon.png",
@@ -18,20 +19,30 @@
     "main": [
       "wtf.hak.survivalfabric.SurvivalFabric"
     ],
+    "client": [
+      "wtf.hak.survivalfabric.SurvivalFabricClient"
+    ],
     "fabric-datagen": [
       "wtf.hak.survivalfabric.SurvivalFabricDataGenerator"
+    ],
+    "modmenu": [
+      "wtf.hak.survivalfabric.modmenu.ModMenuIntegration"
     ]
   },
   "mixins": [
-		"survivalfabric.mixins.json"
+    "survivalfabric.mixins.json",
+    {
+      "config": "survivalfabric.client.mixins.json",
+      "environment": "client"
+    }
   ],
   "depends": {
     "fabricloader": ">=0.16.10",
-		"minecraft": "~1.21.4",
+    "minecraft": "~1.21.5",
     "java": ">=21",
     "fabric-api": "*"
   },
-	"suggests": {
-
+  "optional": {
+    "modmenu": "*"
   }
 }