Tool Components

src/main/java/ch/njol/skript/registrations/Feature.java

@@ -18,7 +18,8 @@ public enum Feature implements Experiment {
 	CATCH_ERRORS("catch runtime errors", LifeCycle.EXPERIMENTAL, "error catching [section]"),
 	TYPE_HINTS("type hints", LifeCycle.EXPERIMENTAL, "[local variable] type hints"),
 	DAMAGE_SOURCE("damage source", LifeCycle.EXPERIMENTAL, "damage source[s]"),
-	EQUIPPABLE_COMPONENTS("equippable components", LifeCycle.EXPERIMENTAL, "equippable components")
+	EQUIPPABLE_COMPONENTS("equippable components", LifeCycle.EXPERIMENTAL, "equippable components"),
+	TOOL_COMPONENTS("tool components", LifeCycle.EXPERIMENTAL, "tool components"),
 	;
 
 	private final String codeName;

src/main/java/ch/njol/util/Math2.java

@@ -1,11 +1,8 @@
 package ch.njol.util;
 
 import ch.njol.skript.Skript;
-import org.jetbrains.annotations.ApiStatus.ScheduledForRemoval;
 import org.jetbrains.annotations.ApiStatus;
 
-import java.util.Arrays;
-
 /**
  * This class is not to be used by addons. In the future methods may
  * change signature, contract and/or get removed without warning.
@@ -57,6 +54,56 @@ public static double fit(double min, double value, double max) {
 		return Math.min(Math.max(value, min), max);
 	}
 
+	/**
+	 * Fits the sum of {@code base} and {@code add} into the interval of {@code min} and {@link Integer#MAX_VALUE}.
+	 * If the sum of {@code base} and {@code add} results in an overflow, returns {@link Integer#MAX_VALUE}.
+	 *
+	 * @return An int in between {@code min} and {@link Integer#MAX_VALUE} or {@link Integer#MAX_VALUE} if the sum overflowed.
+	 */
+	public static int fitOverflowMax(int min, int base, int add) {
+		return fitOverflow(min, base, add, Integer.MAX_VALUE, Integer.MAX_VALUE);
+	}
+
+	/**
+	 * Fits the sum of {@code base} and {@code add} into the interval of {@code min} and {@code max}.
+	 * If the sum of {@code base} and {@code add} results in an overflow, returns {@code overflow}.
+	 *
+	 * @return An int in between {@code min} and {@code max} or {@code overflow} if the sum overflowed.
+	 */
+	public static int fitOverflow(int min, int base, int add, int max, int overflow) {
+		assert min <= max;
+		int value = base + add;
+		boolean overflowed = value - base != add;
+		if (overflowed)
+			return overflow;
+		return Math.min(Math.max(value, min), max);
+	}
+
+	/**
+	 * Fits the sum of {@code base} and {@code add} into the interval of {@code min} and {@link Float#MAX_VALUE}.
+	 * If the sum of {@code base} and {@code add} results in an overflow, returns {@link Float#MAX_VALUE}.
+	 *
+	 * @return A float in between {@code min} and {@link Float#MAX_VALUE} or {@link Float#MAX_VALUE} if the sum overflowed.
+	 */
+	public static float fitOverflowMax(float min, float base, float add) {
+		return fitOverflow(min, base, add, Float.MAX_VALUE, Float.MAX_VALUE);
+	}
+
+	/**
+	 * Fits the sum of {@code base} and {@code add} into the interval of {@code min} and {@code max}.
+	 * If the sum of {@code base} and {@code add} results in an overflow, returns {@code overflow}.
+	 *
+	 * @return A float in between {@code min} and {@code max} or {@code overflow} if the sum overflowed.
+	 */
+	public static float fitOverflow(float min, float base, float add, float max, float overflow) {
+		assert min <= max;
+		float value = base + add;
+		boolean overflowed = value - base != add;
+		if (overflowed)
+			return overflow;
+		return Math.min(Math.max(value, min), max);
+	}
+
 	/**
 	 * Modulo that returns positive values even for negative arguments.
 	 *

src/main/java/org/skriptlang/skript/bukkit/itemcomponents/ItemComponentModule.java

@@ -9,6 +9,7 @@
 import org.skriptlang.skript.addon.SkriptAddon;
 import org.skriptlang.skript.bukkit.itemcomponents.equippable.EquippableModule;
 import org.skriptlang.skript.bukkit.itemcomponents.generic.ExprItemCompCopy;
+import org.skriptlang.skript.bukkit.itemcomponents.tool.ToolModule;
 
 public class ItemComponentModule implements AddonModule {
 
@@ -47,7 +48,10 @@ public String toVariableNameString(ComponentWrapper wrapper) {
 
 	@Override
 	public void load(SkriptAddon addon) {
-		addon.loadModules(new EquippableModule());
+		addon.loadModules(
+			new EquippableModule(),
+			new ToolModule()
+		);
 
 		ExprItemCompCopy.register(addon.syntaxRegistry());
 	}

src/main/java/org/skriptlang/skript/bukkit/itemcomponents/tool/ToolExperimentalSyntax.java

@@ -0,0 +1,20 @@
+package org.skriptlang.skript.bukkit.itemcomponents.tool;
+
+import ch.njol.skript.lang.SyntaxElement;
+import ch.njol.skript.registrations.Feature;
+import org.skriptlang.skript.lang.experiment.ExperimentData;
+import org.skriptlang.skript.lang.experiment.SimpleExperimentalSyntax;
+
+/**
+ * Typed {@link SimpleExperimentalSyntax} for {@link SyntaxElement}s that require {@link Feature#TOOL_COMPONENTS}.
+ */
+public interface ToolExperimentalSyntax extends SimpleExperimentalSyntax {
+
+	ExperimentData EXPERIMENT_DATA = ExperimentData.createSingularData(Feature.TOOL_COMPONENTS);
+
+	@Override
+	default ExperimentData getExperimentData() {
+		return EXPERIMENT_DATA;
+	}
+
+}

src/main/java/org/skriptlang/skript/bukkit/itemcomponents/tool/ToolModule.java

@@ -0,0 +1,133 @@
+package org.skriptlang.skript.bukkit.itemcomponents.tool;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.aliases.ItemType;
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.classes.Parser;
+import ch.njol.skript.expressions.base.EventValueExpression;
+import ch.njol.skript.lang.ParseContext;
+import ch.njol.skript.registrations.Classes;
+import ch.njol.skript.util.ItemSource;
+import ch.njol.skript.util.slot.Slot;
+import io.papermc.paper.datacomponent.item.Tool;
+import io.papermc.paper.datacomponent.item.Tool.Rule;
+import org.bukkit.inventory.ItemStack;
+import org.skriptlang.skript.addon.AddonModule;
+import org.skriptlang.skript.addon.SkriptAddon;
+import org.skriptlang.skript.bukkit.itemcomponents.tool.elements.*;
+import org.skriptlang.skript.lang.converter.Converter;
+import org.skriptlang.skript.lang.converter.Converters;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+public class ToolModule implements AddonModule {
+
+	@Override
+	public boolean canLoad(SkriptAddon addon) {
+		return Skript.classExists("io.papermc.paper.datacomponent.item.Tool");
+	}
+
+	@Override
+	public void init(SkriptAddon addon) {
+		Classes.registerClass(new ClassInfo<>(ToolWrapper.class, "toolcomponent")
+			.user("tool ?components?")
+			.name("Tool Component")
+			.description("""
+				Represents a tool component used for items.
+				NOTE: Tool component elements are experimental. Thus, they are subject to change and may not work as intended.
+				""")
+			.requiredPlugins("Minecraft 1.21.3+")
+			.since("INSERT VERSION")
+			.defaultExpression(new EventValueExpression<>(ToolWrapper.class))
+			.parser(new Parser<>() {
+				@Override
+				public boolean canParse(ParseContext context) {
+					return false;
+				}
+
+				@Override
+				public String toString(ToolWrapper wrapper, int flags) {
+					return "tool component";
+				}
+
+				@Override
+				public String toVariableNameString(ToolWrapper wrapper) {
+					return "tool component#" + wrapper.hashCode();
+				}
+			})
+			.after("itemstack", "itemtype", "slot")
+		);
+
+		Classes.registerClass(new ClassInfo<>(ToolRuleWrapper.class, "toolrule")
+			.user("tool ?rules?")
+			.name("Tool Rule")
+			.description("""
+				Represents a rule that can be applied to a tool component.
+				A tool rule consists of:
+					- Block types that the rule should be applied to
+					- Mining speed for the blocks
+					- Whether the blocks should drop their respective items
+				NOTE: Tool component elements are experimental. Thus, they are subject to change and may not work as intended.
+				""")
+			.requiredPlugins("Minecraft 1.21.3+")
+			.since("INSERT VERSION")
+			.defaultExpression(new EventValueExpression<>(ToolRuleWrapper.class))
+			.parser(new Parser<>() {
+				@Override
+				public boolean canParse(ParseContext context) {
+					return false;
+				}
+
+				@Override
+				public String toString(ToolRuleWrapper wrapper, int flags) {
+					return "tool rule";
+				}
+
+				@Override
+				public String toVariableNameString(ToolRuleWrapper wrapper) {
+					return "tool rule#" + wrapper.hashCode();
+				}
+			})
+		);
+
+		Converters.registerConverter(Tool.class, ToolWrapper.class, ToolWrapper::new, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(ItemStack.class, ToolWrapper.class, ToolWrapper::new, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(ItemType.class, ToolWrapper.class, itemType -> new ToolWrapper(new ItemSource<>(itemType)), Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(Slot.class, ToolWrapper.class, slot -> {
+			ItemSource<Slot> itemSource = ItemSource.fromSlot(slot);
+			if (itemSource == null)
+				return null;
+			return new ToolWrapper(itemSource);
+		}, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(Rule.class, ToolRuleWrapper.class, ToolRuleWrapper::new, Converter.NO_RIGHT_CHAINING);
+	}
+
+	@Override
+	public void load(SkriptAddon addon) {
+		register(addon.syntaxRegistry(),
+
+			CondToolCompCreative::register,
+			CondToolRuleDrops::register,
+
+			EffToolCompCreative::register,
+			EffToolRuleDrops::register,
+
+			ExprToolCompDamage::register,
+			ExprToolCompMiningSpeed::register,
+			ExprToolComponent::register,
+			ExprToolCompRules::register,
+			ExprToolRuleBlocks::register,
+			ExprToolRuleSpeed::register,
+
+			ExprSecBlankToolComp::register,
+			ExprSecToolRule::register
+		);
+	}
+
+	private void register(SyntaxRegistry registry, Consumer<SyntaxRegistry>... consumers) {
+		Arrays.stream(consumers).forEach(consumer -> consumer.accept(registry));
+	}
+
+}