Merge pull request 'bug/17-config_list_definitions' (#18) from bug/17-config_list_definitions into 1.20.1

Reviewed-on: #18

build.gradle

@@ -9,7 +9,7 @@ group = mod_group_id
 version = mod_version
 
 base {
-    archivesName = mod_id
+    archivesName = "${mod_id}-${minecraft_version}"
 }
 
 java {

gradle.properties

@@ -4,7 +4,7 @@ org.gradle.daemon=false
 mod_id=xp_tools
 mod_name=XP Tools
 mod_license=All Rights Reserved
-mod_version=1.0.0
+mod_version=1.0.2
 mod_group_id=dev.micle
 mod_authors=Micle
 mod_description=Minecraft Forge mod for tweaking various things about XP in Minecraft. Primarily targeted at modpack developers.

src/main/java/dev/micle/xptools/config/Config.java

@@ -13,6 +13,7 @@ import net.minecraftforge.fml.event.config.ModConfigEvent;
 import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 @Mod.EventBusSubscriber(modid = XpTools.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
 public final class Config {
@@ -104,13 +105,13 @@ public final class Config {
                     .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<>());
+                    .defineList("blockBreakGlobalOperations", List.of(), Server::isValidGlobalOperationEntry);
             blockBreakOperationsRaw = builder
                     .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.")
-                    .define("blockBreakOperations", new ArrayList<>());
+                    .defineList("blockBreakOperations", List.of(), Server::isValidOperationEntry);
             builder.pop();
 
             builder.comment("Settings for entity killing").push("entity_killing");
@@ -120,20 +121,20 @@ public final class Config {
                     .comment("Global operations are run before any unique operations.")
                     .comment("Examples:")
                     .comment("'set,0,0,0' - Sets the xp of all entities to 0.")
-                    .define("entityKillGlobalOperations", new ArrayList<>());
+                    .defineList("entityKillGlobalOperations", List.of(), Server::isValidGlobalOperationEntry);
             entityKillOperationsRaw = builder
                     .comment("List of unique operations. Format: '[entity_id/tag_id],[operation],[min],[max],[priority],[is_last]'")
                     .comment("Examples:")
                     .comment("'minecraft:creeper,set,2,2,0,true' - Sets the xp drop for killing creepers to 2, takes highest priority and stops any additional operations.")
                     .comment("'#some_mod:some_tag,multiply,1,2,1,false' - Multiplies the xp drop for killing all entities tagged some_mod:some_tag by 1-2, allows additional operations.")
-                    .define("entityKillOperations", new ArrayList<>());
+                    .defineList("entityKillOperations", List.of(), Server::isValidOperationEntry);
             builder.pop();
         }
 
         private static void onConfigReload() {
             // Clear cache
-            OperationCache.clearBlockBreakCache();
-            OperationCache.clearEntityKillCache();
+            OperationCache.blockBreakCache.clear();
+            OperationCache.entityKillCache.clear();
 
             // Parse all block break global operations
             blockBreakGlobalOperationItems = new ArrayList<>();
@@ -161,5 +162,23 @@ public final class Config {
                 entityKillOperationItems.add(OperationItem.fromConfig(s));
             }
         }
+
+        private static boolean isValidGlobalOperationEntry(Object entry) {
+            return entry instanceof String && ((String) entry).matches(
+                    String.format(
+                            "(?i)^(%s),(\\d*\\.?\\d+),(\\d*\\.?\\d+),(\\d+)$",
+                            Arrays.stream(OperationType.values()).map(OperationType::toString).collect(Collectors.joining("|"))
+                    )
+            );
+        }
+
+        private static boolean isValidOperationEntry(Object entry) {
+            return entry instanceof String && ((String) entry).matches(
+                    String.format(
+                            "(?i)^(\\#?\\w+:[\\w\\/]+),(%s),(\\d*\\.?\\d+),(\\d*\\.?\\d+),(\\d+),(TRUE|FALSE)$",
+                            Arrays.stream(OperationType.values()).map(OperationType::toString).collect(Collectors.joining("|"))
+                    )
+            );
+        }
     }
 }

src/main/java/dev/micle/xptools/events/common/OnBlockBreakEventHandler.java

@@ -15,10 +15,11 @@ import java.time.Instant;
 import java.util.List;
 
 public class OnBlockBreakEventHandler {
+    private final OperationCache cache = OperationCache.blockBreakCache;
+
     @SubscribeEvent
     public void OnBlockBreakEvent(BlockEvent.BreakEvent event) {
         Instant start = Instant.now();
-        boolean usedCache = true;
         float xpToDrop = event.getExpToDrop();
 
         // Get Block id
@@ -28,25 +29,13 @@ public class OnBlockBreakEventHandler {
             block_id = block_rl.toString();
         }
 
-        // Collect operations
-        List<OperationItem> operations = null;
-        if (Config.Server.optimizationUseCache.get()) {
-            operations = OperationCache.getBlockBreakCacheEntry(block_id);
-        }
-
-        if (operations == null) {
-            usedCache = false;
-
-            // Calculate operations
-            operations = OperationUtils.calculateOperationList(
-                    block_id,
-                    event.getState().getTags().toList(),
-                    Config.Server.blockBreakOperationItems
-            );
-
-            // Save operations to cache
-            OperationCache.addBlockBreakCacheEntry(block_id, operations);
-        }
+        // Get operations
+        List<OperationItem> operations = OperationUtils.getOperationList(
+                block_id,
+                event.getState().getTags().toList(),
+                Config.Server.blockBreakOperationItems,
+                cache
+        );
 
         // Add global operations before all others
         operations.addAll(0, Config.Server.blockBreakGlobalOperationItems);
@@ -58,7 +47,7 @@ public class OnBlockBreakEventHandler {
         if (Config.Server.debugExtra.get()) {
             XpTools.LOGGER.debug("Completed block break event:");
             XpTools.LOGGER.debug("\tOperations: {}", operations);
-            XpTools.LOGGER.debug("\tUsed cache: {}", usedCache);
+            XpTools.LOGGER.debug("\tCache entries: {}", cache.size());
             XpTools.LOGGER.debug("\tTime taken (nano seconds): {}", Duration.between(start, Instant.now()).toNanos());
             XpTools.LOGGER.debug("\tXP: {} -> {}", event.getExpToDrop(), xpToDrop);
         }

src/main/java/dev/micle/xptools/events/common/OnLivingExperienceDropEventHandler.java

@@ -15,10 +15,11 @@ import java.time.Instant;
 import java.util.List;
 
 public class OnLivingExperienceDropEventHandler {
+    private final OperationCache cache = OperationCache.entityKillCache;
+
     @SubscribeEvent
     public void onLivingExperienceDropEvent(LivingExperienceDropEvent event) {
         Instant start = Instant.now();
-        boolean usedCache = true;
         float xpToDrop = event.getDroppedExperience();
 
         // Get Entity id
@@ -28,25 +29,13 @@ public class OnLivingExperienceDropEventHandler {
             entity_id = entity_rl.toString();
         }
 
-        // Collect operations
-        List<OperationItem> operations = null;
-        if (Config.Server.optimizationUseCache.get()) {
-            operations = OperationCache.getEntityKillCacheEntry(entity_id);
-        }
-
-        if (operations == null) {
-            usedCache = false;
-
-            // Calculate operations
-            operations = OperationUtils.calculateOperationList(
-                    entity_id,
-                    event.getEntity().getType().getTags().toList(),
-                    Config.Server.entityKillOperationItems
-            );
-
-            // Save operations to cache
-            OperationCache.addEntityKillCacheEntry(entity_id, operations);
-        }
+        // Get operations
+        List<OperationItem> operations = OperationUtils.getOperationList(
+                entity_id,
+                event.getEntity().getType().getTags().toList(),
+                Config.Server.entityKillOperationItems,
+                cache
+        );
 
         // Add global operations before all others
         operations.addAll(0, Config.Server.entityKillGlobalOperationItems);
@@ -58,7 +47,7 @@ public class OnLivingExperienceDropEventHandler {
         if (Config.Server.debugExtra.get()) {
             XpTools.LOGGER.debug("Completed entity kill event:");
             XpTools.LOGGER.debug("\tOperations: {}", operations);
-            XpTools.LOGGER.debug("\tUsed cache: {}", usedCache);
+            XpTools.LOGGER.debug("\tCache entries: {}", cache.size());
             XpTools.LOGGER.debug("\tTime taken (nano seconds): {}", Duration.between(start, Instant.now()).toNanos());
             XpTools.LOGGER.debug("\tXP: {} -> {}", event.getDroppedExperience(), xpToDrop);
         }

src/main/java/dev/micle/xptools/operation/OperationCache.java

@@ -6,36 +6,28 @@ import java.util.HashMap;
 import java.util.List;
 
 public class OperationCache {
-    private static HashMap<String, List<OperationItem>> blockBreakCache;
-    private static HashMap<String, List<OperationItem>> entityKillCache;
+    public static OperationCache blockBreakCache = new OperationCache();
+    public static OperationCache entityKillCache = new OperationCache();
+    private HashMap<String, List<OperationItem>> cache = new HashMap<>();
 
-    public static void clearBlockBreakCache() {
-        blockBreakCache = new HashMap<>();
+    private OperationCache() {}
+
+    public void clear() {
+        cache = new HashMap<>();
     }
 
-    public static void clearEntityKillCache() {
-        entityKillCache = new HashMap<>();
-    }
-
-    public static @Nullable List<OperationItem> getBlockBreakCacheEntry(String key) {
-        if (blockBreakCache.containsKey(key)) {
-            return new ArrayList<>(blockBreakCache.get(key));
+    public @Nullable List<OperationItem> getEntry(String key) {
+        if (cache.containsKey(key)) {
+            return new ArrayList<>(cache.get(key));
         }
         return null;
     }
 
-    public static @Nullable List<OperationItem> getEntityKillCacheEntry(String key) {
-        if (entityKillCache.containsKey(key)) {
-            return new ArrayList<>(entityKillCache.get(key));
-        }
-        return null;
+    public void addEntry(String key, List<OperationItem> value) {
+        cache.putIfAbsent(key, new ArrayList<>(value));
     }
 
-    public static void addBlockBreakCacheEntry(String key, List<OperationItem> value) {
-        blockBreakCache.putIfAbsent(key, new ArrayList<>(value));
-    }
-
-    public static void addEntityKillCacheEntry(String key, List<OperationItem> value) {
-        entityKillCache.putIfAbsent(key, new ArrayList<>(value));
+    public int size() {
+        return cache.size();
     }
 }

src/main/java/dev/micle/xptools/operation/OperationUtils.java

@@ -1,5 +1,6 @@
 package dev.micle.xptools.operation;
 
+import dev.micle.xptools.config.Config;
 import net.minecraft.tags.TagKey;
 
 import java.util.ArrayList;
@@ -8,36 +9,50 @@ import java.util.List;
 import java.util.concurrent.ThreadLocalRandom;
 
 public class OperationUtils {
-    public static <T extends TagKey<?>> List<OperationItem> calculateOperationList(String id, List<T> tagList, List<OperationItem> operationItems) {
-        List<OperationItem> operations = new ArrayList<>();
+    public static <T extends TagKey<?>> List<OperationItem> getOperationList(String id, List<T> tagList, List<OperationItem> operationItems, OperationCache cache) {
+        List<OperationItem> operations = null;
 
-        // Collect operations on relevant id
-        if (!id.isEmpty()) {
-            for (OperationItem operationItem : operationItems) {
-                if (!operationItem.isTag() && operationItem.getId().equals(id)) {
-                    operations.add(operationItem);
-                }
-            }
+        // Get from cache if possible
+        if (Config.Server.optimizationUseCache.get()) {
+            operations = cache.getEntry(id);
         }
 
-        // Collect operations on relevant tag_id
-        for (T tagKey : tagList) {
-            String tag_id = tagKey.location().toString();
-            for (OperationItem operationItem : operationItems) {
-                if (operationItem.isTag() && operationItem.getId().equals(tag_id)) {
-                    operations.add(operationItem);
+        if (operations == null) {
+            operations = new ArrayList<>();
+
+            // Collect operations on relevant id
+            if (!id.isEmpty()) {
+                for (OperationItem operationItem : operationItems) {
+                    if (!operationItem.isTag() && operationItem.getId().equals(id)) {
+                        operations.add(operationItem);
+                    }
                 }
             }
-        }
 
-        // Sort operations based on priority
-        operations.sort(Comparator.comparingInt(OperationItem::getPriority));
+            // Collect operations on relevant tag_id
+            for (T tagKey : tagList) {
+                String tag_id = tagKey.location().toString();
+                for (OperationItem operationItem : operationItems) {
+                    if (operationItem.isTag() && operationItem.getId().equals(tag_id)) {
+                        operations.add(operationItem);
+                    }
+                }
+            }
 
-        // Remove any operations after last operation
-        for (OperationItem operationItem : operations) {
-            if (operationItem.isLast()) {
-                operations = operations.subList(0, operations.indexOf(operationItem) + 1);
-                break;
+            // 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;
+                }
+            }
+
+            // Save to cache if possible
+            if (Config.Server.optimizationUseCache.get()) {
+                cache.addEntry(id, operations);
             }
         }