From c09b1b4dc964804e484d64507a6d52393b499948 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 05:23:16 +0100 Subject: [PATCH 01/20] Create base event handler for block break event. Made LOGGER public. --- src/main/java/dev/micle/xptools/XpTools.java | 2 +- .../events/common/OnBlockBreakEventHandler.java | 12 ++++++++++++ src/main/java/dev/micle/xptools/proxy/Proxy.java | 4 ++++ 3 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java diff --git a/src/main/java/dev/micle/xptools/XpTools.java b/src/main/java/dev/micle/xptools/XpTools.java index 257d91c..a1390a4 100644 --- a/src/main/java/dev/micle/xptools/XpTools.java +++ b/src/main/java/dev/micle/xptools/XpTools.java @@ -11,7 +11,7 @@ import org.slf4j.Logger; @Mod(XpTools.MOD_ID) public class XpTools { public static final String MOD_ID = "xp_tools"; - private static final Logger LOGGER = LogUtils.getLogger(); + public static final Logger LOGGER = LogUtils.getLogger(); private static FMLJavaModLoadingContext fmlJavaModLoadingContext; private static IProxy proxy; diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java new file mode 100644 index 0000000..5485e05 --- /dev/null +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -0,0 +1,12 @@ +package dev.micle.xptools.events.common; + +import dev.micle.xptools.XpTools; +import net.minecraftforge.event.level.BlockEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; + +public class OnBlockBreakEventHandler { + @SubscribeEvent + public void OnBlockBreakEvent(BlockEvent.BreakEvent event) { + XpTools.LOGGER.debug(String.valueOf(event.getExpToDrop())); + } +} diff --git a/src/main/java/dev/micle/xptools/proxy/Proxy.java b/src/main/java/dev/micle/xptools/proxy/Proxy.java index 1339e17..d6d4121 100644 --- a/src/main/java/dev/micle/xptools/proxy/Proxy.java +++ b/src/main/java/dev/micle/xptools/proxy/Proxy.java @@ -1,6 +1,7 @@ package dev.micle.xptools.proxy; import dev.micle.xptools.XpTools; +import dev.micle.xptools.events.common.OnBlockBreakEventHandler; import net.minecraft.client.Minecraft; import net.minecraft.server.MinecraftServer; import net.minecraft.world.entity.player.Player; @@ -27,6 +28,9 @@ public class Proxy implements IProxy { MinecraftForge.EVENT_BUS.addListener(Proxy::onAddReloadListeners); MinecraftForge.EVENT_BUS.addListener(Proxy::serverStarted); MinecraftForge.EVENT_BUS.addListener(Proxy::serverStopping); + + // Register event handlers + MinecraftForge.EVENT_BUS.register(new OnBlockBreakEventHandler()); } private static void setup(FMLCommonSetupEvent event) {} From 5e110dd3c8dd7e2885029f2b4bb85ea562ed4238 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 05:52:51 +0100 Subject: [PATCH 02/20] Created base config class. --- .../java/dev/micle/xptools/config/Config.java | 49 +++++++++++++++++++ .../java/dev/micle/xptools/proxy/Proxy.java | 3 ++ 2 files changed, 52 insertions(+) create mode 100644 src/main/java/dev/micle/xptools/config/Config.java diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java new file mode 100644 index 0000000..7ed2b7d --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -0,0 +1,49 @@ +package dev.micle.xptools.config; + +import dev.micle.xptools.XpTools; +import net.minecraftforge.common.ForgeConfigSpec; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.fml.config.ModConfig; +import org.apache.commons.lang3.tuple.Pair; + +@Mod.EventBusSubscriber(modid = XpTools.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) +public final class Config { + public static final Client CLIENT; + public static final ForgeConfigSpec CLIENT_SPEC; + public static final Common COMMON; + public static final ForgeConfigSpec COMMON_SPEC; + public static final Server SERVER; + public static final ForgeConfigSpec SERVER_SPEC; + + static { + Pair clientSpecPair = new ForgeConfigSpec.Builder().configure(Client::new); + CLIENT = clientSpecPair.getLeft(); + CLIENT_SPEC = clientSpecPair.getRight(); + + Pair commonSpecPair = new ForgeConfigSpec.Builder().configure(Common::new); + COMMON = commonSpecPair.getLeft(); + COMMON_SPEC = commonSpecPair.getRight(); + + Pair serverSpecPair = new ForgeConfigSpec.Builder().configure(Server::new); + SERVER = serverSpecPair.getLeft(); + SERVER_SPEC = serverSpecPair.getRight(); + } + + public static void register() { + XpTools.getFMLJavaModLoadingContext().registerConfig(ModConfig.Type.CLIENT, CLIENT_SPEC); + XpTools.getFMLJavaModLoadingContext().registerConfig(ModConfig.Type.COMMON, COMMON_SPEC); + XpTools.getFMLJavaModLoadingContext().registerConfig(ModConfig.Type.SERVER, SERVER_SPEC); + } + + public static class Client { + Client(ForgeConfigSpec.Builder builder) {} + } + + public static class Common { + Common(ForgeConfigSpec.Builder builder) {} + } + + public static class Server { + Server(ForgeConfigSpec.Builder builder) {} + } +} diff --git a/src/main/java/dev/micle/xptools/proxy/Proxy.java b/src/main/java/dev/micle/xptools/proxy/Proxy.java index d6d4121..eefac49 100644 --- a/src/main/java/dev/micle/xptools/proxy/Proxy.java +++ b/src/main/java/dev/micle/xptools/proxy/Proxy.java @@ -1,6 +1,7 @@ package dev.micle.xptools.proxy; import dev.micle.xptools.XpTools; +import dev.micle.xptools.config.Config; import dev.micle.xptools.events.common.OnBlockBreakEventHandler; import net.minecraft.client.Minecraft; import net.minecraft.server.MinecraftServer; @@ -18,6 +19,8 @@ public class Proxy implements IProxy { // Common setup public Proxy() { + Config.register(); + // Register mod event bus listeners IEventBus modEventBus = XpTools.getFMLJavaModLoadingContext().getModEventBus(); modEventBus.addListener(Proxy::setup); From 802321e9a21fc2cc7324f6c5c2fe9c13baee3061 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 16:33:57 +0100 Subject: [PATCH 03/20] Created config options for block breaking. --- .../java/dev/micle/xptools/config/Config.java | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 7ed2b7d..ec91f22 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -6,6 +6,9 @@ import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.config.ModConfig; import org.apache.commons.lang3.tuple.Pair; +import java.util.ArrayList; +import java.util.List; + @Mod.EventBusSubscriber(modid = XpTools.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) public final class Config { public static final Client CLIENT; @@ -44,6 +47,22 @@ public final class Config { } public static class Server { - Server(ForgeConfigSpec.Builder builder) {} + public static ForgeConfigSpec.BooleanValue BLOCK_BREAK_DEFAULT_NO_XP; + public static ForgeConfigSpec.ConfigValue> BLOCK_BREAK_OVERRIDES; + + Server(ForgeConfigSpec.Builder builder) { + builder.comment("Settings for block breaking").push("block_breaking"); + BLOCK_BREAK_DEFAULT_NO_XP = builder + .comment("Should all blocks drop 0 XP by default?") + .comment("(This makes multipliers not have any effect)") + .define("blockBreakXpDisabled", false); + BLOCK_BREAK_OVERRIDES = builder + .comment("List of all overrides. Format: '[block_id/tag],[multi/val],[min],[max]'") + .comment("Examples:") + .comment("'minecraft:dirt,val,2,2' - Makes minecraft's dirt blocks drop 2 XP") + .comment("'#forge:ores,multi,1,2' - Applies an XP multiplier between 1-2 to all blocks tagged forge:ores") + .define("blockBreakOverrides", new ArrayList<>()); + builder.pop(); + } } } From ec5f9a7daeb587b79d391d6fb182f7f4c92a2a7e Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 17:44:24 +0100 Subject: [PATCH 04/20] Created classes for holding override data. Updated config to generate the list of override items. --- .../java/dev/micle/xptools/config/Config.java | 21 +++++++-- .../micle/xptools/config/OverrideItem.java | 43 +++++++++++++++++++ .../micle/xptools/config/OverrideType.java | 16 +++++++ 3 files changed, 76 insertions(+), 4 deletions(-) create mode 100644 src/main/java/dev/micle/xptools/config/OverrideItem.java create mode 100644 src/main/java/dev/micle/xptools/config/OverrideType.java diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index ec91f22..12678c4 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -2,8 +2,10 @@ package dev.micle.xptools.config; import dev.micle.xptools.XpTools; import net.minecraftforge.common.ForgeConfigSpec; +import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.config.ModConfig; +import net.minecraftforge.fml.event.config.ModConfigEvent; import org.apache.commons.lang3.tuple.Pair; import java.util.ArrayList; @@ -47,16 +49,17 @@ public final class Config { } public static class Server { - public static ForgeConfigSpec.BooleanValue BLOCK_BREAK_DEFAULT_NO_XP; - public static ForgeConfigSpec.ConfigValue> BLOCK_BREAK_OVERRIDES; + public static ForgeConfigSpec.BooleanValue blockBreakDefaultNoXp; + private static ForgeConfigSpec.ConfigValue> blockBreakOverridesRaw; + public static List blockBreakOverrideItems; Server(ForgeConfigSpec.Builder builder) { builder.comment("Settings for block breaking").push("block_breaking"); - BLOCK_BREAK_DEFAULT_NO_XP = builder + blockBreakDefaultNoXp = builder .comment("Should all blocks drop 0 XP by default?") .comment("(This makes multipliers not have any effect)") .define("blockBreakXpDisabled", false); - BLOCK_BREAK_OVERRIDES = builder + blockBreakOverridesRaw = builder .comment("List of all overrides. Format: '[block_id/tag],[multi/val],[min],[max]'") .comment("Examples:") .comment("'minecraft:dirt,val,2,2' - Makes minecraft's dirt blocks drop 2 XP") @@ -64,5 +67,15 @@ public final class Config { .define("blockBreakOverrides", new ArrayList<>()); builder.pop(); } + + @SubscribeEvent + public static void onServerConfigReload(ModConfigEvent event) { + if (event.getConfig().getSpec() == SERVER_SPEC) { + blockBreakOverrideItems = new ArrayList<>(); + for (String s : blockBreakOverridesRaw.get()) { + blockBreakOverrideItems.add(new OverrideItem(s)); + } + } + } } } diff --git a/src/main/java/dev/micle/xptools/config/OverrideItem.java b/src/main/java/dev/micle/xptools/config/OverrideItem.java new file mode 100644 index 0000000..432d7f4 --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/OverrideItem.java @@ -0,0 +1,43 @@ +package dev.micle.xptools.config; + +public class OverrideItem { + private boolean isTag = false; + private String id = ""; + private OverrideType type = OverrideType.MULTIPLIER; + private float min = 1; + private float max = 1; + + public OverrideItem(String configString) { + String[] splitString = configString.split(","); + + if (splitString.length == 4) { + isTag = splitString[0].startsWith("#"); + id = isTag ? splitString[0].substring(1) : splitString[0]; + + type = OverrideType.valueOf(splitString[1]); + + min = Float.parseFloat(splitString[2]); + max = Float.parseFloat(splitString[3]); + } + } + + public boolean isTag() { + return isTag; + } + + public String getId() { + return id; + } + + public OverrideType getType() { + return type; + } + + public float getMin() { + return min; + } + + public float getMax() { + return max; + } +} diff --git a/src/main/java/dev/micle/xptools/config/OverrideType.java b/src/main/java/dev/micle/xptools/config/OverrideType.java new file mode 100644 index 0000000..dae9267 --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/OverrideType.java @@ -0,0 +1,16 @@ +package dev.micle.xptools.config; + +public enum OverrideType { + VALUE("val"), + MULTIPLIER("multi"); + + private final String name; + + OverrideType(String s) { + name = s; + } + + public String toString() { + return this.name; + } +} From 4425974fe161ef94e8d6a29a80aefffad5887e33 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 18:23:26 +0100 Subject: [PATCH 05/20] Changed overrides into operations. Added priority and isLast values to operations. --- .../java/dev/micle/xptools/config/Config.java | 24 ++++---- .../micle/xptools/config/OperationItem.java | 57 +++++++++++++++++++ .../micle/xptools/config/OperationType.java | 9 +++ .../micle/xptools/config/OverrideItem.java | 43 -------------- .../micle/xptools/config/OverrideType.java | 16 ------ 5 files changed, 79 insertions(+), 70 deletions(-) create mode 100644 src/main/java/dev/micle/xptools/config/OperationItem.java create mode 100644 src/main/java/dev/micle/xptools/config/OperationType.java delete mode 100644 src/main/java/dev/micle/xptools/config/OverrideItem.java delete mode 100644 src/main/java/dev/micle/xptools/config/OverrideType.java diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 12678c4..2d26c76 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -9,6 +9,7 @@ import net.minecraftforge.fml.event.config.ModConfigEvent; import org.apache.commons.lang3.tuple.Pair; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; @Mod.EventBusSubscriber(modid = XpTools.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) @@ -50,30 +51,31 @@ public final class Config { public static class Server { public static ForgeConfigSpec.BooleanValue blockBreakDefaultNoXp; - private static ForgeConfigSpec.ConfigValue> blockBreakOverridesRaw; - public static List blockBreakOverrideItems; + private static ForgeConfigSpec.ConfigValue> blockBreakOperationsRaw; + public static List blockBreakOperationItems; Server(ForgeConfigSpec.Builder builder) { builder.comment("Settings for block breaking").push("block_breaking"); blockBreakDefaultNoXp = builder .comment("Should all blocks drop 0 XP by default?") .comment("(This makes multipliers not have any effect)") - .define("blockBreakXpDisabled", false); - blockBreakOverridesRaw = builder - .comment("List of all overrides. Format: '[block_id/tag],[multi/val],[min],[max]'") + .define("blockBreakDefaultNoXp", false); + blockBreakOperationsRaw = builder + .comment("List of all overrides. Format: '[block_id/tag],[operation],[min],[max],[priority],[is_last]'") + .comment("Available operations: " + Arrays.toString(OperationType.values())) .comment("Examples:") - .comment("'minecraft:dirt,val,2,2' - Makes minecraft's dirt blocks drop 2 XP") - .comment("'#forge:ores,multi,1,2' - Applies an XP multiplier between 1-2 to all blocks tagged forge:ores") - .define("blockBreakOverrides", new ArrayList<>()); + .comment("'minecraft:dirt,set,2,2,0,true' - Sets the xp drop of the dirt block to 2, takes highest priority and stops any additional operations.") + .comment("'#forge:ores,multiply,1,2,1,false' - Multiplies xp drop of all blocks tagged forge:ores by 1-2, allows additional operations.") + .define("blockBreakOperations", new ArrayList<>()); builder.pop(); } @SubscribeEvent public static void onServerConfigReload(ModConfigEvent event) { if (event.getConfig().getSpec() == SERVER_SPEC) { - blockBreakOverrideItems = new ArrayList<>(); - for (String s : blockBreakOverridesRaw.get()) { - blockBreakOverrideItems.add(new OverrideItem(s)); + blockBreakOperationItems = new ArrayList<>(); + for (String s : blockBreakOperationsRaw.get()) { + blockBreakOperationItems.add(new OperationItem(s)); } } } diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/config/OperationItem.java new file mode 100644 index 0000000..63e3d6d --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/OperationItem.java @@ -0,0 +1,57 @@ +package dev.micle.xptools.config; + +public class OperationItem { + private boolean isTag; + private String id; + private OperationType type; + private float min; + private float max; + private int priority; + private boolean isLast; + + public OperationItem(String configString) { + String[] splitString = configString.split(","); + + if (splitString.length == 6) { + isTag = splitString[0].startsWith("#"); + id = isTag ? splitString[0].substring(1) : splitString[0]; + + type = OperationType.valueOf(splitString[1]); + + min = Float.parseFloat(splitString[2]); + max = Float.parseFloat(splitString[3]); + + priority = Integer.parseInt(splitString[4]); + + isLast = Boolean.parseBoolean(splitString[5]); + } + } + + public boolean isTag() { + return isTag; + } + + public String getId() { + return id; + } + + public OperationType getType() { + return type; + } + + public float getMin() { + return min; + } + + public float getMax() { + return max; + } + + public float getPriority() { + return priority; + } + + public boolean isLast() { + return isLast; + } +} diff --git a/src/main/java/dev/micle/xptools/config/OperationType.java b/src/main/java/dev/micle/xptools/config/OperationType.java new file mode 100644 index 0000000..939e1f3 --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/OperationType.java @@ -0,0 +1,9 @@ +package dev.micle.xptools.config; + +public enum OperationType { + SET, + ADD, + SUBTRACT, + MULTIPLY, + DIVIDE +} diff --git a/src/main/java/dev/micle/xptools/config/OverrideItem.java b/src/main/java/dev/micle/xptools/config/OverrideItem.java deleted file mode 100644 index 432d7f4..0000000 --- a/src/main/java/dev/micle/xptools/config/OverrideItem.java +++ /dev/null @@ -1,43 +0,0 @@ -package dev.micle.xptools.config; - -public class OverrideItem { - private boolean isTag = false; - private String id = ""; - private OverrideType type = OverrideType.MULTIPLIER; - private float min = 1; - private float max = 1; - - public OverrideItem(String configString) { - String[] splitString = configString.split(","); - - if (splitString.length == 4) { - isTag = splitString[0].startsWith("#"); - id = isTag ? splitString[0].substring(1) : splitString[0]; - - type = OverrideType.valueOf(splitString[1]); - - min = Float.parseFloat(splitString[2]); - max = Float.parseFloat(splitString[3]); - } - } - - public boolean isTag() { - return isTag; - } - - public String getId() { - return id; - } - - public OverrideType getType() { - return type; - } - - public float getMin() { - return min; - } - - public float getMax() { - return max; - } -} diff --git a/src/main/java/dev/micle/xptools/config/OverrideType.java b/src/main/java/dev/micle/xptools/config/OverrideType.java deleted file mode 100644 index dae9267..0000000 --- a/src/main/java/dev/micle/xptools/config/OverrideType.java +++ /dev/null @@ -1,16 +0,0 @@ -package dev.micle.xptools.config; - -public enum OverrideType { - VALUE("val"), - MULTIPLIER("multi"); - - private final String name; - - OverrideType(String s) { - name = s; - } - - public String toString() { - return this.name; - } -} From b5ddcc9e22a6be5993a3fa709aa7b92e5b2e61d3 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 18:50:44 +0100 Subject: [PATCH 06/20] Fixed config reload event not being subscribed. --- .../java/dev/micle/xptools/config/Config.java | 26 ++++++++++++++----- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 2d26c76..61175c3 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -41,12 +41,27 @@ public final class Config { XpTools.getFMLJavaModLoadingContext().registerConfig(ModConfig.Type.SERVER, SERVER_SPEC); } + @SubscribeEvent + public static void onConfigReloadEvent(ModConfigEvent event) { + if (event.getConfig().getSpec() == CLIENT_SPEC) { + Client.onConfigReload(); + } else if (event.getConfig().getSpec() == COMMON_SPEC) { + Common.onConfigReload(); + } else if (event.getConfig().getSpec() == SERVER_SPEC) { + Server.onConfigReload(); + } + } + public static class Client { Client(ForgeConfigSpec.Builder builder) {} + + private static void onConfigReload() {} } public static class Common { Common(ForgeConfigSpec.Builder builder) {} + + private static void onConfigReload() {} } public static class Server { @@ -70,13 +85,10 @@ public final class Config { builder.pop(); } - @SubscribeEvent - public static void onServerConfigReload(ModConfigEvent event) { - if (event.getConfig().getSpec() == SERVER_SPEC) { - blockBreakOperationItems = new ArrayList<>(); - for (String s : blockBreakOperationsRaw.get()) { - blockBreakOperationItems.add(new OperationItem(s)); - } + private static void onConfigReload() { + blockBreakOperationItems = new ArrayList<>(); + for (String s : blockBreakOperationsRaw.get()) { + blockBreakOperationItems.add(new OperationItem(s)); } } } From e796927bf0f30faf2a24a250ed8b88b664db28e7 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 19:26:40 +0100 Subject: [PATCH 07/20] Created toString and EnumUtils class to fix case dependent casting string to enum. --- .../micle/xptools/config/OperationItem.java | 19 ++++++++++++++++++- .../dev/micle/xptools/util/EnumUtils.java | 17 +++++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 src/main/java/dev/micle/xptools/util/EnumUtils.java diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/config/OperationItem.java index 63e3d6d..760d311 100644 --- a/src/main/java/dev/micle/xptools/config/OperationItem.java +++ b/src/main/java/dev/micle/xptools/config/OperationItem.java @@ -1,5 +1,7 @@ package dev.micle.xptools.config; +import dev.micle.xptools.util.EnumUtils; + public class OperationItem { private boolean isTag; private String id; @@ -16,7 +18,7 @@ public class OperationItem { isTag = splitString[0].startsWith("#"); id = isTag ? splitString[0].substring(1) : splitString[0]; - type = OperationType.valueOf(splitString[1]); + type = EnumUtils.valueOf(OperationType.class, splitString[1]); min = Float.parseFloat(splitString[2]); max = Float.parseFloat(splitString[3]); @@ -27,6 +29,21 @@ public class OperationItem { } } + public String toString() { + StringBuilder builder = new StringBuilder(); + if (isTag) { + builder.append("#"); + } + builder + .append(id).append(",") + .append(type.toString()).append(",") + .append(min).append(",").append(max).append(",") + .append(priority).append(",") + .append(isLast); + + return builder.toString(); + } + public boolean isTag() { return isTag; } diff --git a/src/main/java/dev/micle/xptools/util/EnumUtils.java b/src/main/java/dev/micle/xptools/util/EnumUtils.java new file mode 100644 index 0000000..00a7a1f --- /dev/null +++ b/src/main/java/dev/micle/xptools/util/EnumUtils.java @@ -0,0 +1,17 @@ +package dev.micle.xptools.util; + +public class EnumUtils { + public static > T valueOf(Class clazz, String name) { + for (T e : clazz.getEnumConstants()) { + if (e.name().equalsIgnoreCase(name)) { + return e; + } + } + return null; + } + + public static > T valueOfOrDefault(Class clazz, String name, T defaultValue) { + T value = valueOf(clazz, name); + return (value == null) ? defaultValue : value; + } +} From b8d8af67f2161dedf8e5d7303565016ce4a2d898 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 19:27:15 +0100 Subject: [PATCH 08/20] Collecting all relevant operations for broken block. --- .../common/OnBlockBreakEventHandler.java | 34 ++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index 5485e05..fbe8367 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -1,12 +1,44 @@ package dev.micle.xptools.events.common; import dev.micle.xptools.XpTools; +import dev.micle.xptools.config.Config; +import dev.micle.xptools.config.OperationItem; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.level.block.Block; import net.minecraftforge.event.level.BlockEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.registries.ForgeRegistries; + +import java.util.ArrayList; +import java.util.List; public class OnBlockBreakEventHandler { @SubscribeEvent public void OnBlockBreakEvent(BlockEvent.BreakEvent event) { - XpTools.LOGGER.debug(String.valueOf(event.getExpToDrop())); + List operations = new ArrayList<>(); + + // Collect operations on relevant block_id + ResourceLocation block_rl = ForgeRegistries.BLOCKS.getKey(event.getState().getBlock()); + if (block_rl != null) { + String block_id = block_rl.toString(); + for (OperationItem operationItem : Config.Server.blockBreakOperationItems) { + if (!operationItem.isTag() && operationItem.getId().equals(block_id)) { + operations.add(operationItem); + } + } + } + + // Collect operations on relevant tag_id + for (TagKey tagKey : event.getState().getTags().toList()) { + String tag_id = tagKey.location().toString(); + for (OperationItem operationItem : Config.Server.blockBreakOperationItems) { + if (operationItem.isTag() && operationItem.getId().equals(tag_id)) { + operations.add(operationItem); + } + } + } + + XpTools.LOGGER.debug(operations.toString()); } } From f3e9854aea4ef3990d4728d40065fe0f3265499a Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 19:36:42 +0100 Subject: [PATCH 09/20] Sorting operations by priority. --- src/main/java/dev/micle/xptools/config/OperationItem.java | 2 +- .../micle/xptools/events/common/OnBlockBreakEventHandler.java | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/config/OperationItem.java index 760d311..1b05989 100644 --- a/src/main/java/dev/micle/xptools/config/OperationItem.java +++ b/src/main/java/dev/micle/xptools/config/OperationItem.java @@ -64,7 +64,7 @@ public class OperationItem { return max; } - public float getPriority() { + public int getPriority() { return priority; } diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index fbe8367..882439c 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -11,6 +11,7 @@ import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.registries.ForgeRegistries; import java.util.ArrayList; +import java.util.Comparator; import java.util.List; public class OnBlockBreakEventHandler { @@ -39,6 +40,9 @@ public class OnBlockBreakEventHandler { } } + // Sort operations based on priority + operations.sort(Comparator.comparingInt(OperationItem::getPriority)); + XpTools.LOGGER.debug(operations.toString()); } } From 3ee1bfa9e64360c0fa7a271cee6e179ce9f66d5d Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 19:59:24 +0100 Subject: [PATCH 10/20] Getting default xp drop amount, applying all operations on it and setting the event xp drops. --- .../common/OnBlockBreakEventHandler.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index 882439c..5340fa4 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -13,10 +13,12 @@ import net.minecraftforge.registries.ForgeRegistries; import java.util.ArrayList; import java.util.Comparator; import java.util.List; +import java.util.concurrent.ThreadLocalRandom; public class OnBlockBreakEventHandler { @SubscribeEvent public void OnBlockBreakEvent(BlockEvent.BreakEvent event) { + float xpToDrop = (Config.Server.blockBreakDefaultNoXp.get()) ? 0 : event.getExpToDrop(); List operations = new ArrayList<>(); // Collect operations on relevant block_id @@ -43,6 +45,42 @@ public class OnBlockBreakEventHandler { // Sort operations based on priority operations.sort(Comparator.comparingInt(OperationItem::getPriority)); + // Apply operations to xp drops + for (OperationItem operation : operations) { + // Calculate operation value + float opValue = (operation.getMin() == operation.getMax()) ? + operation.getMin() : + ThreadLocalRandom.current().nextFloat(operation.getMin(), operation.getMax()); + + // Apply operation + switch (operation.getType()) { + case SET: + xpToDrop = opValue; + break; + case ADD: + xpToDrop += opValue; + break; + case SUBTRACT: + xpToDrop -= opValue; + break; + case MULTIPLY: + xpToDrop *= opValue; + break; + case DIVIDE: + xpToDrop /= opValue; + break; + } + + // Stop if this is the last operation + if (operation.isLast()) { + operations = operations.subList(0, operations.indexOf(operation) + 1); + break; + } + } XpTools.LOGGER.debug(operations.toString()); + XpTools.LOGGER.debug(String.valueOf(xpToDrop)); + + // Apply xp drop + event.setExpToDrop((int)xpToDrop); } } From 0c9cee8b19b0d2beceecba49f9f5ab432c5fa870 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 20:18:46 +0100 Subject: [PATCH 11/20] Created data classes for GlobalOperationItem. --- .../java/dev/micle/xptools/config/Config.java | 2 +- .../xptools/config/GlobalOperationItem.java | 23 ++++++++++++++ .../micle/xptools/config/OperationItem.java | 31 ++++++++++++------- 3 files changed, 44 insertions(+), 12 deletions(-) create mode 100644 src/main/java/dev/micle/xptools/config/GlobalOperationItem.java diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 61175c3..1f2116b 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -88,7 +88,7 @@ public final class Config { private static void onConfigReload() { blockBreakOperationItems = new ArrayList<>(); for (String s : blockBreakOperationsRaw.get()) { - blockBreakOperationItems.add(new OperationItem(s)); + blockBreakOperationItems.add(OperationItem.fromConfig(s)); } } } diff --git a/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java b/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java new file mode 100644 index 0000000..b255381 --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java @@ -0,0 +1,23 @@ +package dev.micle.xptools.config; + +import dev.micle.xptools.util.EnumUtils; + +public class GlobalOperationItem extends OperationItem { + public GlobalOperationItem(OperationType type, float min, float max, int priority) { + super(false, "", type, min, max, priority, false); + } + + public static GlobalOperationItem fromConfig(String configString) { + String[] splitString = configString.split(","); + + if (splitString.length == 4) { + OperationType type = EnumUtils.valueOf(OperationType.class, splitString[0]); + float min = Float.parseFloat(splitString[1]); + float max = Float.parseFloat(splitString[2]); + int priority = Integer.parseInt(splitString[3]); + + return new GlobalOperationItem(type, min, max, priority); + } + return null; + } +} diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/config/OperationItem.java index 1b05989..ad9ec51 100644 --- a/src/main/java/dev/micle/xptools/config/OperationItem.java +++ b/src/main/java/dev/micle/xptools/config/OperationItem.java @@ -11,22 +11,31 @@ public class OperationItem { private int priority; private boolean isLast; - public OperationItem(String configString) { + public OperationItem(boolean isTag, String id, OperationType type, float min, float max, int priority, boolean isLast) { + this.isTag = isTag; + this.id = id; + this.type = type; + this.min = min; + this.max = max; + this.priority = priority; + this.isLast = isLast; + } + + public static OperationItem fromConfig(String configString) { String[] splitString = configString.split(","); if (splitString.length == 6) { - isTag = splitString[0].startsWith("#"); - id = isTag ? splitString[0].substring(1) : splitString[0]; + boolean isTag = splitString[0].startsWith("#"); + String id = isTag ? splitString[0].substring(1) : splitString[0]; + OperationType type = EnumUtils.valueOf(OperationType.class, splitString[1]); + float min = Float.parseFloat(splitString[2]); + float max = Float.parseFloat(splitString[3]); + int priority = Integer.parseInt(splitString[4]); + boolean isLast = Boolean.parseBoolean(splitString[5]); - type = EnumUtils.valueOf(OperationType.class, splitString[1]); - - min = Float.parseFloat(splitString[2]); - max = Float.parseFloat(splitString[3]); - - priority = Integer.parseInt(splitString[4]); - - isLast = Boolean.parseBoolean(splitString[5]); + return new OperationItem(isTag, id, type, min, max, priority, isLast); } + return null; } public String toString() { From bdf1a5baa2aee125728d3f81c6bee11fd89b601d Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 20:28:48 +0100 Subject: [PATCH 12/20] Changed config option for no xp to a global operations list. --- .../java/dev/micle/xptools/config/Config.java | 25 +++++++++++++------ 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 1f2116b..d532a1e 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -65,19 +65,23 @@ public final class Config { } public static class Server { - public static ForgeConfigSpec.BooleanValue blockBreakDefaultNoXp; + private static ForgeConfigSpec.ConfigValue> blockBreakGlobalOperationsRaw; + public static List blockBreakGlobalOperationItems; private static ForgeConfigSpec.ConfigValue> blockBreakOperationsRaw; public static List blockBreakOperationItems; Server(ForgeConfigSpec.Builder builder) { + builder.comment("Available operations: " + Arrays.toString(OperationType.values())); + builder.comment("Settings for block breaking").push("block_breaking"); - blockBreakDefaultNoXp = builder - .comment("Should all blocks drop 0 XP by default?") - .comment("(This makes multipliers not have any effect)") - .define("blockBreakDefaultNoXp", false); + blockBreakGlobalOperationsRaw = builder + .comment("List of global operations. Format: '[operation],[min],[max],[priority]'") + .comment("Global operations are run before any unique operations.") + .comment("Examples:") + .comment("'set,0,0,0' - Sets the xp of all blocks to 0.") + .define("blockBreakGlobalOperations", new ArrayList<>()); blockBreakOperationsRaw = builder - .comment("List of all overrides. Format: '[block_id/tag],[operation],[min],[max],[priority],[is_last]'") - .comment("Available operations: " + Arrays.toString(OperationType.values())) + .comment("List of unique operations. Format: '[block_id/tag_id],[operation],[min],[max],[priority],[is_last]'") .comment("Examples:") .comment("'minecraft:dirt,set,2,2,0,true' - Sets the xp drop of the dirt block to 2, takes highest priority and stops any additional operations.") .comment("'#forge:ores,multiply,1,2,1,false' - Multiplies xp drop of all blocks tagged forge:ores by 1-2, allows additional operations.") @@ -86,6 +90,13 @@ public final class Config { } private static void onConfigReload() { + // Parse all block break global operations + blockBreakGlobalOperationItems = new ArrayList<>(); + for (String s : blockBreakGlobalOperationsRaw.get()) { + blockBreakOperationItems.add(GlobalOperationItem.fromConfig(s)); + } + + // Parse all block break unique operations blockBreakOperationItems = new ArrayList<>(); for (String s : blockBreakOperationsRaw.get()) { blockBreakOperationItems.add(OperationItem.fromConfig(s)); From 3ae20d2416046281767073c7185ed3f1c5a8cd1e Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 20:51:17 +0100 Subject: [PATCH 13/20] Fixed global operations and now sorting them. --- src/main/java/dev/micle/xptools/config/Config.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index d532a1e..564903b 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -10,6 +10,7 @@ import org.apache.commons.lang3.tuple.Pair; import java.util.ArrayList; import java.util.Arrays; +import java.util.Comparator; import java.util.List; @Mod.EventBusSubscriber(modid = XpTools.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) @@ -93,8 +94,9 @@ public final class Config { // Parse all block break global operations blockBreakGlobalOperationItems = new ArrayList<>(); for (String s : blockBreakGlobalOperationsRaw.get()) { - blockBreakOperationItems.add(GlobalOperationItem.fromConfig(s)); + blockBreakGlobalOperationItems.add(GlobalOperationItem.fromConfig(s)); } + blockBreakGlobalOperationItems.sort(Comparator.comparingInt(OperationItem::getPriority)); // Parse all block break unique operations blockBreakOperationItems = new ArrayList<>(); From ea813acb2f90293728eb06f79d29071af21f1bc8 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 20:51:49 +0100 Subject: [PATCH 14/20] Changed toString logic. --- .../java/dev/micle/xptools/config/GlobalOperationItem.java | 5 +++++ src/main/java/dev/micle/xptools/config/OperationItem.java | 1 + 2 files changed, 6 insertions(+) diff --git a/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java b/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java index b255381..3d3ffd8 100644 --- a/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java +++ b/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java @@ -20,4 +20,9 @@ public class GlobalOperationItem extends OperationItem { } return null; } + + @Override + public String toString() { + return String.format("%s,%f,%f,%d", getType().toString(), getMin(), getMax(), getPriority()); + } } diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/config/OperationItem.java index ad9ec51..9e31cce 100644 --- a/src/main/java/dev/micle/xptools/config/OperationItem.java +++ b/src/main/java/dev/micle/xptools/config/OperationItem.java @@ -38,6 +38,7 @@ public class OperationItem { return null; } + @Override public String toString() { StringBuilder builder = new StringBuilder(); if (isTag) { From 43fb2f9a0af1c0452116d6d4c687ed743c05e31c Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 20:52:10 +0100 Subject: [PATCH 15/20] Using global operations. --- .../xptools/events/common/OnBlockBreakEventHandler.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index 5340fa4..c40dd4e 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -18,7 +18,7 @@ import java.util.concurrent.ThreadLocalRandom; public class OnBlockBreakEventHandler { @SubscribeEvent public void OnBlockBreakEvent(BlockEvent.BreakEvent event) { - float xpToDrop = (Config.Server.blockBreakDefaultNoXp.get()) ? 0 : event.getExpToDrop(); + float xpToDrop = event.getExpToDrop(); List operations = new ArrayList<>(); // Collect operations on relevant block_id @@ -45,6 +45,9 @@ public class OnBlockBreakEventHandler { // Sort operations based on priority operations.sort(Comparator.comparingInt(OperationItem::getPriority)); + // Add global operations before all others + operations.addAll(0, Config.Server.blockBreakGlobalOperationItems); + // Apply operations to xp drops for (OperationItem operation : operations) { // Calculate operation value From 43a5eef628282648d79b169c24efc75f0c532da5 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 21:19:26 +0100 Subject: [PATCH 16/20] Made members final. --- .../dev/micle/xptools/config/OperationItem.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/config/OperationItem.java index 9e31cce..7f14629 100644 --- a/src/main/java/dev/micle/xptools/config/OperationItem.java +++ b/src/main/java/dev/micle/xptools/config/OperationItem.java @@ -3,13 +3,13 @@ package dev.micle.xptools.config; import dev.micle.xptools.util.EnumUtils; public class OperationItem { - private boolean isTag; - private String id; - private OperationType type; - private float min; - private float max; - private int priority; - private boolean isLast; + private final boolean isTag; + private final String id; + private final OperationType type; + private final float min; + private final float max; + private final int priority; + private final boolean isLast; public OperationItem(boolean isTag, String id, OperationType type, float min, float max, int priority, boolean isLast) { this.isTag = isTag; From 20a56f83e0552f4467a7c96f48b43727d6543cb1 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 22:13:40 +0100 Subject: [PATCH 17/20] Implemented cache for fetching operations. --- .../java/dev/micle/xptools/config/Config.java | 8 +-- .../micle/xptools/config/OperationCache.java | 24 +++++++ .../common/OnBlockBreakEventHandler.java | 64 +++++++++++++------ 3 files changed, 74 insertions(+), 22 deletions(-) create mode 100644 src/main/java/dev/micle/xptools/config/OperationCache.java diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 564903b..fb683cc 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -8,10 +8,7 @@ import net.minecraftforge.fml.config.ModConfig; import net.minecraftforge.fml.event.config.ModConfigEvent; import org.apache.commons.lang3.tuple.Pair; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Comparator; -import java.util.List; +import java.util.*; @Mod.EventBusSubscriber(modid = XpTools.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) public final class Config { @@ -91,6 +88,9 @@ public final class Config { } private static void onConfigReload() { + // Clear cache + OperationCache.clearBlockBreakCache(); + // Parse all block break global operations blockBreakGlobalOperationItems = new ArrayList<>(); for (String s : blockBreakGlobalOperationsRaw.get()) { diff --git a/src/main/java/dev/micle/xptools/config/OperationCache.java b/src/main/java/dev/micle/xptools/config/OperationCache.java new file mode 100644 index 0000000..7469f0c --- /dev/null +++ b/src/main/java/dev/micle/xptools/config/OperationCache.java @@ -0,0 +1,24 @@ +package dev.micle.xptools.config; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class OperationCache { + private static HashMap> blockBreakCache; + + public static void clearBlockBreakCache() { + blockBreakCache = new HashMap<>(); + } + + public static List getBlockBreakCacheEntry(String key) { + if (blockBreakCache.containsKey(key)) { + return new ArrayList<>(blockBreakCache.get(key)); + } + return null; + } + + public static void addBlockBreakCacheEntry(String key, List value) { + blockBreakCache.putIfAbsent(key, new ArrayList<>(value)); + } +} diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index c40dd4e..e7e6d28 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -2,6 +2,7 @@ package dev.micle.xptools.events.common; import dev.micle.xptools.XpTools; import dev.micle.xptools.config.Config; +import dev.micle.xptools.config.OperationCache; import dev.micle.xptools.config.OperationItem; import net.minecraft.resources.ResourceLocation; import net.minecraft.tags.TagKey; @@ -10,6 +11,8 @@ import net.minecraftforge.event.level.BlockEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.registries.ForgeRegistries; +import java.time.Duration; +import java.time.Instant; import java.util.ArrayList; import java.util.Comparator; import java.util.List; @@ -19,31 +22,57 @@ public class OnBlockBreakEventHandler { @SubscribeEvent public void OnBlockBreakEvent(BlockEvent.BreakEvent event) { float xpToDrop = event.getExpToDrop(); - List operations = new ArrayList<>(); - // Collect operations on relevant block_id + // Get Block id ResourceLocation block_rl = ForgeRegistries.BLOCKS.getKey(event.getState().getBlock()); + String block_id = ""; if (block_rl != null) { - String block_id = block_rl.toString(); - for (OperationItem operationItem : Config.Server.blockBreakOperationItems) { - if (!operationItem.isTag() && operationItem.getId().equals(block_id)) { - operations.add(operationItem); - } - } + block_id = block_rl.toString(); } - // Collect operations on relevant tag_id - for (TagKey tagKey : event.getState().getTags().toList()) { - String tag_id = tagKey.location().toString(); - for (OperationItem operationItem : Config.Server.blockBreakOperationItems) { - if (operationItem.isTag() && operationItem.getId().equals(tag_id)) { - operations.add(operationItem); + // Collect operations + Instant start = Instant.now(); + List operations = OperationCache.getBlockBreakCacheEntry(block_id); + if (operations != null) { + XpTools.LOGGER.debug("Got operations from cache for {} [time: {}]", block_id, Duration.between(start, Instant.now()).toNanos()); + } else { + operations = new ArrayList<>(); + + // Collect operations on relevant block_id + if (!block_id.isEmpty()) { + for (OperationItem operationItem : Config.Server.blockBreakOperationItems) { + if (!operationItem.isTag() && operationItem.getId().equals(block_id)) { + operations.add(operationItem); + } } } - } - // Sort operations based on priority - operations.sort(Comparator.comparingInt(OperationItem::getPriority)); + // Collect operations on relevant tag_id + for (TagKey tagKey : event.getState().getTags().toList()) { + String tag_id = tagKey.location().toString(); + for (OperationItem operationItem : Config.Server.blockBreakOperationItems) { + if (operationItem.isTag() && operationItem.getId().equals(tag_id)) { + operations.add(operationItem); + } + } + } + + // Sort operations based on priority + operations.sort(Comparator.comparingInt(OperationItem::getPriority)); + + // Remove any operations after last operation + for (OperationItem operationItem : operations) { + if (operationItem.isLast()) { + operations = operations.subList(0, operations.indexOf(operationItem) + 1); + break; + } + } + + XpTools.LOGGER.debug("Calculated operations for {} [time: {}]", block_id, Duration.between(start, Instant.now()).toNanos()); + + // Save operations to cache + OperationCache.addBlockBreakCacheEntry(block_id, operations); + } // Add global operations before all others operations.addAll(0, Config.Server.blockBreakGlobalOperationItems); @@ -76,7 +105,6 @@ public class OnBlockBreakEventHandler { // Stop if this is the last operation if (operation.isLast()) { - operations = operations.subList(0, operations.indexOf(operation) + 1); break; } } From 042ebf10dccd8943b0a1a19d8ad2944338ea6a76 Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 22:44:07 +0100 Subject: [PATCH 18/20] Added config option for using the cache. --- .../java/dev/micle/xptools/config/Config.java | 10 ++++++++- .../micle/xptools/config/OperationCache.java | 3 ++- .../common/OnBlockBreakEventHandler.java | 22 +++++++++++-------- 3 files changed, 24 insertions(+), 11 deletions(-) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index fb683cc..fd0ca36 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -63,15 +63,23 @@ public final class Config { } public static class Server { + public static ForgeConfigSpec.BooleanValue optimizationUseCache; + private static ForgeConfigSpec.ConfigValue> blockBreakGlobalOperationsRaw; public static List blockBreakGlobalOperationItems; private static ForgeConfigSpec.ConfigValue> blockBreakOperationsRaw; public static List blockBreakOperationItems; Server(ForgeConfigSpec.Builder builder) { - builder.comment("Available operations: " + Arrays.toString(OperationType.values())); + builder.comment("Settings for optimizations").push("optimization"); + optimizationUseCache = builder + .comment("When enabled, the list of operations to perform per unique_id will be cached after the first calculation.") + .comment("Although this does increase performance at the cost of RAM, the overall performance hit of this mod is tiny anyway... but oh well") + .define("optimizationUseCache", true); + builder.pop(); builder.comment("Settings for block breaking").push("block_breaking"); + builder.comment("Available operations: " + Arrays.toString(OperationType.values())); blockBreakGlobalOperationsRaw = builder .comment("List of global operations. Format: '[operation],[min],[max],[priority]'") .comment("Global operations are run before any unique operations.") diff --git a/src/main/java/dev/micle/xptools/config/OperationCache.java b/src/main/java/dev/micle/xptools/config/OperationCache.java index 7469f0c..50058e8 100644 --- a/src/main/java/dev/micle/xptools/config/OperationCache.java +++ b/src/main/java/dev/micle/xptools/config/OperationCache.java @@ -1,5 +1,6 @@ package dev.micle.xptools.config; +import javax.annotation.Nullable; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -11,7 +12,7 @@ public class OperationCache { blockBreakCache = new HashMap<>(); } - public static List getBlockBreakCacheEntry(String key) { + public static @Nullable List getBlockBreakCacheEntry(String key) { if (blockBreakCache.containsKey(key)) { return new ArrayList<>(blockBreakCache.get(key)); } diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index e7e6d28..a9f7891 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -21,6 +21,7 @@ import java.util.concurrent.ThreadLocalRandom; public class OnBlockBreakEventHandler { @SubscribeEvent public void OnBlockBreakEvent(BlockEvent.BreakEvent event) { + Instant start = Instant.now(); float xpToDrop = event.getExpToDrop(); // Get Block id @@ -31,11 +32,12 @@ public class OnBlockBreakEventHandler { } // Collect operations - Instant start = Instant.now(); - List operations = OperationCache.getBlockBreakCacheEntry(block_id); - if (operations != null) { - XpTools.LOGGER.debug("Got operations from cache for {} [time: {}]", block_id, Duration.between(start, Instant.now()).toNanos()); - } else { + List operations = null; + if (Config.Server.optimizationUseCache.get()) { + operations = OperationCache.getBlockBreakCacheEntry(block_id); + } + + if (operations == null) { operations = new ArrayList<>(); // Collect operations on relevant block_id @@ -68,8 +70,6 @@ public class OnBlockBreakEventHandler { } } - XpTools.LOGGER.debug("Calculated operations for {} [time: {}]", block_id, Duration.between(start, Instant.now()).toNanos()); - // Save operations to cache OperationCache.addBlockBreakCacheEntry(block_id, operations); } @@ -108,8 +108,12 @@ public class OnBlockBreakEventHandler { break; } } - XpTools.LOGGER.debug(operations.toString()); - XpTools.LOGGER.debug(String.valueOf(xpToDrop)); + + // Debug logging + XpTools.LOGGER.debug("Completed block break event:"); + XpTools.LOGGER.debug("\tOperations: {}", operations); + XpTools.LOGGER.debug("\tTime taken (nano seconds): {}", Duration.between(start, Instant.now()).toNanos()); + XpTools.LOGGER.debug("\tXP: {} -> {}", event.getExpToDrop(), xpToDrop); // Apply xp drop event.setExpToDrop((int)xpToDrop); From b287f43e74762340639270dcf4561a4e3cea179d Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 22:47:44 +0100 Subject: [PATCH 19/20] Added config for extra debugging. --- src/main/java/dev/micle/xptools/config/Config.java | 8 ++++++++ .../events/common/OnBlockBreakEventHandler.java | 10 ++++++---- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index fd0ca36..98de02e 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -63,6 +63,8 @@ public final class Config { } public static class Server { + public static ForgeConfigSpec.BooleanValue debugExtra; + public static ForgeConfigSpec.BooleanValue optimizationUseCache; private static ForgeConfigSpec.ConfigValue> blockBreakGlobalOperationsRaw; @@ -71,6 +73,12 @@ public final class Config { public static List blockBreakOperationItems; Server(ForgeConfigSpec.Builder builder) { + builder.comment("Settings for debugging").push("debug"); + debugExtra = builder + .comment("Whether to log more extensive debug information.") + .define("debugExtra", false); + builder.pop(); + builder.comment("Settings for optimizations").push("optimization"); optimizationUseCache = builder .comment("When enabled, the list of operations to perform per unique_id will be cached after the first calculation.") diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index a9f7891..aa8f66e 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -110,10 +110,12 @@ public class OnBlockBreakEventHandler { } // Debug logging - XpTools.LOGGER.debug("Completed block break event:"); - XpTools.LOGGER.debug("\tOperations: {}", operations); - XpTools.LOGGER.debug("\tTime taken (nano seconds): {}", Duration.between(start, Instant.now()).toNanos()); - XpTools.LOGGER.debug("\tXP: {} -> {}", event.getExpToDrop(), xpToDrop); + if (Config.Server.debugExtra.get()) { + XpTools.LOGGER.debug("Completed block break event:"); + XpTools.LOGGER.debug("\tOperations: {}", operations); + XpTools.LOGGER.debug("\tTime taken (nano seconds): {}", Duration.between(start, Instant.now()).toNanos()); + XpTools.LOGGER.debug("\tXP: {} -> {}", event.getExpToDrop(), xpToDrop); + } // Apply xp drop event.setExpToDrop((int)xpToDrop); From 07919c19a13339120baeeacbeeaa2c893a1fef0d Mon Sep 17 00:00:00 2001 From: Micle Date: Sat, 24 May 2025 22:53:39 +0100 Subject: [PATCH 20/20] Moved operation classes into new package. --- src/main/java/dev/micle/xptools/config/Config.java | 4 ++++ .../micle/xptools/events/common/OnBlockBreakEventHandler.java | 4 ++-- .../xptools/{config => operation}/GlobalOperationItem.java | 2 +- .../micle/xptools/{config => operation}/OperationCache.java | 2 +- .../micle/xptools/{config => operation}/OperationItem.java | 2 +- .../micle/xptools/{config => operation}/OperationType.java | 2 +- 6 files changed, 10 insertions(+), 6 deletions(-) rename src/main/java/dev/micle/xptools/{config => operation}/GlobalOperationItem.java (96%) rename src/main/java/dev/micle/xptools/{config => operation}/OperationCache.java (95%) rename src/main/java/dev/micle/xptools/{config => operation}/OperationItem.java (98%) rename src/main/java/dev/micle/xptools/{config => operation}/OperationType.java (70%) diff --git a/src/main/java/dev/micle/xptools/config/Config.java b/src/main/java/dev/micle/xptools/config/Config.java index 98de02e..687ee33 100644 --- a/src/main/java/dev/micle/xptools/config/Config.java +++ b/src/main/java/dev/micle/xptools/config/Config.java @@ -1,6 +1,10 @@ package dev.micle.xptools.config; import dev.micle.xptools.XpTools; +import dev.micle.xptools.operation.GlobalOperationItem; +import dev.micle.xptools.operation.OperationCache; +import dev.micle.xptools.operation.OperationItem; +import dev.micle.xptools.operation.OperationType; import net.minecraftforge.common.ForgeConfigSpec; import net.minecraftforge.eventbus.api.SubscribeEvent; import net.minecraftforge.fml.common.Mod; diff --git a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java index aa8f66e..cce9704 100644 --- a/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java +++ b/src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java @@ -2,8 +2,8 @@ package dev.micle.xptools.events.common; import dev.micle.xptools.XpTools; import dev.micle.xptools.config.Config; -import dev.micle.xptools.config.OperationCache; -import dev.micle.xptools.config.OperationItem; +import dev.micle.xptools.operation.OperationCache; +import dev.micle.xptools.operation.OperationItem; import net.minecraft.resources.ResourceLocation; import net.minecraft.tags.TagKey; import net.minecraft.world.level.block.Block; diff --git a/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java b/src/main/java/dev/micle/xptools/operation/GlobalOperationItem.java similarity index 96% rename from src/main/java/dev/micle/xptools/config/GlobalOperationItem.java rename to src/main/java/dev/micle/xptools/operation/GlobalOperationItem.java index 3d3ffd8..a955c4c 100644 --- a/src/main/java/dev/micle/xptools/config/GlobalOperationItem.java +++ b/src/main/java/dev/micle/xptools/operation/GlobalOperationItem.java @@ -1,4 +1,4 @@ -package dev.micle.xptools.config; +package dev.micle.xptools.operation; import dev.micle.xptools.util.EnumUtils; diff --git a/src/main/java/dev/micle/xptools/config/OperationCache.java b/src/main/java/dev/micle/xptools/operation/OperationCache.java similarity index 95% rename from src/main/java/dev/micle/xptools/config/OperationCache.java rename to src/main/java/dev/micle/xptools/operation/OperationCache.java index 50058e8..446d716 100644 --- a/src/main/java/dev/micle/xptools/config/OperationCache.java +++ b/src/main/java/dev/micle/xptools/operation/OperationCache.java @@ -1,4 +1,4 @@ -package dev.micle.xptools.config; +package dev.micle.xptools.operation; import javax.annotation.Nullable; import java.util.ArrayList; diff --git a/src/main/java/dev/micle/xptools/config/OperationItem.java b/src/main/java/dev/micle/xptools/operation/OperationItem.java similarity index 98% rename from src/main/java/dev/micle/xptools/config/OperationItem.java rename to src/main/java/dev/micle/xptools/operation/OperationItem.java index 7f14629..2cb4593 100644 --- a/src/main/java/dev/micle/xptools/config/OperationItem.java +++ b/src/main/java/dev/micle/xptools/operation/OperationItem.java @@ -1,4 +1,4 @@ -package dev.micle.xptools.config; +package dev.micle.xptools.operation; import dev.micle.xptools.util.EnumUtils; diff --git a/src/main/java/dev/micle/xptools/config/OperationType.java b/src/main/java/dev/micle/xptools/operation/OperationType.java similarity index 70% rename from src/main/java/dev/micle/xptools/config/OperationType.java rename to src/main/java/dev/micle/xptools/operation/OperationType.java index 939e1f3..7324ba6 100644 --- a/src/main/java/dev/micle/xptools/config/OperationType.java +++ b/src/main/java/dev/micle/xptools/operation/OperationType.java @@ -1,4 +1,4 @@ -package dev.micle.xptools.config; +package dev.micle.xptools.operation; public enum OperationType { SET,