diff --git a/src/main/java/ch/njol/skript/Skript.java b/src/main/java/ch/njol/skript/Skript.java index e38c523eb62..a85d7a80be4 100644 --- a/src/main/java/ch/njol/skript/Skript.java +++ b/src/main/java/ch/njol/skript/Skript.java @@ -95,12 +95,14 @@ import org.skriptlang.skript.bukkit.brewing.BrewingModule; import org.skriptlang.skript.bukkit.damagesource.DamageSourceModule; import org.skriptlang.skript.bukkit.displays.DisplayModule; +import org.skriptlang.skript.bukkit.entity.EntityModule; import org.skriptlang.skript.bukkit.fishing.FishingModule; import org.skriptlang.skript.bukkit.furnace.FurnaceModule; import org.skriptlang.skript.bukkit.input.InputModule; import org.skriptlang.skript.bukkit.itemcomponents.ItemComponentModule; import org.skriptlang.skript.bukkit.log.runtime.BukkitRuntimeErrorConsumer; import org.skriptlang.skript.bukkit.loottables.LootTableModule; +import org.skriptlang.skript.bukkit.misc.MiscModule; import org.skriptlang.skript.bukkit.registration.BukkitRegistryKeys; import org.skriptlang.skript.bukkit.registration.BukkitSyntaxInfos; import org.skriptlang.skript.bukkit.tags.TagModule; @@ -122,11 +124,13 @@ import org.skriptlang.skript.registration.SyntaxOrigin; import org.skriptlang.skript.registration.SyntaxRegistry; import org.skriptlang.skript.util.ClassLoader; +import org.skriptlang.skript.util.ReflectUtils; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.lang.Thread.UncaughtExceptionHandler; +import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -187,6 +191,7 @@ public final class Skript extends JavaPlugin implements Listener { private static org.skriptlang.skript.@UnknownNullability Skript skript = null; private static org.skriptlang.skript.@UnknownNullability Skript unmodifiableSkript = null; + private static final ReflectUtils REFLECT_UTILS = new ReflectUtils(); private static boolean disabled = false; private static boolean partDisabled = false; @@ -586,7 +591,6 @@ public void onEnable() { try { getAddonInstance().loadClasses("ch.njol.skript", "conditions", "effects", "events", "expressions", "entity", "literals", "sections", "structures"); - getAddonInstance().loadClasses("org.skriptlang.skript.bukkit", "misc"); // todo: become proper module once registry api is merged FishingModule.load(); BreedingModule.load(); @@ -599,7 +603,9 @@ public void onEnable() { new DamageSourceModule(), new ItemComponentModule(), new BrewingModule(), - new CommonModule() + new CommonModule(), + new EntityModule(), + new MiscModule() ); } catch (final Exception e) { exception(e, "Could not load required .class files: " + e.getLocalizedMessage()); @@ -851,7 +857,7 @@ public void run() { } }; } - } + } private void runTests() { info("Skript testing environment enabled, starting..."); @@ -1125,80 +1131,6 @@ public static boolean isRunningMinecraft(final Version v) { return minecraftVersion.compareTo(v) >= 0; } - /** - * Tests whether a given class exists in the classpath. - * - * @param className The {@link Class#getCanonicalName() canonical name} of the class - * @return Whether the given class exists. - */ - public static boolean classExists(final String className) { - try { - Class.forName(className); - return true; - } catch (final ClassNotFoundException e) { - return false; - } - } - - /** - * Tests whether a method exists in the given class. - * - * @param c The class - * @param methodName The name of the method - * @param parameterTypes The parameter types of the method - * @return Whether the given method exists. - */ - public static boolean methodExists(final Class c, final String methodName, final Class... parameterTypes) { - try { - c.getDeclaredMethod(methodName, parameterTypes); - return true; - } catch (final NoSuchMethodException e) { - return false; - } catch (final SecurityException e) { - return false; - } - } - - /** - * Tests whether a method exists in the given class, and whether the return type matches the expected one. - *

- * Note that this method doesn't work properly if multiple methods with the same name and parameters exist but have different return types. - * - * @param c The class - * @param methodName The name of the method - * @param parameterTypes The parameter types of the method - * @param returnType The expected return type - * @return Whether the given method exists. - */ - public static boolean methodExists(final Class c, final String methodName, final Class[] parameterTypes, final Class returnType) { - try { - final Method m = c.getDeclaredMethod(methodName, parameterTypes); - return m.getReturnType() == returnType; - } catch (final NoSuchMethodException e) { - return false; - } catch (final SecurityException e) { - return false; - } - } - - /** - * Tests whether a field exists in the given class. - * - * @param c The class - * @param fieldName The name of the field - * @return Whether the given field exists. - */ - public static boolean fieldExists(final Class c, final String fieldName) { - try { - c.getDeclaredField(fieldName); - return true; - } catch (final NoSuchFieldException e) { - return false; - } catch (final SecurityException e) { - return false; - } - } - @Nullable static Metrics metrics; @@ -2138,4 +2070,135 @@ public SkriptUpdater getUpdater() { return updater; } + // + /** + * Tests whether a given class exists in the classpath. + * + * @param className The {@link Class#getCanonicalName() canonical name} of the class + * @return Whether the given class exists. + */ + public static boolean classExists(String className) { + return REFLECT_UTILS.classExists(className); + } + + /** + * @param className The full package and class name. + * @return The resulting {@link Class} if found, otherwise {@code null}. + */ + public static @Nullable Class getClass(String className) { + return REFLECT_UTILS.getClass(className); + } + + /** + * Tests whether a method exists in the given class. + * + * @param c The class + * @param methodName The name of the method + * @param parameterTypes The parameter types of the method + * @return Whether the given method exists. + */ + public static boolean methodExists(Class c, String methodName, Class @Nullable ... parameterTypes) { + return REFLECT_UTILS.methodExists(c, methodName, parameterTypes); + } + + /** + * Tests whether a method exists in the given class, and whether the return type matches the expected one. + *

+ * Note that this method doesn't work properly if multiple methods with the same name and parameters exist but have different return types. + * + * @param c The class + * @param methodName The name of the method + * @param parameterTypes The parameter types of the method + * @param returnType The expected return type + * @return Whether the given method exists. + */ + public static boolean methodExists(Class c, String methodName, Class @Nullable [] parameterTypes, Class returnType) { + return REFLECT_UTILS.methodExists(c, methodName, parameterTypes, returnType); + } + + /** + * @param c The {@link Class} to get the method from. + * @param methodName The name of the method. + * @param params The {@link Class}es used as parameters for the desired method. + * @return The resulting {@link Method} if it exists, otherwise {@code null}. + */ + public static @Nullable Method getMethod(Class c, String methodName, Class @Nullable ... params) { + return REFLECT_UTILS.getMethod(c, methodName, params); + } + + /** + * @param c The {@link Class} to get the method from. + * @param methodName The name of the method. + * @param params The {@link Class}es used as parameters for the desired method. + * @param returnType The return type of the desired method. + * @return The resulting {@link Method} if it exists, otherwise {@code null}. + */ + public static @Nullable Method getMethod(Class c, String methodName, Class @Nullable [] params, @Nullable Class returnType) { + return REFLECT_UTILS.getMethod(c, methodName, params, returnType); + } + + /** + * Tests whether a field exists in the given class. + * + * @param c The class + * @param fieldName The name of the field + * @return Whether the given field exists. + */ + public static boolean fieldExists(Class c, String fieldName) { + return REFLECT_UTILS.fieldExists(c, fieldName); + } + + /** + * @param c The {@link Class} to get the field from. + * @param fieldName The name of the field. + * @return The resulting {@link Field} if it exists, otherwise {@code null}. + */ + public static @Nullable Field getField(Class c, String fieldName) { + return REFLECT_UTILS.getField(c, fieldName); + } + + /** + * Invoke a static {@link Method}. + * @param method The {@link Method} to invoke. + * @return The result of the invocation if successful, otherwise {@code null}. + * @param The expected return type from the invocation. + */ + public static @Nullable Type invokeMethod(Method method) { + return REFLECT_UTILS.invokeMethod(method); + } + + /** + * Invoke a {@link Method}. + * @param method The {@link Method} to invoke. + * @param holder The holder object to invoke for. + * @param params The parameters to pass into the invocation. + * @return The result of the invocation if successful, otherwise {@code null}. + * @param The expected return type from the invocation. + */ + public static @Nullable Type invokeMethod(Method method, @Nullable Object holder, Object @Nullable ... params) { + return REFLECT_UTILS.invokeMethod(method, holder, params); + } + + /** + * Gets the values of a static {@link Field}. + * @param field The {@link Field} to get from. + * @return The value of the {@link Field}. + * @param The expected return type. + */ + public static @Nullable Type getFieldValue(Field field) { + return REFLECT_UTILS.getFieldValue(field); + } + + /** + * Gets the values of a {@link Field}. + * @param field The {@link Field} to get from. + * @param holder The holder object to get the field for. + * @return The value of the {@link Field}. + * @param The expected return type. + */ + public static @Nullable Type getFieldValue(Field field, @Nullable Object holder) { + return REFLECT_UTILS.getFieldValue(field, holder); + } + // + } diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java index d723321dca0..ed0292a3391 100644 --- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java +++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java @@ -241,7 +241,6 @@ private static void addSuperEntity(String codeName, Class enti addSimpleEntity("happy ghast", HappyGhast.class); if (Skript.isRunningMinecraft(1, 21, 9)) { - addSimpleEntity("copper golem", CopperGolem.class); addSimpleEntity("mannequin", Mannequin.class); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java new file mode 100644 index 00000000000..124e5e0dff4 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java @@ -0,0 +1,14 @@ +package org.skriptlang.skript.bukkit.entity; + +import org.skriptlang.skript.addon.AddonModule; +import org.skriptlang.skript.addon.SkriptAddon; +import org.skriptlang.skript.bukkit.entity.coppergolem.CopperGolemModule; + +public class EntityModule implements AddonModule { + + @Override + public void load(SkriptAddon addon) { + addon.loadModules(new CopperGolemModule()); + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/CopperGolemData.java b/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/CopperGolemData.java new file mode 100644 index 00000000000..d14c4599a3c --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/CopperGolemData.java @@ -0,0 +1,115 @@ +package org.skriptlang.skript.bukkit.entity.coppergolem; + +import ch.njol.skript.entity.EntityData; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.localization.Language; +import ch.njol.util.Kleenean; +import io.papermc.paper.world.WeatheringCopperState; +import org.bukkit.entity.CopperGolem; +import org.bukkit.entity.CopperGolem.Oxidizing.Waxed; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Objects; + +public class CopperGolemData extends EntityData { + + public static void register() { + register(CopperGolemData.class, "copper golem", CopperGolem.class, 0, "copper golem"); + } + + private Kleenean waxed = Kleenean.UNKNOWN; + private @Nullable WeatheringCopperState state; + + public CopperGolemData() {} + + public CopperGolemData(@Nullable Kleenean waxed, @Nullable WeatheringCopperState state) { + this.waxed = waxed == null ? Kleenean.UNKNOWN : waxed; + this.state = state; + } + + @Override + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + //noinspection unchecked + Literal expr = (Literal) exprs[0]; + if (expr != null) + state = expr.getSingle(); + if (matchedPattern == 1) { + waxed = Kleenean.TRUE; + } else if (matchedPattern == 2) { + waxed = Kleenean.FALSE; + } + return true; + } + + @Override + protected boolean init(@Nullable Class entityClass, @Nullable CopperGolem golem) { + if (golem != null) { + state = golem.getWeatheringState(); + waxed = Kleenean.get(golem.getOxidizing() instanceof Waxed); + } + return true; + } + + @Override + public void set(CopperGolem golem) { + if (state != null) + golem.setWeatheringState(state); + if (waxed.isTrue()) + golem.setOxidizing(CopperGolem.Oxidizing.waxed()); + } + + @Override + protected boolean match(CopperGolem golem) { + if (!dataMatch(state, golem.getWeatheringState())) + return false; + return kleeneanMatch(waxed, Kleenean.get(golem.getOxidizing() instanceof Waxed)); + } + + @Override + public Class getType() { + return CopperGolem.class; + } + + @Override + public @NotNull EntityData getSuperType() { + return new CopperGolemData(); + } + + @Override + protected int hashCode_i() { + return Objects.hashCode(state) + waxed.hashCode(); + } + + @Override + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof CopperGolemData other)) + return false; + return state == other.state && waxed == other.waxed; + } + + @Override + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof CopperGolemData other)) + return false; + return dataMatch(state, other.state) && kleeneanMatch(waxed, other.waxed); + } + + @Override + public String toString(int flags) { + StringBuilder builder = new StringBuilder(); + if (waxed.isTrue()) { + builder.append("waxed "); + } else if (waxed.isFalse()) { + builder.append("unwaxed "); + } + if (state != null) + builder.append(Language.getList("weathering copper states." + state.name())[0] + " "); + builder.append("copper golem"); + if (isPlural().isTrue()) + builder.append("s"); + return builder.toString(); + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/CopperGolemModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/CopperGolemModule.java new file mode 100644 index 00000000000..da9cff9fa7c --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/CopperGolemModule.java @@ -0,0 +1,21 @@ +package org.skriptlang.skript.bukkit.entity.coppergolem; + +import ch.njol.skript.Skript; +import org.skriptlang.skript.addon.AddonModule; +import org.skriptlang.skript.addon.SkriptAddon; + +public class CopperGolemModule implements AddonModule { + + @Override + public boolean canLoad(SkriptAddon addon) { + return Skript.classExists("org.bukkit.entity.CopperGolem"); + } + + @Override + public void load(SkriptAddon addon) { + ExprCopperGolemOxidationTime.register(addon.syntaxRegistry()); + + CopperGolemData.register(); + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/ExprCopperGolemOxidationTime.java b/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/ExprCopperGolemOxidationTime.java new file mode 100644 index 00000000000..afcd865b7d2 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/coppergolem/ExprCopperGolemOxidationTime.java @@ -0,0 +1,99 @@ +package org.skriptlang.skript.bukkit.entity.coppergolem; + +import ch.njol.skript.classes.Changer.ChangeMode; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.RequiredPlugins; +import ch.njol.skript.doc.Since; +import ch.njol.skript.expressions.base.SimplePropertyExpression; +import ch.njol.skript.util.Timespan; +import ch.njol.skript.util.Timespan.TimePeriod; +import ch.njol.util.coll.CollectionUtils; +import org.bukkit.entity.CopperGolem; +import org.bukkit.entity.CopperGolem.Oxidizing; +import org.bukkit.entity.CopperGolem.Oxidizing.AtTime; +import org.bukkit.entity.Entity; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Time Until Oxidation") +@Description(""" + The time until a copper golem oxidizes to its next state. (Normal -> Exposed -> Weathered -> Oxidized). + Copper golems that are waxed do not go through oxidation. + Setting or resetting the time until oxidation on a waxed copper golem will remove the waxed state. + Resetting the time until oxidation uses vanilla behavior of generating a random time between 7 hours and 7 hours 40 minutes. + """) +@Example("set {_time} to the time until oxidation of last spawned copper golem") +@Example("set the time until oxidation of last spawned copper golem to 10 seconds") +@Example("clear the time until oxidation of last spawned copper golem") +@RequiredPlugins("Minecraft 1.21.9+") +@Since("INSERT VERSION") +public class ExprCopperGolemOxidationTime extends SimplePropertyExpression { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EXPRESSION, + infoBuilder( + ExprCopperGolemOxidationTime.class, + Timespan.class, + "time until oxidation", + "entities", + false + ).supplier(ExprCopperGolemOxidationTime::new) + .build() + ); + } + + @Override + public @Nullable Timespan convert(Entity entity) { + if (!(entity instanceof CopperGolem golem)) + return null; + if (!(golem.getOxidizing() instanceof AtTime atTime)) + return null; + long worldTime = golem.getWorld().getGameTime(); + long oxidationTime = atTime.time(); + if (worldTime > oxidationTime) + return null; + return new Timespan(TimePeriod.TICK, oxidationTime - worldTime); + } + + @Override + public Class @Nullable [] acceptChange(ChangeMode mode) { + if (mode == ChangeMode.SET || mode == ChangeMode.RESET) + return CollectionUtils.array(Timespan.class); + return null; + } + + @Override + public void change(Event event, Object @Nullable [] delta, ChangeMode mode) { + if (mode == ChangeMode.SET) { + assert delta != null; + long ticks = ((Timespan) delta[0]).getAs(TimePeriod.TICK); + for (Entity entity : getExpr().getArray(event)) { + if (!(entity instanceof CopperGolem golem)) + continue; + long worldTime = golem.getWorld().getGameTime(); + golem.setOxidizing(Oxidizing.atTime(worldTime + ticks)); + } + } else if (mode == ChangeMode.RESET) { + for (Entity entity : getExpr().getArray(event)) { + if (!(entity instanceof CopperGolem golem)) + continue; + golem.setOxidizing(Oxidizing.unset()); + } + } + } + + @Override + public Class getReturnType() { + return Timespan.class; + } + + @Override + protected String getPropertyName() { + return "time until oxidation"; + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/MiscModule.java b/src/main/java/org/skriptlang/skript/bukkit/misc/MiscModule.java new file mode 100644 index 00000000000..0e340de063f --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/MiscModule.java @@ -0,0 +1,69 @@ +package org.skriptlang.skript.bukkit.misc; + +import ch.njol.skript.Skript; +import ch.njol.skript.classes.EnumClassInfo; +import ch.njol.skript.registrations.Classes; +import org.bukkit.block.data.type.CopperGolemStatue; +import org.skriptlang.skript.addon.AddonModule; +import org.skriptlang.skript.addon.SkriptAddon; +import org.skriptlang.skript.bukkit.misc.conditions.CondIsWaxed; +import org.skriptlang.skript.bukkit.misc.effects.EffRotate; +import org.skriptlang.skript.bukkit.misc.effects.EffWax; +import org.skriptlang.skript.bukkit.misc.expressions.ExprCopperGolemPose; +import org.skriptlang.skript.bukkit.misc.expressions.ExprCopperState; +import org.skriptlang.skript.bukkit.misc.expressions.ExprItemOfEntity; +import org.skriptlang.skript.bukkit.misc.expressions.ExprQuaternionAxisAngle; +import org.skriptlang.skript.bukkit.misc.expressions.ExprRotate; +import org.skriptlang.skript.bukkit.misc.expressions.ExprTextOf; +import org.skriptlang.skript.bukkit.paperutil.CopperState; +import org.skriptlang.skript.registration.SyntaxRegistry; + +import java.util.HashSet; +import java.util.Set; +import java.util.function.Consumer; + +public class MiscModule implements AddonModule { + + @Override + public void init(SkriptAddon addon) { + //noinspection unchecked,rawtypes + Classes.registerClass(new EnumClassInfo<>((Class) CopperState.getStateClass(), "weatheringcopperstate", "weathering copper states") + .user("(weathering ?)?copper ?states?") + .name("Weathering Copper State") + .description("The weathering state of a copper golem or copper block.") + .since("INSERT VERSION") + ); + + if (Skript.classExists("org.bukkit.block.data.type.CopperGolemStatue$Pose")) { + Classes.registerClass(new EnumClassInfo<>(CopperGolemStatue.Pose.class, "coppergolempose", "copper golem poses") + .user("copper ?golem ?(statue ?)?poses?") + .name("Copper Golem Pose") + .description("The pose of a copper golem statue.") + .requiredPlugins("Minecraft 1.21.9+") + .since("INSERT VERSION") + ); + } + } + + @Override + public void load(SkriptAddon addon) { + Set> elementsToLoad = new HashSet<>(Set.of( + CondIsWaxed::register, + EffRotate::register, + EffWax::register, + ExprCopperState::register, + ExprItemOfEntity::register, + ExprQuaternionAxisAngle::register, + ExprRotate::register + )); + + if (Skript.classExists("org.bukkit.entity.Display")) + elementsToLoad.add(ExprTextOf::register); + if (Skript.classExists("org.bukkit.block.data.type.CopperGolemStatue")) + elementsToLoad.add(ExprCopperGolemPose::register); + + SyntaxRegistry registry = addon.syntaxRegistry(); + elementsToLoad.forEach(consumer -> consumer.accept(registry)); + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/conditions/CondIsWaxed.java b/src/main/java/org/skriptlang/skript/bukkit/misc/conditions/CondIsWaxed.java new file mode 100644 index 00000000000..7f2c12fb8c7 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/conditions/CondIsWaxed.java @@ -0,0 +1,59 @@ +package org.skriptlang.skript.bukkit.misc.conditions; + +import ch.njol.skript.Skript; +import ch.njol.skript.conditions.base.PropertyCondition; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.RequiredPlugins; +import ch.njol.skript.doc.Since; +import com.destroystokyo.paper.MaterialTags; +import org.bukkit.block.Block; +import org.bukkit.entity.CopperGolem; +import org.bukkit.entity.CopperGolem.Oxidizing.Waxed; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Is Waxed") +@Description("Whether a copper golem or copper block is waxed.") +@Example(""" + if last spawned copper golem is not waxed: + wax last spawned copper golem + """) +@Example(""" + if {_block} is waxed: + unwax {_block} + """) +@RequiredPlugins("Minecraft 1.21.9+ (copper golems)") +@Since("INSERT VERSION") +public class CondIsWaxed extends PropertyCondition { + + private static final boolean COPPER_GOLEM_EXISTS = Skript.classExists("org.bukkit.entity.CopperGolem"); + + public static void register(SyntaxRegistry registry) { + String types = "blocks"; + if (Skript.classExists("org.bukkit.entity.CopperGolem")) + types = "entities/blocks"; + registry.register( + SyntaxRegistry.CONDITION, + infoBuilder(CondIsWaxed.class, PropertyType.BE, "waxed", types) + .supplier(CondIsWaxed::new) + .build() + ); + } + + @Override + public boolean check(Object object) { + if (COPPER_GOLEM_EXISTS && object instanceof CopperGolem golem) { + return golem.getOxidizing() instanceof Waxed; + } else if (object instanceof Block block) { + return MaterialTags.WAXED_COPPER_BLOCKS.isTagged(block); + } + return false; + } + + @Override + protected String getPropertyName() { + return "waxed"; + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffRotate.java b/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffRotate.java index 0fb51b6adca..39b9443c2d9 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffRotate.java +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffRotate.java @@ -1,8 +1,7 @@ package org.skriptlang.skript.bukkit.misc.effects; -import ch.njol.skript.Skript; import ch.njol.skript.doc.Description; -import ch.njol.skript.doc.Examples; +import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.lang.Effect; @@ -22,38 +21,44 @@ import org.skriptlang.skript.bukkit.misc.rotation.Rotator; import org.skriptlang.skript.bukkit.misc.rotation.Rotator.Axis; import org.skriptlang.skript.bukkit.misc.rotation.VectorRotator; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.Locale; @Name("Rotate") -@Description({ - "Rotates displays, quaternions, or vectors around an axis a set amount of degrees, or around all 3 axes at once.", - "Vectors can only be rotated around the global X/Y/Z axes, or an arbitrary vector axis.", - "Quaternions are more flexible, allowing rotation around the global or local X/Y/Z axes, arbitrary vectors, or all 3 local axes at once.", - "Global axes are the ones in the Minecraft world. Local axes are relative to how the quaternion is already oriented.", - "", - "Rotating a display is a shortcut for rotating its left rotation. If the right rotation needs to be modified, it should be acquired, rotated, and re-set.", - "", - "Note that rotating a quaternion/display around a vector results in a rotation around the local vector, so results may not be what you expect. " + - "For example, rotating quaternions/displays around vector(1, 0, 0) is the same as rotating around the local X axis.", - "The same applies to rotations by all three axes at once. " + - "In addition, rotating around all three axes of a quaternion/display at once will rotate in ZYX order, meaning the Z rotation will be applied first and the X rotation last." -}) -@Examples({ - "rotate {_quaternion} around x axis by 10 degrees", - "rotate last spawned block display around y axis by 10 degrees", - "rotate {_vector} around vector(1, 1, 1) by 45", - "rotate {_quaternion} by x 45, y 90, z 135" -}) +@Description(""" + Rotates displays, quaternions, or vectors around an axis a set amount of degrees, or around all 3 axes at once. + Vectors can only be rotated around the global X/Y/Z axes, or an arbitrary vector axis. + Quaternions are more flexible, allowing rotation around the global or local X/Y/Z axes, arbitrary vectors, or all 3 local axes at once. + Global axes are the ones in the Minecraft world. Local axes are relative to how the quaternion is already oriented. + + Rotating a display is a shortcut for rotating its left rotation. If the right rotation needs to be modified, it should be acquired, rotated, and re-set. + + Note that rotating a quaternion/display around a vector results in a rotation around the local vector, so results may not be what you expect. + For example, rotating quaternions/displays around vector(1, 0, 0) is the same as rotating around the local X axis. + The same applies to rotations by all three axes at once. + In addition, rotating around all three axes of a quaternion/display at once will rotate in ZYX order, meaning the Z rotation will be applied first and the X rotation last. + """) +@Example("rotate {_quaternion} around x axis by 10 degrees") +@Example("rotate last spawned block display around y axis by 10 degrees") +@Example("rotate {_vector} around vector(1, 1, 1) by 45") +@Example("rotate {_quaternion} by x 45, y 90, z 135") @Since("2.2-dev28, 2.10 (quaternions, displays)") public class EffRotate extends Effect { - static { - Skript.registerEffect(EffRotate.class, - "rotate %vectors/quaternions/displays% around [the] [global] (:x|:y|:z)(-| )axis by %number%", - "rotate %quaternions/displays% around [the|its|their] local (:x|:y|:z)(-| )ax(i|e)s by %number%", - "rotate %vectors/quaternions/displays% around [the] %vector% by %number%", - "rotate %quaternions/displays% by x %number%, y %number%(, [and]| and) z %number%" + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EFFECT, + SyntaxInfo.builder(EffRotate.class) + .addPatterns( + "rotate %vectors/quaternions/displays% around [the] [global] (:x|:y|:z)(-| )axis by %number%", + "rotate %quaternions/displays% around [the|its|their] local (:x|:y|:z)(-| )ax(i|e)s by %number%", + "rotate %vectors/quaternions/displays% around [the] %vector% by %number%", + "rotate %quaternions/displays% by x %number%, y %number%(, [and]| and) z %number%" + ) + .supplier(EffRotate::new) + .build() ); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffWax.java b/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffWax.java new file mode 100644 index 00000000000..1e6f44bcb82 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/effects/EffWax.java @@ -0,0 +1,124 @@ +package org.skriptlang.skript.bukkit.misc.effects; + +import ch.njol.skript.Skript; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.RequiredPlugins; +import ch.njol.skript.doc.Since; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.SyntaxStringBuilder; +import ch.njol.util.Kleenean; +import com.destroystokyo.paper.MaterialTags; +import com.google.common.collect.BiMap; +import com.google.common.collect.HashBiMap; +import io.papermc.paper.block.TileStateInventoryHolder; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.entity.CopperGolem; +import org.bukkit.entity.CopperGolem.Oxidizing; +import org.bukkit.entity.CopperGolem.Oxidizing.Waxed; +import org.bukkit.event.Event; +import org.bukkit.inventory.Inventory; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Wax") +@Description(""" + Wax or unwax a copper golem or copper block. + This does not change the weathering copper state of entities and blocks. + """) +@Example(""" + if last spawned copper golem is not waxed: + wax last spawned copper golem + """) +@Example(""" + if {_block} is waxed: + unwax {_block} + """) +@RequiredPlugins("Minecraft 1.21.9+ (copper golems)") +@Since("INSERT VERSION") +public class EffWax extends Effect { + + private static final BiMap WAX_CONVERSION; + private static final BiMap UNWAX_CONVERSION = HashBiMap.create(); + private static final boolean COPPER_GOLEM_EXISTS = Skript.classExists("org.bukkit.entity.CopperGolem"); + private static final boolean COPPER_CHEST_EXISTS = Skript.fieldExists(Material.class, "COPPER_CHEST"); + + static { + for (Material waxed : MaterialTags.WAXED_COPPER_BLOCKS.getValues()) { + Material unwaxed = Material.valueOf(waxed.name().replaceAll("WAXED_", "")); + UNWAX_CONVERSION.put(waxed, unwaxed); + } + WAX_CONVERSION = UNWAX_CONVERSION.inverse(); + } + + public static void register(SyntaxRegistry registry) { + String types = "%blocks%"; + if (COPPER_GOLEM_EXISTS) + types = "%entities/blocks%"; + + registry.register( + SyntaxRegistry.EFFECT, + SyntaxInfo.builder(EffWax.class) + .addPatterns("[:un]wax " + types) + .supplier(EffWax::new) + .build() + ); + } + + private boolean wax; + private Expression waxables; + + @Override + public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + waxables = exprs[0]; + wax = !parseResult.hasTag("un"); + return true; + } + + @Override + protected void execute(Event event) { + for (Object object : waxables.getArray(event)) { + if (COPPER_GOLEM_EXISTS && object instanceof CopperGolem golem) { + boolean isWaxed = golem.getOxidizing() instanceof Waxed; + if (wax == isWaxed) + continue; + CopperGolem.Oxidizing oxidizing = wax ? Oxidizing.waxed() : Oxidizing.unset(); + golem.setOxidizing(oxidizing); + } else if (object instanceof Block block) { + if (!MaterialTags.COPPER_BLOCKS.isTagged(block)) + continue; + BiMap conversion = wax ? WAX_CONVERSION : UNWAX_CONVERSION; + if (conversion.containsKey(block.getType())) { + Material material = conversion.get(block.getType()); + assert material != null; + if (COPPER_CHEST_EXISTS && block.getState() instanceof TileStateInventoryHolder inventoryHolder) { + Inventory inventory = inventoryHolder.getInventory(); + block.setType(material); + TileStateInventoryHolder newHolder = (TileStateInventoryHolder) block.getState(); + newHolder.getInventory().setStorageContents(inventory.getContents()); + } else { + block.setType(material); + } + } + } + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug); + if (wax) { + builder.append("wax"); + } else { + builder.append("unwax"); + } + builder.append(waxables); + return builder.toString(); + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprCopperGolemPose.java b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprCopperGolemPose.java new file mode 100644 index 00000000000..612ccf52351 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprCopperGolemPose.java @@ -0,0 +1,77 @@ +package org.skriptlang.skript.bukkit.misc.expressions; + +import ch.njol.skript.classes.Changer.ChangeMode; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.RequiredPlugins; +import ch.njol.skript.doc.Since; +import ch.njol.skript.expressions.base.SimplePropertyExpression; +import ch.njol.util.coll.CollectionUtils; +import org.bukkit.block.Block; +import org.bukkit.block.data.type.CopperGolemStatue; +import org.bukkit.block.data.type.CopperGolemStatue.Pose; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Copper Golem Statue Pose") +@Description("The pose of a copper golem statue.") +@Example("set {_pose} to the copper golem statue pose of {_statue}") +@Example("set the copper golem pose of {_statue} to running") +@RequiredPlugins("Minecraft 1.21.9+") +@Since("INSERT VERSION") +public class ExprCopperGolemPose extends SimplePropertyExpression { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EXPRESSION, + infoBuilder( + ExprCopperGolemPose.class, + Pose.class, + "copper golem [statue] pose[s]", + "blocks", + false + ).supplier(ExprCopperGolemPose::new) + .build() + ); + } + + @Override + public @Nullable Pose convert(Block block) { + if (block.getBlockData() instanceof CopperGolemStatue statue) + return statue.getCopperGolemPose(); + return null; + } + + @Override + public Class @Nullable [] acceptChange(ChangeMode mode) { + if (mode == ChangeMode.SET) + return CollectionUtils.array(Pose.class); + return null; + } + + @Override + public void change(Event event, Object @Nullable [] delta, ChangeMode mode) { + assert delta != null; + Pose pose = (Pose) delta[0]; + + for (Block block : getExpr().getArray(event)) { + if (block.getBlockData() instanceof CopperGolemStatue statue) { + statue.setCopperGolemPose(pose); + block.setBlockData(statue, true); + } + } + } + + @Override + public Class getReturnType() { + return Pose.class; + } + + @Override + protected String getPropertyName() { + return "copper golem pose"; + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprCopperState.java b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprCopperState.java new file mode 100644 index 00000000000..a9af985876b --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprCopperState.java @@ -0,0 +1,204 @@ +package org.skriptlang.skript.bukkit.misc.expressions; + +import ch.njol.skript.Skript; +import ch.njol.skript.classes.Changer.ChangeMode; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.RequiredPlugins; +import ch.njol.skript.doc.Since; +import ch.njol.skript.expressions.base.SimplePropertyExpression; +import ch.njol.util.coll.CollectionUtils; +import com.destroystokyo.paper.MaterialTags; +import io.papermc.paper.block.TileStateInventoryHolder; +import io.papermc.paper.world.WeatheringCopperState; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.entity.CopperGolem; +import org.bukkit.event.Event; +import org.bukkit.inventory.Inventory; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.bukkit.paperutil.CopperState; +import org.skriptlang.skript.registration.SyntaxRegistry; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +@Name("Weathering Copper State") +@Description(""" + The weathering copper state of a copper golem or copper block. + Changing the copper state does not change the waxed state. + """) +@Example(""" + if the copper state of last spawned copper golem is weathered: + set the copper state of last spawned golem to normal + """) +@Example(""" + if the weathering copper state of {_block} is not oxidized: + set the weathering copper state of {_block} to oxidized + """) +@RequiredPlugins("Minecraft 1.21.9+ (copper golems)") +@Since("INSERT VERSION") +public class ExprCopperState extends SimplePropertyExpression { + + // TODO: Remove 'CopperState' and change all instances of 'Enum' to 'WeatheringCopperState' when 1.21.9+ is minimum version. + + private static final CopperStateMaterialMap STATE_MATERIALS = new CopperStateMaterialMap(); + private static final List STATE_REPLACEMENTS = new ArrayList<>(); + private static final boolean COPPER_GOLEM_EXISTS = Skript.classExists("org.bukkit.entity.CopperGolem"); + private static final boolean COPPER_CHEST_EXISTS = Skript.fieldExists(Material.class, "COPPER_CHEST"); + + static { + for (Enum state : CopperState.getValues()) { + if (state.name().equals("UNAFFECTED")) + continue; + STATE_REPLACEMENTS.add(state.name() + "_"); + } + + for (Material material : MaterialTags.COPPER_BLOCKS.getValues()) { + Enum state = getMaterialCopperState(material); + assert state != null; + String blockType = getBlockType(material); + STATE_MATERIALS.putMaterial(blockType, state, material); + } + } + + public static void register(SyntaxRegistry registry) { + String type = "blocks"; + if (Skript.classExists("org.bukkit.entity.CopperGolem")) + type = "entities/blocks"; + + registry.register( + SyntaxRegistry.EXPRESSION, + infoBuilder( + ExprCopperState.class, + Object.class, + "[weathering] copper state[s]", + type, + false + ).supplier(ExprCopperState::new) + .build() + ); + } + + /** + * Gets the string of the block type {@code material} relates to. + * i.e. stair, slab, door, trapdoor, etc. + * @param material The {@link Material} to get the block type from. + * @return The resulting string block type. + */ + public static String getBlockType(Material material) { + String type = material.name(); + for (String replace : STATE_REPLACEMENTS) + type = type.replaceAll(replace, ""); + if (type.equals("COPPER_BLOCK")) { + type = "COPPER"; + } else if (type.equals("WAXED_COPPER_BLOCK")) { + type = "WAXED_COPPER"; + } + return type; + } + + /** + * Gets the {@link CopperState} or 'WeatheringCopperState' a {@link Material} belongs to. + * @param material The {@link Material} to check. + * @return The resulting {@link CopperState} or 'WeatheringCopperState' if found, otherwise {@code null}. + */ + public static @Nullable Enum getMaterialCopperState(Material material) { + if (!MaterialTags.COPPER_BLOCKS.isTagged(material)) + return null; + if (MaterialTags.EXPOSED_COPPER_BLOCKS.isTagged(material)) { + return CopperState.get(CopperState.EXPOSED); + } else if (MaterialTags.WEATHERED_COPPER_BLOCKS.isTagged(material)) { + return CopperState.get(CopperState.WEATHERED); + } else if (MaterialTags.OXIDIZED_COPPER_BLOCKS.isTagged(material)) { + return CopperState.get(CopperState.OXIDIZED); + } + return CopperState.get(CopperState.UNAFFECTED); + } + + @Override + public @Nullable Object convert(Object object) { + if (COPPER_GOLEM_EXISTS && object instanceof CopperGolem golem) { + return golem.getWeatheringState(); + } else if (object instanceof Block block) { + return getMaterialCopperState(block.getType()); + } + return null; + } + + @Override + public Class @Nullable [] acceptChange(ChangeMode mode) { + if (mode == ChangeMode.SET || mode == ChangeMode.RESET) + return CollectionUtils.array(CopperState.getStateClass()); + return null; + } + + @Override + public void change(Event event, Object @Nullable [] delta, ChangeMode mode) { + Enum state = CopperState.get(CopperState.UNAFFECTED); + if (delta != null) + state = (Enum) delta[0]; + + for (Object object : getExpr().getArray(event)) { + if (COPPER_GOLEM_EXISTS && object instanceof CopperGolem golem) { + golem.setWeatheringState((WeatheringCopperState) state); + } else if (object instanceof Block block) { + Material material = getConvertedCopperMaterial(block.getType(), state); + if (material != null) { + if (COPPER_CHEST_EXISTS && block.getState() instanceof TileStateInventoryHolder inventoryHolder) { + Inventory inventory = inventoryHolder.getInventory(); + block.setType(material); + TileStateInventoryHolder newHolder = (TileStateInventoryHolder) block.getState(); + newHolder.getInventory().setStorageContents(inventory.getStorageContents()); + } else { + block.setType(material); + } + } + } + } + } + + /** + * Gets the {@link Material} that is the same block type as {@code material} and in the {@code state}. + * @param material The current {@link Material} to convert from. + * @param state The {@link CopperState} or 'WeatheringCopperState' to get the same block type as {@code material}. + * @return The resulting {@link Material} if found, otherwise {@code null}. + */ + public static @Nullable Material getConvertedCopperMaterial(Material material, Enum state) { + if (!MaterialTags.COPPER_BLOCKS.isTagged(material)) + return null; + String type = getBlockType(material); + return STATE_MATERIALS.getMaterial(type, state); + } + + @Override + public Class getReturnType() { + return CopperState.getStateClass(); + } + + @Override + protected String getPropertyName() { + return "weathering copper state"; + } + + /** + * Map for storing a block type, a {@link CopperState} or 'WeatheringCopperState' and the {@link Material} that is the block type and state. + */ + private static class CopperStateMaterialMap extends HashMap { + + public void putMaterial(String key, Enum state, Material material) { + computeIfAbsent(key, array -> new Material[CopperState.getValues().length])[state.ordinal()] = material; + } + + public @Nullable Material getMaterial(String key, Enum state) { + if (!containsKey(key)) + return null; + Material[] materials = get(key); + return materials[state.ordinal()]; + } + + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprItemOfEntity.java b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprItemOfEntity.java index 6c25dfea834..0d08ddf11b8 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprItemOfEntity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprItemOfEntity.java @@ -1,7 +1,7 @@ package org.skriptlang.skript.bukkit.misc.expressions; import ch.njol.skript.doc.Description; -import ch.njol.skript.doc.Examples; +import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; @@ -16,25 +16,32 @@ import org.bukkit.entity.ItemFrame; import org.bukkit.entity.ThrowableProjectile; import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Item of an Entity") -@Description({ - "An item associated with an entity. For dropped item entities, it gets the item that was dropped.", - "For item frames, the item inside the frame is returned.", - "For throwable projectiles (snowballs, enderpearls etc.) or item displays, it gets the displayed item.", - "Other entities do not have items associated with them." -}) -@Examples({ - "item of event-entity", - "", - "set the item inside of event-entity to a diamond sword named \"Example\"" -}) +@Description(""" + An item associated with an entity. For dropped item entities, it gets the item that was dropped. + For item frames, the item inside the frame is returned. + For throwable projectiles (snowballs, enderpearls etc.) or item displays, it gets the displayed item. + Other entities do not have items associated with them. + """) +@Example("item of event-entity") +@Example("set the item inside of event-entity to a diamond sword named \"Example\"") @Since("2.2-dev35, 2.2-dev36 (improved), 2.5.2 (throwable projectiles), 2.10 (item displays)") public class ExprItemOfEntity extends SimplePropertyExpression { - - static { - register(ExprItemOfEntity.class, Slot.class, "item [inside]", "entities"); + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EXPRESSION, + infoBuilder( + ExprItemOfEntity.class, + Slot.class, + "item [inside]", + "entities", + false + ).supplier(ExprItemOfEntity::new) + .build() + ); } @Override diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprQuaternionAxisAngle.java b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprQuaternionAxisAngle.java index 72e4a871322..07a1e9012cf 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprQuaternionAxisAngle.java +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprQuaternionAxisAngle.java @@ -1,16 +1,16 @@ package org.skriptlang.skript.bukkit.misc.expressions; -import ch.njol.skript.Skript; import ch.njol.skript.classes.Changer; import ch.njol.skript.classes.Changer.ChangeMode; import ch.njol.skript.doc.Description; -import ch.njol.skript.doc.Examples; +import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.simplification.SimplifiedLiteral; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import org.bukkit.event.Event; @@ -19,27 +19,36 @@ import org.joml.AxisAngle4f; import org.joml.Math; import org.joml.Quaternionf; -import ch.njol.skript.lang.simplification.SimplifiedLiteral; +import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Rotation Axis/Angle") -@Description({ - "Returns the axis or angle that a quaternion will rotate by/around.", - "All quaternions can be represented by a rotation of some amount around some axis, so this expression provides " + - "the ability to get that angle/axis." -}) -@Examples({ - "set {_quaternion} to axisAngle(45, vector(1, 2, 3))", - "send rotation axis of {_quaternion} # 1, 2, 3", - "send rotation angle of {_quaternion} # 45", - "set rotation angle of {_quaternion} to 135", - "set rotation axis of {_quaternion} to vector(0, 1, 0)" -}) +@Description(""" + Returns the axis or angle that a quaternion will rotate by/around. + All quaternions can be represented by a rotation of some amount around some axis, so this expression provides\ + the ability to get that angle/axis. + """) +@Example(""" + set {_quaternion} to axisAngle(45, vector(1, 2, 3)) + send rotation axis of {_quaternion} # 1, 2, 3 + send rotation angle of {_quaternion} # 45 + """) +@Example("set rotation angle of {_quaternion} to 135") +@Example("set rotation axis of {_quaternion} to vector(0, 1, 0)") @Since("2.10") public class ExprQuaternionAxisAngle extends SimplePropertyExpression { - static { - if (Skript.classExists("org.joml.Quaternionf")) - register(ExprQuaternionAxisAngle.class, Object.class, "rotation (angle|:axis)", "quaternions"); + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EXPRESSION, + infoBuilder( + ExprQuaternionAxisAngle.class, + Object.class, + "rotation (angle|:axis)", + "quaternions", + false + ).supplier(ExprQuaternionAxisAngle::new) + .build() + ); } private boolean isAxis; diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprRotate.java b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprRotate.java index f56d2c7941c..a4ef20f3036 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprRotate.java +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprRotate.java @@ -1,14 +1,13 @@ package org.skriptlang.skript.bukkit.misc.expressions; -import ch.njol.skript.Skript; import ch.njol.skript.doc.Description; -import ch.njol.skript.doc.Examples; +import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.ExpressionType; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.simplification.SimplifiedLiteral; import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.util.Kleenean; import org.bukkit.event.Event; @@ -21,37 +20,43 @@ import org.skriptlang.skript.bukkit.misc.rotation.NonMutatingVectorRotator; import org.skriptlang.skript.bukkit.misc.rotation.Rotator; import org.skriptlang.skript.bukkit.misc.rotation.Rotator.Axis; -import ch.njol.skript.lang.simplification.SimplifiedLiteral; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.Locale; import java.util.Objects; @Name("Rotated Quaternion/Vector") -@Description({ - "Rotates a quaternion or vector around an axis a set amount of degrees, or around all 3 axes at once.", - "Vectors can only be rotated around the global X/Y/Z axes, or an arbitrary vector axis.", - "Quaternions are more flexible, allowing rotation around the global or local X/Y/Z axes, arbitrary vectors, or all 3 local axes at once.", - "Global axes are the ones in the Minecraft world. Local axes are relative to how the quaternion is already oriented.", - "", - "Note that rotating a quaternion around a vector results in a rotation around the local vector, so results may not be what you expect. " + - "For example, rotating around vector(1, 0, 0) is the same as rotating around the local X axis.", - "The same applies to rotations by all three axes at once. " + - "In addition, rotating around all three axes of a quaternion/display at once will rotate in ZYX order, meaning the Z rotation will be applied first and the X rotation last." -}) -@Examples({ - "set {_new} to {_quaternion} rotated around x axis by 10 degrees", - "set {_new} to {_vector} rotated around vector(1, 1, 1) by 45", - "set {_new} to {_quaternion} rotated by x 45, y 90, z 135" -}) +@Description(""" + Rotates a quaternion or vector around an axis a set amount of degrees, or around all 3 axes at once. + Vectors can only be rotated around the global X/Y/Z axes, or an arbitrary vector axis. + Quaternions are more flexible, allowing rotation around the global or local X/Y/Z axes, arbitrary vectors, or all 3 local axes at once. + Global axes are the ones in the Minecraft world. Local axes are relative to how the quaternion is already oriented. + + Note that rotating a quaternion around a vector results in a rotation around the local vector, so results may not be what you expect. + For example, rotating around vector(1, 0, 0) is the same as rotating around the local X axis. + The same applies to rotations by all three axes at once. + In addition, rotating around all three axes of a quaternion/display at once will rotate in ZYX order, meaning the Z rotation will be applied first and the X rotation last. + """) +@Example("set {_new} to {_quaternion} rotated around x axis by 10 degrees") +@Example("set {_new} to {_vector} rotated around vector(1, 1, 1) by 45") +@Example("set {_new} to {_quaternion} rotated by x 45, y 90, z 135") @Since("2.10") public class ExprRotate extends SimpleExpression { - static { - Skript.registerExpression(ExprRotate.class, Object.class, ExpressionType.SIMPLE, - "%quaternions/vectors% rotated around [the] [global] (:x|:y|:z)(-| )axis by %number%", - "%quaternions% rotated around [the|its|their] local (:x|:y|:z)(-| )ax(i|e)s by %number%", - "%quaternions/vectors% rotated around [the] %vector% by %number%", - "%quaternions% rotated by x %number%, y %number%(, [and]| and) z %number%"); + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EXPRESSION, + SyntaxInfo.Expression.builder(ExprRotate.class, Object.class) + .addPatterns( + "%quaternions/vectors% rotated around [the] [global] (:x|:y|:z)(-| )axis by %number%", + "%quaternions% rotated around [the|its|their] local (:x|:y|:z)(-| )ax(i|e)s by %number%", + "%quaternions/vectors% rotated around [the] %vector% by %number%", + "%quaternions% rotated by x %number%, y %number%(, [and]| and) z %number%" + ) + .supplier(ExprRotate::new) + .build() + ); } private Expression toRotate; diff --git a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprTextOf.java b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprTextOf.java index 462fb581c1e..e24776c66f0 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprTextOf.java +++ b/src/main/java/org/skriptlang/skript/bukkit/misc/expressions/ExprTextOf.java @@ -1,14 +1,8 @@ package org.skriptlang.skript.bukkit.misc.expressions; -import org.bukkit.entity.TextDisplay; -import org.bukkit.event.Event; -import org.jetbrains.annotations.Nullable; - -import ch.njol.skript.ServerPlatform; -import ch.njol.skript.Skript; import ch.njol.skript.classes.Changer.ChangeMode; import ch.njol.skript.doc.Description; -import ch.njol.skript.doc.Examples; +import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; @@ -17,31 +11,35 @@ import ch.njol.util.coll.CollectionUtils; import net.kyori.adventure.text.serializer.bungeecord.BungeeComponentSerializer; import net.md_5.bungee.api.chat.BaseComponent; +import org.bukkit.entity.TextDisplay; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxRegistry; import java.util.Arrays; @Name("Text Of") -@Description({ - "Returns or changes the text/string of displays.", - "Note that currently you can only use Skript chat codes when running Paper." -}) -@Examples("set text of the last spawned text display to \"example\"") +@Description(""" + Returns or changes the text/string of displays. + Note that currently you can only use Skript chat codes when running Paper. + """) +@Example("set text of the last spawned text display to \"example\"") @Since("2.10") public class ExprTextOf extends SimplePropertyExpression { - private static final boolean IS_RUNNING_PAPER = Skript.getServerPlatform() == ServerPlatform.BUKKIT_PAPER; - private static BungeeComponentSerializer serializer; + private static final BungeeComponentSerializer SERIALIZER = BungeeComponentSerializer.get(); - static { - String types = ""; - if (Skript.classExists("org.bukkit.entity.Display")) { - if (IS_RUNNING_PAPER) - serializer = BungeeComponentSerializer.get(); - types += "displays"; - } - // This is because this expression is setup to support future types. - // Remove this if non-versioning. - if (!types.isEmpty()) - register(ExprTextOf.class, String.class, "text[s]", types); + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EXPRESSION, + infoBuilder( + ExprTextOf.class, + String.class, + "text[s]", + "displays", + false + ).supplier(ExprTextOf::new) + .build() + ); } @Override @@ -65,9 +63,9 @@ public void change(Event event, Object @Nullable [] delta, ChangeMode mode) { for (Object object : getExpr().getArray(event)) { if (!(object instanceof TextDisplay textDisplay)) continue; - if (IS_RUNNING_PAPER && serializer != null && value != null) { + if (SERIALIZER != null && value != null) { BaseComponent[] components = BungeeConverter.convert(ChatMessages.parseToArray(value)); - textDisplay.text(serializer.deserialize(components)); + textDisplay.text(SERIALIZER.deserialize(components)); } else { textDisplay.setText(value); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/paperutil/CopperState.java b/src/main/java/org/skriptlang/skript/bukkit/paperutil/CopperState.java new file mode 100644 index 00000000000..d9eb2ff7564 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/paperutil/CopperState.java @@ -0,0 +1,60 @@ +package org.skriptlang.skript.bukkit.paperutil; + +import ch.njol.skript.Skript; +import org.jetbrains.annotations.ApiStatus.Internal; +import org.skriptlang.skript.bukkit.misc.expressions.ExprCopperState; + +import java.lang.reflect.Method; + +/** + * Temporary enum to mimic `WeatheringCopperState`, which represents copper states, used in elements such as for {@link ExprCopperState}. + * Can be removed when 1.21.9+ is the minimum supported version. + */ +@Internal +public enum CopperState { + + EXPOSED, OXIDIZED, UNAFFECTED, WEATHERED; + + private static final Class WEATHERING_CLASS; + private static final Enum[] WEATHERING_VALUES; + private static final Method WEATHERING_VALUE_METHOD; + + static { + WEATHERING_CLASS = Skript.getClass("io.papermc.paper.world.WeatheringCopperState"); + if (WEATHERING_CLASS != null) { + Method valuesMethod = Skript.getMethod(WEATHERING_CLASS, "values"); + WEATHERING_VALUES = Skript.invokeMethod(valuesMethod); + WEATHERING_VALUE_METHOD = Skript.getMethod(WEATHERING_CLASS, "valueOf", String.class); + } else { + WEATHERING_VALUES = null; + WEATHERING_VALUE_METHOD = null; + } + } + + /** + * @return {@link CopperState} class or 'WeatheringCopperState' if it exists. + */ + public static Class getStateClass() { + return WEATHERING_CLASS != null ? WEATHERING_CLASS : CopperState.class; + } + + /** + * @return The enum values for {@link CopperState} or 'WeatheringCopperState' if it exists. + */ + public static Enum[] getValues() { + if (WEATHERING_CLASS != null) + return WEATHERING_VALUES; + return CopperState.values(); + } + + /** + * @param state The {@link CopperState} enum value. + * @return {@code state} or the state in 'WeatheringCopperState' if it exists. + */ + public static Enum get(CopperState state) { + if (WEATHERING_CLASS != null) + return Skript.invokeMethod(WEATHERING_VALUE_METHOD, null, state.name()); + return state; + } + +} diff --git a/src/main/java/org/skriptlang/skript/util/ClassLoader.java b/src/main/java/org/skriptlang/skript/util/ClassLoader.java index d6f8ed44da4..cb48dcbcdfe 100644 --- a/src/main/java/org/skriptlang/skript/util/ClassLoader.java +++ b/src/main/java/org/skriptlang/skript/util/ClassLoader.java @@ -192,7 +192,7 @@ public void loadClasses(Class source, @Nullable JarFile jar) { if (this.forEachClass != null) { this.forEachClass.accept(clazz); } - } catch (ClassNotFoundException ex) { + } catch (ClassNotFoundException | NoClassDefFoundError ex) { throw new RuntimeException("Failed to load class: " + className, ex); } catch (ExceptionInInitializerError err) { throw new RuntimeException(className + " generated an exception while loading", err.getCause()); diff --git a/src/main/java/org/skriptlang/skript/util/ReflectUtils.java b/src/main/java/org/skriptlang/skript/util/ReflectUtils.java new file mode 100644 index 00000000000..501b2527bc3 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/util/ReflectUtils.java @@ -0,0 +1,252 @@ +package org.skriptlang.skript.util; + +import org.jetbrains.annotations.Nullable; + +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; + +/** + * Utility class for reflection. + */ +public final class ReflectUtils { + + public ReflectUtils() {} + + /** + * Cache for classes. + */ + private final Map> classes = new HashMap<>(); + + /** + * Cache for methods of classes. + */ + private final MethodMap methods = new MethodMap(); + + /** + * Cache for fields of classes. + */ + private final FieldMap fields = new FieldMap(); + + /** + * @param className The full package and class name. + * @return Whether the class exists. + */ + public boolean classExists(String className) { + return getClass(className) != null; + } + + /** + * @param className The full package and class name. + * @return The resulting {@link Class} if found, otherwise {@code null}. + */ + public @Nullable Class getClass(String className) { + if (classes.containsKey(className)) + return classes.get(className); + Class c = null; + try { + c = Class.forName(className); + } catch (ClassNotFoundException ignored) {} + classes.put(className, c); + return c; + } + + /** + * @param c The {@link Class} to check the method for. + * @param methodName The name of the method. + * @param params The {@link Class}es used as parameters for the desired method. + * @return Whether the method exists. + */ + public boolean methodExists(Class c, String methodName, Class @Nullable ... params) { + return methodExists(c, methodName, params, null); + } + + /** + * @param c The {@link Class} to check the method for. + * @param methodName The name of the method. + * @param params The {@link Class}es used as parameters for the desired method. + * @param returnTpe The return type of the desired method. + * @return Whether the method exists. + */ + public boolean methodExists(Class c, String methodName, Class @Nullable [] params, @Nullable Class returnTpe) { + return getMethod(c, methodName, params, returnTpe) != null; + } + + /** + * @param c The {@link Class} to get the method from. + * @param methodName The name of the method. + * @param params The {@link Class}es used as parameters for the desired method. + * @return The resulting {@link Method} if it exists, otherwise {@code null}. + */ + public @Nullable Method getMethod(Class c, String methodName, Class @Nullable ... params) { + return getMethod(c, methodName, params, null); + } + + /** + * @param c The {@link Class} to get the method from. + * @param methodName The name of the method. + * @param params The {@link Class}es used as parameters for the desired method. + * @param returnType The return type of the desired method. + * @return The resulting {@link Method} if it exists, otherwise {@code null}. + */ + public @Nullable Method getMethod(Class c, String methodName, Class @Nullable [] params, @Nullable Class returnType) { + MethodID methodID = new MethodID(c, methodName, params); + if (methods.contains(c, methodID)) { + Method method = methods.get(c, methodID); + if (method != null && returnType != null) { + Class methodType = method.getReturnType(); + if (!returnType.isAssignableFrom(methodType) && !methodType.isAssignableFrom(returnType)) + return null; + } + return methods.get(c, methodID); + } + Method method = null; + try { + method = c.getDeclaredMethod(methodName, params); + } catch (NoSuchMethodException ignored) {} + + methods.put(c, methodID, method); + if (method != null && returnType != null) { + Class methodType = method.getReturnType(); + if (!returnType.isAssignableFrom(methodType) && !methodType.isAssignableFrom(returnType)) + return null; + } + return method; + } + + /** + * @param c The {@link Class} to check the field for. + * @param fieldName The name of the field. + * @return Whether the field exists. + */ + public boolean fieldExists(Class c, String fieldName) { + return getField(c, fieldName) != null; + } + + /** + * @param c The {@link Class} to get the field from. + * @param fieldName The name of the field. + * @return The resulting {@link Field} if it exists, otherwise {@code null}. + */ + public @Nullable Field getField(Class c, String fieldName) { + if (fields.contains(c, fieldName)) + return fields.get(c, fieldName); + Field field = null; + try { + field = c.getDeclaredField(fieldName); + } catch (NoSuchFieldException ignored) {} + + fields.put(c, fieldName, field); + return field; + } + + /** + * Invoke a static {@link Method}. + * @param method The {@link Method} to invoke. + * @return The result of the invocation if successful, otherwise {@code null}. + * @param The expected return type from the invocation. + */ + public @Nullable Type invokeMethod(Method method) { + return invokeMethod(method, null); + } + + /** + * Invoke a {@link Method}. + * @param method The {@link Method} to invoke. + * @param holder The holder object to invoke for. + * @param params The parameters to pass into the invocation. + * @return The result of the invocation if successful, otherwise {@code null}. + * @param The expected return type from the invocation. + */ + public @Nullable Type invokeMethod(Method method, @Nullable Object holder, Object @Nullable ... params) { + method.setAccessible(true); + try { + //noinspection unchecked + return (Type) method.invoke(holder, params); + } catch (IllegalAccessException | InvocationTargetException ignored) {} + return null; + } + + /** + * Gets the values of a static {@link Field}. + * @param field The {@link Field} to get from. + * @return The value of the {@link Field}. + * @param The expected return type. + */ + public @Nullable Type getFieldValue(Field field) { + return getFieldValue(field, null); + } + + /** + * Gets the values of a {@link Field}. + * @param field The {@link Field} to get from. + * @param holder The holder object to get the field for. + * @return The value of the {@link Field}. + * @param The expected return type. + */ + public @Nullable Type getFieldValue(Field field, @Nullable Object holder) { + field.setAccessible(true); + try { + //noinspection unchecked + return (Type) field.get(holder); + } catch (IllegalAccessException ignored) {} + return null; + } + + /** + * Record for caching data for a method. + * @param c The {@link Class} the method belongs to. + * @param methodName The name of the method. + * @param params The types of parameters for the method. + */ + private record MethodID(Class c, String methodName, Class @Nullable [] params) {} + + /** + * Custom map for correlating a {@link Class} to a {@link Method}. + */ + private static class MethodMap extends HashMap, Map> { + + public boolean contains(Class c, MethodID methodID) { + if (!containsKey(c)) + return false; + return get(c).containsKey(methodID); + } + + public void put(Class c, MethodID methodID, Method method) { + computeIfAbsent(c, map -> new HashMap<>()).put(methodID, method); + } + + public @Nullable Method get(Class c, MethodID methodID) { + if (!contains(c, methodID)) + return null; + return get(c).get(methodID); + } + + } + + /** + * Custom map for correlating a {@link Class} to a {@link Field}. + */ + private static class FieldMap extends HashMap, Map> { + + public boolean contains(Class c, String fieldName) { + if (!containsKey(c)) + return false; + return get(c).containsKey(fieldName); + } + + public void put(Class c, String fieldName, Field field) { + computeIfAbsent(c, map -> new HashMap<>()).put(fieldName, field); + } + + public @Nullable Field get(Class c, String fieldName) { + if (!contains(c, fieldName)) + return null; + return get(c).get(fieldName); + } + + } + +} diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index e9853b2c01a..9e5d938754e 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -640,6 +640,14 @@ entities: 0: [%-cowvariant%] cow[plural:s] 1: baby:[%-cowvariant%] cal(f|plural:ves) + # CopperGolemData + copper golem: + name: copper golem¦s + patterns: + 0: [%-weatheringcopperstate%] copper golem[plural:s] + 1: waxed [%-weatheringcopperstate%] copper golem[plural:s] + 2: unwaxed [%-weatheringcopperstate%] copper golem[plural:s] + # CreeperData creeper: name: creeper¦s @@ -1590,9 +1598,6 @@ entities: 1: baby:[happy] ghastling[plural:s] # 1.21.9 Entities - copper golem: - name: copper golem¦s - pattern: copper golem[plural:s] mannequin: name: mannequin¦s pattern: mannequin[plural:s] @@ -3013,6 +3018,20 @@ damage types: wither: wither wither_skull: wither skull +# -- Weathering Copper States -- +weathering copper states: + exposed: exposed, exposed state, exposed copper, exposed copper state + oxidized: oxidized, oxidized state, oxidized copper, oxidized copper state + unaffected: normal state, normal copper state, unaffected, unaffected state, unaffected copper, unaffected copper state + weathered: weathered, weathered state, weathered copper, weathered copper state + +# -- Copper Golem Poses -- +copper golem poses: + running: running, running pose, running statue pose, statue running pose + sitting: sitting, sitting pose, sitting statue pose, statue sitting pose + standing: standing, standing pose, standing statue pose, statue standing pose + star: star, star pose, star statue pose, statue star pose + # -- Boolean -- boolean: true: @@ -3133,6 +3152,8 @@ types: frogvariant: frog variant¦s @a itemcomponent: item component¦s @an equippablecomponent: equippable component¦s @an + weatheringcopperstate: weathering copper state¦s @a + coppergolempose: copper golem pose¦s @a # Skript weathertype: weather type¦s @a diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index b1e02b2826e..39adec02f3e 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -233,6 +233,50 @@ test "chicken data": testData(temperate chick) testData(cold chick) +test "copper golem data" when running minecraft "1.21.9": + setSuperTypes(copper golem) + testData(copper golem) + testData(waxed copper golem) + testData(unwaxed copper golem) + testData(unaffected copper golem) + testData(exposed copper golem) + testData(weathered copper golem) + testData(oxidized copper golem) + + setSuperTypes(waxed copper golem) + testData(waxed copper golem) + testData(waxed unaffected copper golem) + testData(waxed exposed copper golem) + testData(waxed weathered copper golem) + testData(waxed oxidized copper golem) + + setSuperTypes(unwaxed copper golem) + testData(unwaxed copper golem) + testData(unwaxed unaffected copper golem) + testData(unwaxed exposed copper golem) + testData(unwaxed weathered copper golem) + testData(unwaxed oxidized copper golem) + + setSuperTypes(unaffected copper golem) + testData(unaffected copper golem) + testData(waxed unaffected copper golem) + testData(unwaxed unaffected copper golem) + + setSuperTypes(exposed copper golem) + testData(exposed copper golem) + testData(waxed exposed copper golem) + testData(unwaxed exposed copper golem) + + setSuperTypes(weathered copper golem) + testData(weathered copper golem) + testData(waxed weathered copper golem) + testData(unwaxed weathered copper golem) + + setSuperTypes(oxidized copper golem) + testData(oxidized copper golem) + testData(waxed oxidized copper golem) + testData(unwaxed oxidized copper golem) + test "cow data": setSuperTypes(cow) testData(cow) diff --git a/src/test/skript/tests/syntaxes/effects/EffWax.sk b/src/test/skript/tests/syntaxes/effects/EffWax.sk new file mode 100644 index 00000000000..5de54384e3f --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffWax.sk @@ -0,0 +1,39 @@ +test "wax copper golem" when running minecraft "1.21.9": + spawn a copper golem at test-location: + set {_entity} to entity + + assert {_entity} is not waxed with "Copper golem should not be waxed after spawn" + wax {_entity} + assert {_entity} is waxed with "Copper golem should be waxed" + unwax {_entity} + assert {_entity} is not waxed with "Copper golem should be unwaxed" + + clear entity within {_entity} + +test "wax copper blocks": + set {_old} to the block data of test-block + + set {_waxTag} to paper tag "waxed_copper_blocks" + set {_unwaxTag} to paper tag "unwaxed_copper_blocks" + set {_blocks::*} to the tag contents of {_waxTag} + loop {_blocks::*}: + set test-block to loop-value + unwax test-block + assert test-block is tagged with {_unwaxTag} with "%loop-value% should be unwaxed, but was %type of test-block%" + wax test-block + assert test-block is tagged with {_waxTag} with "%loop-value% should be waxed, but was %type of test-block%" + + set the block data of test-block to {_old} + +test "wax copper chest" when running minecraft "1.21.9": + set {_old} to the block data of test-block + + set test-block to a copper chest + set slot 1 of inventory of test-block to a diamond + assert slot 1 of inventory of test-block is a diamond with "Diamond was not initially set into inventory" + wax test-block + assert slot 1 of inventory of test-block is a diamond with "Inventory did not retain items when being waxed" + unwax test-block + assert slot 1 of inventory of test-block is a diamond with "Inventory did not retain items when being unwaxed" + + set the block data of test-block to {_old} diff --git a/src/test/skript/tests/syntaxes/expressions/ExprCopperGolemOxidationTime.sk b/src/test/skript/tests/syntaxes/expressions/ExprCopperGolemOxidationTime.sk new file mode 100644 index 00000000000..0a5d225f9a1 --- /dev/null +++ b/src/test/skript/tests/syntaxes/expressions/ExprCopperGolemOxidationTime.sk @@ -0,0 +1,10 @@ +test "copper golem oxidation" when running minecraft "1.21.9": + spawn a copper golem at test-location: + set {_entity} to entity + + set the time until oxidation of {_entity} to 10 seconds + assert the time until oxidation of {_entity} is 10 seconds with "Copper golem oxidation time did not change" + reset the time until oxidation of {_entity} + assert the time until oxidation of {_entity} is not set with "Copper golem oxidation reset takes a tick to be scheduled again" + + clear the entity within {_entity} diff --git a/src/test/skript/tests/syntaxes/expressions/ExprCopperGolemPose.sk b/src/test/skript/tests/syntaxes/expressions/ExprCopperGolemPose.sk new file mode 100644 index 00000000000..3b3377d2e14 --- /dev/null +++ b/src/test/skript/tests/syntaxes/expressions/ExprCopperGolemPose.sk @@ -0,0 +1,9 @@ +test "copper golem pose" when running minecraft "1.21.9": + set {_old} to the block data of test-block + + set test-block to a copper golem statue + loop all copper golem poses: + set the copper golem pose of test-block to loop-value + assert the copper golem pose of test-block is loop-value with "Copper golem pose should be %loop-value%" + + set the block data of test-block to {_old} diff --git a/src/test/skript/tests/syntaxes/expressions/ExprCopperState.sk b/src/test/skript/tests/syntaxes/expressions/ExprCopperState.sk new file mode 100644 index 00000000000..56d269dfa97 --- /dev/null +++ b/src/test/skript/tests/syntaxes/expressions/ExprCopperState.sk @@ -0,0 +1,51 @@ +test "copper state of copper golem" when running minecraft "1.21.9": + spawn a copper golem at test-location: + set {_entity} to entity + + loop all weathering copper states: + set the copper state of {_entity} to loop-value + assert the copper state of {_entity} is loop-value with "Copper state of copper golem did not change" + + clear entity within {_entity} + +test "copper state of copper blocks": + set {_old} to the block data of test-block + + set {_exposedTag} to paper tag "exposed_copper_blocks" + set {_weatheredTag} to paper tag "weathered_copper_blocks" + set {_oxidizedTag} to paper tag "oxidized_copper_blocks" + set {_blocks::*} to the tag contents of paper tag "copper_blocks" + filter {_blocks::*} to match: + input is not tagged with {_exposedTag} + input is not tagged with {_weatheredTag} + input is not tagged with {_oxidizedTag} + + parse if running minecraft "1.21.9": + filter {_blocks::*} to match: + input is not a copper torch + input is not a copper wall torch + + loop {_blocks::*}: + set test-block to loop-value + + assert the copper state of test-block is normal copper state with "Copper block should be normal copper state, but was %type of test-block%" + set the copper state of test-block to exposed copper state + assert the copper state of test-block is exposed copper state with "Copper block should be exposed copper state, but was %type of test-block%" + set the copper state of test-block to weathered copper state + assert the copper state of test-block is weathered copper state with "Copper block should be weathered copper state, but was %type of test-block%" + set the copper state of test-block to oxidized copper state + assert the copper state of test-block is oxidized copper state with "Copper block should be oxidized copper state, but was %type of test-block%" + + set the block data of test-block to {_old} + +test "copper state of chests" when running minecraft "1.21.9": + set {_old} to the block data of test-block + + set test-block to a copper chest + set slot 1 of inventory of test-block to a diamond + assert slot 1 of inventory of test-block is a diamond with "Diamond was not initially set into inventory" + loop all copper states: + set copper state of test-block to loop-value + assert slot 1 of inventory of test-block is a diamond with "Inventory did not retain items when being changed to %loop-value%" + + set the block data of test-block to {_old} diff --git a/src/test/skript/tests/syntaxes/sections/EffSecSpawn.sk b/src/test/skript/tests/syntaxes/sections/EffSecSpawn.sk index 265bf06bed7..a242afc1d89 100644 --- a/src/test/skript/tests/syntaxes/sections/EffSecSpawn.sk +++ b/src/test/skript/tests/syntaxes/sections/EffSecSpawn.sk @@ -268,3 +268,47 @@ test "spawn baby cow by variant" when running minecraft "1.21.5": assert size of all calves is 5 with "Only temperate calves should have been deleted" delete all warm calves assert size of all warm calves is 0 with "Warm calves were not deleted" + +test "spawn copper golems" when running minecraft "1.21.9": + clear all copper golems + spawn 2 copper golems at test-location + spawn 2 waxed copper golems at test-location + spawn 2 unwaxed copper golems at test-location + + spawn 2 unaffected copper golems at test-location + spawn 2 waxed unaffected copper golems at test-location + spawn 2 unwaxed unaffected copper golems at test-location + + spawn 2 exposed copper golems at test-location + spawn 2 waxed exposed copper golems at test-location + spawn 2 unwaxed exposed copper golems at test-location + + spawn 2 weathered copper golems at test-location + spawn 2 waxed weathered copper golems at test-location + spawn 2 unwaxed weathered copper golems at test-location + + spawn 2 oxidized copper golems at test-location + spawn 2 waxed oxidized copper golems at test-location + spawn 2 unwaxed oxidized copper golems at test-location + + assert size of all copper golems is 30 with "Size of all copper golems is not 30" + assert size of all waxed copper golems is 10 with "Size of all waxed copper golems is not 10" + assert size of all unwaxed copper golems is 20 with "Size of all unwaxed copper golems is not 20" + + assert size of all unaffected copper golems is 12 with "Size of all unaffected copper golems is not 12" + assert size of all waxed unaffected copper golems is 4 with "Size of all waxed unaffected copper golems is not 4" + assert size of all unwaxed unaffected copper golems is 8 with "Size of all unwaxed unaffected copper golems is not 8" + + assert size of all exposed copper golems is 6 with "Size of all exposed copper golems is not 6" + assert size of all waxed exposed copper golems is 2 with "Size of all waxed exposed copper golems is not 2" + assert size of all unwaxed exposed copper golems is 4 with "Size of all unwaxed exposed copper golems is not 4" + + assert size of all weathered copper golems is 6 with "Size of all weathered copper golems is not 6" + assert size of all waxed weathered copper golems is 2 with "Size of all waxed weathered copper golems is not 2" + assert size of all unwaxed weathered copper golems is 4 with "Size of all unwaxed weathered copper golems is not 4" + + assert size of all oxidized copper golems is 6 with "Size of all oxidized copper golems is not 6" + assert size of all waxed oxidized copper golems is 2 with "Size of all waxed oxidized copper golems is not 2" + assert size of all unwaxed oxidized copper golems is 4 with "Size of all unwaxed oxidized copper golems is not 4" + + clear all copper golems