Blocking 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"),
+	BLOCKING_COMPONENTS("blocking components", LifeCycle.EXPERIMENTAL, "blocking components"),
 	;
 
 	private final String codeName;

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

@@ -7,6 +7,7 @@
 import ch.njol.skript.registrations.Classes;
 import org.skriptlang.skript.addon.AddonModule;
 import org.skriptlang.skript.addon.SkriptAddon;
+import org.skriptlang.skript.bukkit.itemcomponents.blocking.BlockingModule;
 import org.skriptlang.skript.bukkit.itemcomponents.equippable.EquippableModule;
 import org.skriptlang.skript.bukkit.itemcomponents.generic.ExprItemCompCopy;
 
@@ -47,7 +48,10 @@ public String toVariableNameString(ComponentWrapper wrapper) {
 
 	@Override
 	public void load(SkriptAddon addon) {
-		addon.loadModules(new EquippableModule());
+		addon.loadModules(
+			new EquippableModule(),
+			new BlockingModule()
+		);
 
 		ExprItemCompCopy.register(addon.syntaxRegistry());
 	}

src/main/java/org/skriptlang/skript/bukkit/itemcomponents/blocking/BlockingExperimentalSyntax.java

@@ -0,0 +1,20 @@
+package org.skriptlang.skript.bukkit.itemcomponents.blocking;
+
+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#BLOCKING_COMPONENTS}.
+ */
+public interface BlockingExperimentalSyntax extends SimpleExperimentalSyntax {
+
+	ExperimentData EXPERIMENT_DATA = ExperimentData.createSingularData(Feature.BLOCKING_COMPONENTS);
+
+	@Override
+	default ExperimentData getExperimentData() {
+		return EXPERIMENT_DATA;
+	}
+
+}

src/main/java/org/skriptlang/skript/bukkit/itemcomponents/blocking/BlockingModule.java

@@ -0,0 +1,173 @@
+package org.skriptlang.skript.bukkit.itemcomponents.blocking;
+
+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.BlocksAttacks;
+import io.papermc.paper.datacomponent.item.blocksattacks.DamageReduction;
+import io.papermc.paper.datacomponent.item.blocksattacks.ItemDamageFunction;
+import org.bukkit.inventory.ItemStack;
+import org.skriptlang.skript.addon.AddonModule;
+import org.skriptlang.skript.addon.SkriptAddon;
+import org.skriptlang.skript.bukkit.itemcomponents.blocking.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 BlockingModule implements AddonModule {
+
+	@Override
+	public boolean canLoad(SkriptAddon addon) {
+		return Skript.classExists("io.papermc.paper.datacomponent.item.BlocksAttacks");
+	}
+
+	@Override
+	public void init(SkriptAddon addon) {
+		Classes.registerClass(new ClassInfo<>(BlockingWrapper.class, "blockingcomponent")
+			.user("blocking ?components?")
+			.name("Blocking Component")
+			.description("""
+				Represents a blocking component used for items.
+				NOTE: Blocking component elements are experimental. Thus, they are subject to change and may not work as intended.
+				""")
+			.requiredPlugins("Minecraft 1.21.5+")
+			.since("INSERT VERSION")
+			.defaultExpression(new EventValueExpression<>(BlockingWrapper.class))
+			.parser(new Parser<>() {
+				@Override
+				public boolean canParse(ParseContext context) {
+					return false;
+				}
+
+				@Override
+				public String toString(BlockingWrapper wrapper, int flags) {
+					return "blocking component";
+				}
+
+				@Override
+				public String toVariableNameString(BlockingWrapper wrapper) {
+					return "blocking component#" + wrapper.hashCode();
+				}
+			})
+			.after("itemstack", "itemtype", "slot")
+		);
+
+		Classes.registerClass(new ClassInfo<>(DamageReductionWrapper.class, "damagereduction")
+			.user("damage ?reductions?")
+			.name("Damage Reduction")
+			.description("""
+				Represents a damage reduction that is applied to a blocking component.
+				Damage Reductions contain data that attribute to:
+					- What damage types can be being blocked
+					- The base amount of damage to block when blocking one of the damage types
+					- The factor amount of damage to block when blocking one of the damage types
+					- The angle at which the item can block when blocking one of the damage types
+				NOTE: Blocking component elements are experimental. Thus, they are subject to change and may not work as intended.
+				""")
+			.requiredPlugins("Minecraft 1.21.5+")
+			.since("INSERT VERSION")
+			.defaultExpression(new EventValueExpression<>(DamageReductionWrapper.class))
+			.parser(new Parser<>() {
+				@Override
+				public boolean canParse(ParseContext context) {
+					return false;
+				}
+
+				@Override
+				public String toString(DamageReductionWrapper wrapper, int flags) {
+					return "damage reduction";
+				}
+
+				@Override
+				public String toVariableNameString(DamageReductionWrapper wrapper) {
+					return "damage reduction#" + wrapper.hashCode();
+				}
+			})
+		);
+
+		Classes.registerClass(new ClassInfo<>(DamageFunctionWrapper.class, "itemdamagefunction")
+			.user("item ?damage ?functions?")
+			.name("Item Damage Function")
+			.description("""
+				Represents an item damage function that is applied to a blocking component.
+				Item Damage Functions contain data that attribute to:
+					- The base amount of damage to be applied to the item, if the attack damage passes the threshold
+					- The factor amount to get a fraction of the attack damage to be applied to the item, if the attack damage passes the threshold
+					- The threshold amount
+				NOTE: Blocking component elements are experimental. Thus, they are subject to change and may not work as intended.
+				""")
+			.requiredPlugins("Minecraft 1.21.5+")
+			.since("INSERT VERSION")
+			.defaultExpression(new EventValueExpression<>(DamageFunctionWrapper.class))
+			.parser(new Parser<>() {
+				@Override
+				public boolean canParse(ParseContext context) {
+					return false;
+				}
+
+				@Override
+				public String toString(DamageFunctionWrapper wrapper, int flags) {
+					return "item damage function";
+				}
+
+				@Override
+				public String toVariableNameString(DamageFunctionWrapper wrapper) {
+					return "item damage function#" + wrapper.hashCode();
+				}
+			})
+		);
+
+		Converters.registerConverter(BlocksAttacks.class, BlockingWrapper.class, BlockingWrapper::new, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(ItemStack.class, BlockingWrapper.class, BlockingWrapper::new, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(ItemType.class, BlockingWrapper.class, itemType -> new BlockingWrapper(new ItemSource<>(itemType)), Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(Slot.class, BlockingWrapper.class, slot -> {
+			ItemSource<Slot> itemSource = ItemSource.fromSlot(slot);
+			if (itemSource == null)
+				return null;
+			return new BlockingWrapper(itemSource);
+		}, Converter.NO_RIGHT_CHAINING);
+
+		Converters.registerConverter(DamageReduction.class, DamageReductionWrapper.class, DamageReductionWrapper::new, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(ItemDamageFunction.class, DamageFunctionWrapper.class, DamageFunctionWrapper::new, Converter.NO_RIGHT_CHAINING);
+	}
+
+	@Override
+	public void load(SkriptAddon addon) {
+		register(addon.syntaxRegistry(),
+
+			ExprBlockCompBlockSound::register,
+			ExprBlockCompBypass::register,
+			ExprBlockCompDamageFunction::register,
+			ExprBlockCompDelay::register,
+			ExprBlockCompDisableScale::register,
+			ExprBlockCompDisableSound::register,
+			ExprBlockCompReductions::register,
+			ExprBlockingComponent::register,
+			ExprDamageFunctionBase::register,
+			ExprDamageFunctionFactor::register,
+			ExprDamageFunctionThreshold::register,
+			ExprReductionAngle::register,
+			ExprReductionBase::register,
+			ExprReductionDamageTypes::register,
+			ExprReductionFactor::register,
+
+			ExprSecBlankBlockComp::register,
+			ExprSecDamageFunction::register,
+			ExprSecReduction::register
+		);
+	}
+
+	private void register(SyntaxRegistry registry, Consumer<SyntaxRegistry>... consumers) {
+		Arrays.stream(consumers).forEach(consumer -> consumer.accept(registry));
+	}
+
+}