From 189cf107911a6e2260cd94327aa4c02172f16ae5 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:06:59 -0700 Subject: [PATCH 01/43] Create AI effect and mark AI expression as deprecated --- .../ch/njol/skript/expressions/ExprAI.java | 11 ++++ .../bukkit/entity/elements/effects/EffAI.java | 65 +++++++++++++++++++ 2 files changed, 76 insertions(+) create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java diff --git a/src/main/java/ch/njol/skript/expressions/ExprAI.java b/src/main/java/ch/njol/skript/expressions/ExprAI.java index 33faceabbcb..23966496359 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprAI.java +++ b/src/main/java/ch/njol/skript/expressions/ExprAI.java @@ -1,5 +1,9 @@ package ch.njol.skript.expressions; +import ch.njol.skript.Skript; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.util.Kleenean; import org.bukkit.entity.LivingEntity; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; @@ -16,11 +20,18 @@ @Description("Returns whether an entity has AI.") @Example("set artificial intelligence of target entity to false") @Since("2.5") +@Deprecated(since = "INSERT VERSION", forRemoval = true) public class ExprAI extends SimplePropertyExpression { static { register(ExprAI.class, Boolean.class, "(ai|artificial intelligence)", "livingentities"); } + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + Skript.warning("This expression is deprecated. Consider using the AI effect instead."); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } @Override @Nullable diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java new file mode 100644 index 00000000000..a7fd2356409 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -0,0 +1,65 @@ +package org.skriptlang.skript.bukkit.entity.elements.effects; + +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SyntaxStringBuilder; +import ch.njol.util.Kleenean; +import org.bukkit.entity.LivingEntity; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Entity AI") +@Description("Change whether an entity has AI.") +@Example("enable artificial intelligence of target entity") +@Example("disable ai of last spawned entity") +@Since("INSERT VERSION") +public class EffAI extends Effect { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EFFECT, + SyntaxInfo.builder(EffAI.class) + .addPatterns( + "(enable|:disable) (ai|artificial intelligence) of %livingentities%", + "(enable|:disable) %livingentities%'s (ai|artificial intelligence)" + ) + .supplier(EffAI::new) + .build() + ); + } + + private Expression entities; + private boolean negated; + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + //noinspection unchecked + entities = (Expression) expressions[0]; + negated = parseResult.hasTag("disable"); + return true; + } + + @Override + protected void execute(Event event) { + for (LivingEntity entity : entities.getArray(event)) { + entity.setAI(!negated); + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return new SyntaxStringBuilder(event, debug) + .appendIf(!negated, "enable") + .appendIf(negated, "disable") + .append("ai of", entities) + .toString(); + } + +} From c6c2fda3ea9c94b2b7a11944bc85813a5b904d83 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:07:31 -0700 Subject: [PATCH 02/43] Create glowing effect and condition. Mark glow expression as deprecated --- .../njol/skript/expressions/ExprGlowing.java | 11 ++++ .../elements/conditions/CondIsGlowing.java | 45 +++++++++++++ .../entity/elements/effects/EffGlowing.java | 65 +++++++++++++++++++ 3 files changed, 121 insertions(+) create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java diff --git a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java index 31770fcc7e7..95f2ca7fba7 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java @@ -1,5 +1,9 @@ package ch.njol.skript.expressions; +import ch.njol.skript.Skript; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.util.Kleenean; import org.bukkit.entity.Entity; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; @@ -15,11 +19,18 @@ @Description("Indicates if targeted entity is glowing (new 1.9 effect) or not. Glowing entities can be seen through walls.") @Example("set glowing of player to true") @Since("2.2-dev18") +@Deprecated(since = "INSERT VERSION", forRemoval = true) public class ExprGlowing extends SimplePropertyExpression { static { register(ExprGlowing.class, Boolean.class, "glowing", "entities"); } + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + Skript.warning("This expression is deprecated. Consider using the glowing effect instead."); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } @Override public Boolean convert(final Entity e) { diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java new file mode 100644 index 00000000000..1f8a3e3149c --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java @@ -0,0 +1,45 @@ +package org.skriptlang.skript.bukkit.entity.elements.conditions; + +import ch.njol.skript.conditions.base.PropertyCondition; +import ch.njol.skript.doc.*; +import org.bukkit.entity.Entity; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Is Glowing") +@Description("Checks whether or not a living entity is glowing.") +@Example(""" + command /glow: + trigger: + if player is glowing: + make player stop glowing + else: + make player glow + """) +@Since("INSERT VERSION") +public class CondIsGlowing extends PropertyCondition { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.CONDITION, + infoBuilder( + CondIsGlowing.class, + PropertyType.BE, + "glowing", + "entities" + ) + .supplier(CondIsGlowing::new) + .build() + ); + } + + @Override + public boolean check(Entity entity) { + return entity.isGlowing(); + } + + @Override + protected String getPropertyName() { + return "glowing"; + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java new file mode 100644 index 00000000000..29cf2631ee4 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -0,0 +1,65 @@ +package org.skriptlang.skript.bukkit.entity.elements.effects; + +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SyntaxStringBuilder; +import ch.njol.util.Kleenean; +import org.bukkit.entity.LivingEntity; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Entity Glow") +@Description("Change whether an entity is glowing.") +@Example("make target entity glow") +@Example("make player stop glowing") +@Since("INSERT VERSION") +public class EffGlowing extends Effect { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EFFECT, + SyntaxInfo.builder(EffGlowing.class) + .addPatterns( + "make %entities% [negate:not] glow", + "make %entities% (negate:stop|start) glowing" + ) + .supplier(EffGlowing::new) + .build() + ); + } + + private Expression entities; + private boolean negated; + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + //noinspection unchecked + entities = (Expression) expressions[0]; + negated = parseResult.hasTag("negate"); + return true; + } + + @Override + protected void execute(Event event) { + for (LivingEntity entity : entities.getArray(event)) { + entity.setGlowing(!negated); + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return new SyntaxStringBuilder(event, debug) + .append("make", entities) + .appendIf(negated, "not") + .append("glow") + .toString(); + } + +} From 954e54f79267bacdacf6d2a6e2bfd7bd4950355f Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:07:57 -0700 Subject: [PATCH 03/43] Create gravity effect. Mark gravity expression as deprecated --- .../njol/skript/expressions/ExprGravity.java | 10 +++ .../entity/elements/effects/EffGravity.java | 65 +++++++++++++++++++ 2 files changed, 75 insertions(+) create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java diff --git a/src/main/java/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index e71c4cbb408..1052b0154dd 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -1,5 +1,8 @@ package ch.njol.skript.expressions; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.util.Kleenean; import org.bukkit.entity.Entity; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; @@ -16,11 +19,18 @@ @Description("If entity is affected by gravity or not, i.e. if it has Minecraft 1.10+ NoGravity flag.") @Example("set gravity of player off") @Since("2.2-dev21") +@Deprecated(since = "INSERT VERSION", forRemoval = true) public class ExprGravity extends SimplePropertyExpression { static { register(ExprGravity.class, Boolean.class, "gravity", "entities"); } + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + Skript.warning("This expression is deprecated. Consider using the gravity effect instead."); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } @Override public Boolean convert(final Entity e) { diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java new file mode 100644 index 00000000000..8d96b7eee97 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -0,0 +1,65 @@ +package org.skriptlang.skript.bukkit.entity.elements.effects; + +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SyntaxStringBuilder; +import ch.njol.util.Kleenean; +import org.bukkit.entity.LivingEntity; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Entity Gravity") +@Description("Change whether an entity is affected by gravity.") +@Example("enable gravity of target entity") +@Example("disable last spawned entity's gravity") +@Since("INSERT VERSION") +public class EffGravity extends Effect { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EFFECT, + SyntaxInfo.builder(EffGravity.class) + .addPatterns( + "(enable|:disable) (gravity) of %entities%", + "(enable|:disable) %entities%'s (gravity)" + ) + .supplier(EffGravity::new) + .build() + ); + } + + private Expression entities; + private boolean negated; + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + //noinspection unchecked + entities = (Expression) expressions[0]; + negated = parseResult.hasTag("disable"); + return true; + } + + @Override + protected void execute(Event event) { + for (LivingEntity entity : entities.getArray(event)) { + entity.setGravity(!negated); + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return new SyntaxStringBuilder(event, debug) + .appendIf(!negated, "enable") + .appendIf(negated, "disable") + .append("gravity of", entities) + .toString(); + } + +} From bb3502fc11f96fc3170ff068ec7e2b0d528dd6d6 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:08:29 -0700 Subject: [PATCH 04/43] Create projectile critical state effect and condition. Mark projectile critical state expression as deprecated --- .../ExprProjectileCriticalState.java | 10 +++ .../conditions/CondProjectileIsCritical.java | 58 +++++++++++++++ .../effects/EffProjectileCriticalState.java | 70 +++++++++++++++++++ 3 files changed, 138 insertions(+) create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java diff --git a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java index 806e36fb2e8..28cb8d208cb 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java +++ b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java @@ -1,5 +1,8 @@ package ch.njol.skript.expressions; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.util.Kleenean; import org.bukkit.entity.AbstractArrow; import org.bukkit.entity.Arrow; import org.bukkit.entity.Projectile; @@ -23,6 +26,7 @@ set projectile critical mode of event-projectile to true """) @Since("2.5.1") +@Deprecated(since = "INSERT VERSION", forRemoval = true) public class ExprProjectileCriticalState extends SimplePropertyExpression { private static final boolean abstractArrowExists = Skript.classExists("org.bukkit.entity.AbstractArrow"); @@ -30,6 +34,12 @@ public class ExprProjectileCriticalState extends SimplePropertyExpression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + Skript.warning("This expression is deprecated. Consider using the projectile critical state effect instead."); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } @Nullable @Override diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java new file mode 100644 index 00000000000..e0e566e8e76 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -0,0 +1,58 @@ +package org.skriptlang.skript.bukkit.entity.elements.conditions; + +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.Since; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.util.Kleenean; +import org.bukkit.entity.AbstractArrow; +import org.bukkit.entity.Projectile; +import org.skriptlang.skript.log.runtime.RuntimeErrorProducer; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Projectile Is Critical") +@Description("Checks whether or not a projectile is in critical state. As of now this only applies to arrows and tridents.") +@Example(""" + on shoot: + if event-projectile is not in projectile critical state: + enable projectile critical state of event-projectile + """) +@Since("INSERT VERSION") +public class CondProjectileIsCritical extends PropertyCondition implements RuntimeErrorProducer { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.CONDITION, + SyntaxInfo.builder(CondProjectileIsCritical.class) + .addPatterns( + "%projectile% is in (projectile|arrow) critical (state|mode)", + "%projectile% (is not|isn't) in (projectile|arrow) critical (state|mode)") + .supplier(CondProjectileIsCritical::new) + .build() + ); + } + + @Override + public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + setNegated(matchedPattern == 1); + return super.init(exprs, matchedPattern, isDelayed, parseResult); + } + + @Override + public boolean check(Projectile projectile) { + if (projectile instanceof AbstractArrow abstractArrow) { + return abstractArrow.isCritical(); + } + warning("This projectile is not supported. This only applies to arrows and tridents."); + return false; + } + + protected String getPropertyName() { + return "projectile critical state"; + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java new file mode 100644 index 00000000000..e6179657c11 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -0,0 +1,70 @@ +package org.skriptlang.skript.bukkit.entity.elements.effects; + +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.lang.Effect; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SyntaxStringBuilder; +import ch.njol.util.Kleenean; +import org.bukkit.entity.AbstractArrow; +import org.bukkit.entity.Projectile; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Projectile Critical State") +@Description("Change whether a projectile is in its critical state. As of now this only applies to arrows and tridents.") +@Example(""" + on shoot: + enable projectile critical state of event-projectile + """) +@Since("INSERT VERSION") +public class EffProjectileCriticalState extends Effect { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.EFFECT, + SyntaxInfo.builder(EffProjectileCriticalState.class) + .addPatterns( + "(enable|:disable) (projectile|arrow) critical (state|mode) of %projectiles%", + "(enable|:disable) %projectiles%'s (projectile|arrow) critical (state|mode)" + ) + .supplier(EffProjectileCriticalState::new) + .build() + ); + } + + private Expression projectiles; + private boolean negated; + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + //noinspection unchecked + projectiles = (Expression) expressions[0]; + negated = parseResult.hasTag("disable"); + return true; + } + + @Override + protected void execute(Event event) { + for (Projectile projectile : projectiles.getArray(event)) { + if (projectile instanceof AbstractArrow abstractArrow) { + abstractArrow.setCritical(!negated); + } + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return new SyntaxStringBuilder(event, debug) + .appendIf(!negated, "enable") + .appendIf(negated, "disable") + .append("projectile critical state", projectiles) + .toString(); + } + +} From 6a360c119e4f33ff96e97a9787a81b66abdbb198 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:08:41 -0700 Subject: [PATCH 05/43] Register new syntax --- .../skript/bukkit/entity/EntityModule.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java index 5e07c604ed6..29e5f1dab6f 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java @@ -7,6 +7,12 @@ import org.skriptlang.skript.addon.HierarchicalAddonModule; import org.skriptlang.skript.addon.SkriptAddon; import org.skriptlang.skript.bukkit.entity.displays.DisplayModule; +import org.skriptlang.skript.bukkit.entity.elements.conditions.CondIsGlowing; +import org.skriptlang.skript.bukkit.entity.elements.conditions.CondProjectileIsCritical; +import org.skriptlang.skript.bukkit.entity.elements.effects.EffAI; +import org.skriptlang.skript.bukkit.entity.elements.effects.EffGlowing; +import org.skriptlang.skript.bukkit.entity.elements.effects.EffGravity; +import org.skriptlang.skript.bukkit.entity.elements.effects.EffProjectileCriticalState; import org.skriptlang.skript.bukkit.entity.interactions.InteractionModule; import org.skriptlang.skript.bukkit.entity.elements.expressions.ExprDeathMessage; import org.skriptlang.skript.bukkit.entity.entitydata.NautilusData; @@ -38,6 +44,14 @@ protected void loadSelf(SkriptAddon addon) { } register(addon, + CondIsGlowing::register, + CondProjectileIsCritical::register, + + EffAI::register, + EffGlowing::register, + EffGravity::register, + EffProjectileCriticalState::register, + ExprDeathMessage::register ); } From d9b262ce5276ec471e2cefc17c92e7856f07dd58 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:27:58 -0700 Subject: [PATCH 06/43] Add runtime warning when effect is used on a non-compatible projectile --- .../entity/elements/effects/EffProjectileCriticalState.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index e6179657c11..8f47fbe11be 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -13,6 +13,7 @@ import org.bukkit.entity.Projectile; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.log.runtime.RuntimeErrorProducer; import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; @@ -23,7 +24,7 @@ enable projectile critical state of event-projectile """) @Since("INSERT VERSION") -public class EffProjectileCriticalState extends Effect { +public class EffProjectileCriticalState extends Effect implements RuntimeErrorProducer { public static void register(SyntaxRegistry registry) { registry.register( @@ -54,6 +55,8 @@ protected void execute(Event event) { for (Projectile projectile : projectiles.getArray(event)) { if (projectile instanceof AbstractArrow abstractArrow) { abstractArrow.setCritical(!negated); + } else { + warning("This projectile is not supported. This only applies to arrows and tridents."); } } } From 1436588dee7a6f49d6bad53b1ccf095f48b24e47 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 2 May 2026 01:32:49 -0700 Subject: [PATCH 07/43] Use entity instead of living entity everywhere --- .../skript/bukkit/entity/elements/effects/EffGravity.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index 8d96b7eee97..da42e083839 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -9,7 +9,7 @@ import ch.njol.skript.lang.SkriptParser; import ch.njol.skript.lang.SyntaxStringBuilder; import ch.njol.util.Kleenean; -import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Entity; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; import org.skriptlang.skript.registration.SyntaxInfo; @@ -35,20 +35,20 @@ public static void register(SyntaxRegistry registry) { ); } - private Expression entities; + private Expression entities; private boolean negated; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { //noinspection unchecked - entities = (Expression) expressions[0]; + entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); return true; } @Override protected void execute(Event event) { - for (LivingEntity entity : entities.getArray(event)) { + for (Entity entity : entities.getArray(event)) { entity.setGravity(!negated); } } From d8aa095453516e22763f537825cf270204d6a22f Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 5 May 2026 13:35:54 -0700 Subject: [PATCH 08/43] Allow deprecation warning to be suppressed --- src/main/java/ch/njol/skript/expressions/ExprAI.java | 4 ++-- src/main/java/ch/njol/skript/expressions/ExprGlowing.java | 4 ++-- src/main/java/ch/njol/skript/expressions/ExprGravity.java | 4 ++-- .../njol/skript/expressions/ExprProjectileCriticalState.java | 3 ++- 4 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/main/java/ch/njol/skript/expressions/ExprAI.java b/src/main/java/ch/njol/skript/expressions/ExprAI.java index 23966496359..636b46f6348 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprAI.java +++ b/src/main/java/ch/njol/skript/expressions/ExprAI.java @@ -1,6 +1,5 @@ package ch.njol.skript.expressions; -import ch.njol.skript.Skript; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser; import ch.njol.util.Kleenean; @@ -15,6 +14,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; import ch.njol.util.coll.CollectionUtils; +import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Entity AI") @Description("Returns whether an entity has AI.") @@ -29,7 +29,7 @@ public class ExprAI extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - Skript.warning("This expression is deprecated. Consider using the AI effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the AI effect instead."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java index 95f2ca7fba7..d333e46f2c3 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java @@ -1,6 +1,5 @@ package ch.njol.skript.expressions; -import ch.njol.skript.Skript; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser; import ch.njol.util.Kleenean; @@ -14,6 +13,7 @@ import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; +import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Glowing") @Description("Indicates if targeted entity is glowing (new 1.9 effect) or not. Glowing entities can be seen through walls.") @@ -28,7 +28,7 @@ public class ExprGlowing extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - Skript.warning("This expression is deprecated. Consider using the glowing effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the glowing effect instead."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index 1052b0154dd..72f5b3ddf24 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -7,13 +7,13 @@ import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; -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.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; +import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Gravity") @Description("If entity is affected by gravity or not, i.e. if it has Minecraft 1.10+ NoGravity flag.") @@ -28,7 +28,7 @@ public class ExprGravity extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - Skript.warning("This expression is deprecated. Consider using the gravity effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the gravity effect instead."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java index 28cb8d208cb..eabdcb78c0b 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java +++ b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java @@ -17,6 +17,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; import ch.njol.util.coll.CollectionUtils; +import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Projectile Critical State") @Description("A projectile's critical state. The only currently accepted projectiles are arrows and tridents.") @@ -37,7 +38,7 @@ public class ExprProjectileCriticalState extends SimplePropertyExpression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - Skript.warning("This expression is deprecated. Consider using the projectile critical state effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the projectile critical state effect instead."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } From 7febfff2ec57514b76c1db73a6aa304492e6c4e9 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 5 May 2026 14:09:20 -0700 Subject: [PATCH 09/43] Improve syntax --- .../skript/bukkit/entity/elements/effects/EffAI.java | 5 ++--- .../skript/bukkit/entity/elements/effects/EffGlowing.java | 5 +++-- .../skript/bukkit/entity/elements/effects/EffGravity.java | 5 ++--- .../entity/elements/effects/EffProjectileCriticalState.java | 5 ++--- 4 files changed, 9 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java index a7fd2356409..1400955df82 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -27,7 +27,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffAI.class) .addPatterns( - "(enable|:disable) (ai|artificial intelligence) of %livingentities%", + "(enable|:disable) (ai|artificial intelligence) (of|for) %livingentities%", "(enable|:disable) %livingentities%'s (ai|artificial intelligence)" ) .supplier(EffAI::new) @@ -56,8 +56,7 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .appendIf(!negated, "enable") - .appendIf(negated, "disable") + .append(negated ? "disable" : "enable") .append("ai of", entities) .toString(); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java index 29cf2631ee4..427552bd2ed 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -28,7 +28,8 @@ public static void register(SyntaxRegistry registry) { SyntaxInfo.builder(EffGlowing.class) .addPatterns( "make %entities% [negate:not] glow", - "make %entities% (negate:stop|start) glowing" + "make %entities% (negate:stop|start) glowing", + "stop %entities% from glowing" ) .supplier(EffGlowing::new) .build() @@ -42,7 +43,7 @@ public static void register(SyntaxRegistry registry) { public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; - negated = parseResult.hasTag("negate"); + negated = (parseResult.hasTag("negate") || matchedPattern == 2); return true; } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index da42e083839..cad4ad229b1 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -27,7 +27,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffGravity.class) .addPatterns( - "(enable|:disable) (gravity) of %entities%", + "(enable|:disable) (gravity) (of|for) %entities%", "(enable|:disable) %entities%'s (gravity)" ) .supplier(EffGravity::new) @@ -56,8 +56,7 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .appendIf(!negated, "enable") - .appendIf(negated, "disable") + .append(negated ? "disable" : "enable") .append("gravity of", entities) .toString(); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index 8f47fbe11be..e7769b70912 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -31,7 +31,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffProjectileCriticalState.class) .addPatterns( - "(enable|:disable) (projectile|arrow) critical (state|mode) of %projectiles%", + "(enable|:disable) (projectile|arrow) critical (state|mode) (of|for) %projectiles%", "(enable|:disable) %projectiles%'s (projectile|arrow) critical (state|mode)" ) .supplier(EffProjectileCriticalState::new) @@ -64,8 +64,7 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .appendIf(!negated, "enable") - .appendIf(negated, "disable") + .append(negated ? "disable" : "enable") .append("projectile critical state", projectiles) .toString(); } From 9246dbc625385aebf7e79b9c56e8d4a173a36486 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Fri, 8 May 2026 15:01:41 -0700 Subject: [PATCH 10/43] Use the infoBuilder and allow for multiple projectiles --- .../conditions/CondProjectileIsCritical.java | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index e0e566e8e76..d2b76564305 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -11,11 +11,10 @@ import org.bukkit.entity.AbstractArrow; import org.bukkit.entity.Projectile; import org.skriptlang.skript.log.runtime.RuntimeErrorProducer; -import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Projectile Is Critical") -@Description("Checks whether or not a projectile is in critical state. As of now this only applies to arrows and tridents.") +@Description("Checks whether or not a projectile is in critical state. Currently this only applies to arrows and tridents.") @Example(""" on shoot: if event-projectile is not in projectile critical state: @@ -27,10 +26,12 @@ public class CondProjectileIsCritical extends PropertyCondition impl public static void register(SyntaxRegistry registry) { registry.register( SyntaxRegistry.CONDITION, - SyntaxInfo.builder(CondProjectileIsCritical.class) - .addPatterns( - "%projectile% is in (projectile|arrow) critical (state|mode)", - "%projectile% (is not|isn't) in (projectile|arrow) critical (state|mode)") + infoBuilder( + CondProjectileIsCritical.class, + PropertyType.BE, + "in (projectile|arrow) critical (state|mode)", + "projectiles" + ) .supplier(CondProjectileIsCritical::new) .build() ); @@ -47,7 +48,7 @@ public boolean check(Projectile projectile) { if (projectile instanceof AbstractArrow abstractArrow) { return abstractArrow.isCritical(); } - warning("This projectile is not supported. This only applies to arrows and tridents."); + warning("This projectile is not supported. Critical projectile state only applies to arrows and tridents."); return false; } From 6c94d5cc9bf2415438bb5530cf9adaad01c29608 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Fri, 8 May 2026 15:10:35 -0700 Subject: [PATCH 11/43] Allow all entities to glow instead of just living entities --- .../bukkit/entity/elements/conditions/CondIsGlowing.java | 2 +- .../skript/bukkit/entity/elements/effects/EffGlowing.java | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java index 1f8a3e3149c..00feb96d040 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java @@ -6,7 +6,7 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Is Glowing") -@Description("Checks whether or not a living entity is glowing.") +@Description("Checks whether or not an entity is glowing.") @Example(""" command /glow: trigger: diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java index 427552bd2ed..cf7221249e5 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -9,7 +9,7 @@ import ch.njol.skript.lang.SkriptParser; import ch.njol.skript.lang.SyntaxStringBuilder; import ch.njol.util.Kleenean; -import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Entity; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; import org.skriptlang.skript.registration.SyntaxInfo; @@ -36,20 +36,20 @@ public static void register(SyntaxRegistry registry) { ); } - private Expression entities; + private Expression entities; private boolean negated; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { //noinspection unchecked - entities = (Expression) expressions[0]; + entities = (Expression) expressions[0]; negated = (parseResult.hasTag("negate") || matchedPattern == 2); return true; } @Override protected void execute(Event event) { - for (LivingEntity entity : entities.getArray(event)) { + for (Entity entity : entities.getArray(event)) { entity.setGlowing(!negated); } } From b6343a0cff17e8879d999f90d3fb04368c25405d Mon Sep 17 00:00:00 2001 From: Phill310 Date: Fri, 8 May 2026 15:45:27 -0700 Subject: [PATCH 12/43] Add condition for gravity --- .../skript/bukkit/entity/EntityModule.java | 2 + .../elements/conditions/CondHasGravity.java | 41 +++++++++++++++++++ 2 files changed, 43 insertions(+) create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java index 29e5f1dab6f..6c6af78423f 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java @@ -7,6 +7,7 @@ import org.skriptlang.skript.addon.HierarchicalAddonModule; import org.skriptlang.skript.addon.SkriptAddon; import org.skriptlang.skript.bukkit.entity.displays.DisplayModule; +import org.skriptlang.skript.bukkit.entity.elements.conditions.CondHasGravity; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondIsGlowing; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondProjectileIsCritical; import org.skriptlang.skript.bukkit.entity.elements.effects.EffAI; @@ -44,6 +45,7 @@ protected void loadSelf(SkriptAddon addon) { } register(addon, + CondHasGravity::register, CondIsGlowing::register, CondProjectileIsCritical::register, diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java new file mode 100644 index 00000000000..f8fdf5075b5 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java @@ -0,0 +1,41 @@ +package org.skriptlang.skript.bukkit.entity.elements.conditions; + +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.Since; +import org.bukkit.entity.Entity; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Has Gravity") +@Description("Checks whether or not an entity experiences gravity.") +@Example("send whether player has gravity") +@Since("INSERT VERSION") +public class CondHasGravity extends PropertyCondition { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.CONDITION, + infoBuilder( + CondHasGravity.class, + PropertyType.HAVE, + "gravity", + "entities" + ) + .supplier(CondHasGravity::new) + .build() + ); + } + + @Override + public boolean check(Entity entity) { + return entity.hasGravity(); + } + + @Override + protected String getPropertyName() { + return "gravity"; + } + +} From 695291911d1d3c411e74380bcbe3a3b1ba65dd8d Mon Sep 17 00:00:00 2001 From: Phill310 Date: Fri, 8 May 2026 16:28:50 -0700 Subject: [PATCH 13/43] Add tests --- .../skript/tests/syntaxes/effects/EffAi.sk | 19 +++++++ .../tests/syntaxes/effects/EffGlowing.sk | 53 +++++++++++++++++++ .../tests/syntaxes/effects/EffGravity.sk | 19 +++++++ .../effects/EffProjectileCriticalState.sk | 37 +++++++++++++ 4 files changed, 128 insertions(+) create mode 100644 src/test/skript/tests/syntaxes/effects/EffAi.sk create mode 100644 src/test/skript/tests/syntaxes/effects/EffGlowing.sk create mode 100644 src/test/skript/tests/syntaxes/effects/EffGravity.sk create mode 100644 src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk diff --git a/src/test/skript/tests/syntaxes/effects/EffAi.sk b/src/test/skript/tests/syntaxes/effects/EffAi.sk new file mode 100644 index 00000000000..4222dfcadf9 --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffAi.sk @@ -0,0 +1,19 @@ +test "Entity AI Effect": + spawn pig at test-location: + assert entity has ai with "Spawned pig didn't have ai" + disable ai of entity + assert entity doesn't have ai with "Failed to disable ai of pig" + enable artificial intelligence of entity + assert entity has ai with "Failed to enable ai of pig" + delete entity + +test "Entity AI Effect with multiple entities": + spawn 2 pigs at test-location: + add entity to {_pigs::*} + + assert {_pigs::*} have ai with "Spawned pigs didn't have ai" + disable ai of {_pigs::*} + assert {_pigs::*} don't have ai with "Failed to disable ai of 2 pigs" + enable artificial intelligence of {_pigs::*} + assert {_pigs::*} have ai with "Failed to enable ai of 2 pigs" + delete entities within {_pigs::*} diff --git a/src/test/skript/tests/syntaxes/effects/EffGlowing.sk b/src/test/skript/tests/syntaxes/effects/EffGlowing.sk new file mode 100644 index 00000000000..daf308c9501 --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffGlowing.sk @@ -0,0 +1,53 @@ +test "Entity Glowing": + spawn pig at test location: + assert entity isn't glowing with "Spawned pig is already glowing" + make entity start glowing + assert entity is glowing with "Failed to make pig start glowing" + stop entity from glowing + assert entity is not glowing with "Failed to stop pig from glowing" + make entity glow + assert entity is glowing with "Failed to make pig glow" + make entity not glow + assert entity is not glowing with "Failed to make pig not glow" + delete entity + + spawn dropped apple at test-location: + assert entity isn't glowing with "Spawned dropped item is already glowing" + make entity start glowing + assert entity is glowing with "Failed to make dropped item start glowing" + stop entity from glowing + assert entity is not glowing with "Failed to stop dropped item from glowing" + make entity glow + assert entity is glowing with "Failed to make dropped item glow" + make entity not glow + assert entity is not glowing with "Failed to make dropped item not glow" + delete entity + +test "Entity Glowing for multiple entities": + spawn 2 pigs at test-location: + add entity to {_pigs::*} + + assert {_pigs::*} aren't glowing with "Spawned pigs were already glowing" + make {_pigs::*} start glowing + assert {_pigs::*} are glowing with "Failed to make 2 pigs start glowing" + stop {_pigs::*} from glowing + assert {_pigs::*} are not glowing with "Failed to stop 2 pigs from glowing" + make {_pigs::*} glow + assert {_pigs::*} are glowing with "Failed to make 2 pigs glow" + make {_pigs::*} not glow + assert {_pigs::*} are not glowing with "Failed to make 2 pigs not glow" + delete entities within {_pigs::*} + + spawn 2 dropped apples at test-location: + add entity to {_dropped items::*} + + assert {_dropped items::*} aren't glowing with "Spawned dropped items were already glowing" + make {_dropped items::*} start glowing + assert {_dropped items::*} is glowing with "Failed to make 2 dropped items start glowing" + stop {_dropped items::*} from glowing + assert {_dropped items::*} is not glowing with "Failed to stop 2 dropped items from glowing" + make {_dropped items::*} glow + assert {_dropped items::*} is glowing with "Failed to make 2 dropped items glow" + make {_dropped items::*} not glow + assert {_dropped items::*} is not glowing with "Failed to make 2 dropped items not glow" + delete entities within {_dropped items::*} diff --git a/src/test/skript/tests/syntaxes/effects/EffGravity.sk b/src/test/skript/tests/syntaxes/effects/EffGravity.sk new file mode 100644 index 00000000000..2487b0c28a2 --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffGravity.sk @@ -0,0 +1,19 @@ +test "Entity Gravity Effect": + spawn pig at test-location: + assert entity has gravity with "Spawned pig didn't have gravity" + disable entity's gravity + assert entity doesn't have gravity with "Failed to disable gravity of pig" + enable gravity of entity + assert entity has gravity with "Failed to enable gravity of pig" + delete entity + +test "Entity Gravity Effect with multiple entities": + spawn 2 pigs at test-location: + add entity to {_pigs::*} + + assert {_pigs::*} have gravity with "Spawned pigs didn't have ai" + disable gravity of {_pigs::*} + assert {_pigs::*} don't have gravity with "Failed to disable gravity of 2 pigs" + enable {_pigs::*}'s gravity + assert {_pigs::*} have gravity with "Failed to enable gravity of 2 pigs" + delete entities within {_pigs::*} \ No newline at end of file diff --git a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk new file mode 100644 index 00000000000..8f2e0fa48e1 --- /dev/null +++ b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk @@ -0,0 +1,37 @@ +test "Projectile Critical State Effect": + shoot arrow from test-location: + assert event-projectile isn't in projectile critical state with "A normally shot arrow shouldn't be in critical state" + enable event-projectile's arrow critical state + assert event-projectile is in arrow critical mode with "Failed to enable critical state of the arrow" + disable projectile critical mode of event-projectile + assert event-projectile isn't in projectile critical state with "Failed to disable the critical state of the arrow" + delete event-projectile + + shoot trident from test-location: + assert event-projectile isn't in projectile critical state with "A normally shot trident shouldn't be in critical state" + enable event-projectile's arrow critical state + assert event-projectile is in arrow critical mode with "Failed to enable critical state of the trident" + disable projectile critical mode of event-projectile + assert event-projectile isn't in projectile critical state with "Failed to disable the critical state of the trident" + delete event-projectile + +test "Projectile Critical State Effect with multiple projectiles": + shoot arrow and arrow from test-location: + add event-projectile to {_arrows::*} + + assert {_arrows::*} aren't in projectile critical state with "Normally shot arrows shouldn't be in critical state" + enable {_arrows::*}'s arrow critical state + assert {_arrows::*} are in arrow critical mode with "Failed to enable critical state of the 2 arrows" + disable projectile critical mode of {_arrows::*} + assert {_arrows::*} aren't in projectile critical state with "Failed to disable the critical state of the 2 arrows" + delete {_arrows::*} + + shoot trident and trident from test-location: + add event-projectile to {_tridents::*} + + assert {_tridents::*} aren't in projectile critical state with "Normally shot tridents shouldn't be in critical state" + enable {_tridents::*}'s arrow critical state + assert {_tridents::*} are in arrow critical mode with "Failed to enable critical state of the 2 tridents" + disable projectile critical mode of {_tridents::*} + assert {_tridents::*} aren't in projectile critical state with "Failed to disable the critical state of the 2 tridents" + delete {_tridents::*} \ No newline at end of file From e7cc66bc435677612b2ac7bb6ac8af5487e28ec1 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 9 May 2026 11:50:31 -0700 Subject: [PATCH 14/43] Update src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java Co-authored-by: Efnilite <35348263+Efnilite@users.noreply.github.com> --- .../skript/bukkit/entity/elements/effects/EffGravity.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index cad4ad229b1..e74d2963833 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -27,8 +27,8 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffGravity.class) .addPatterns( - "(enable|:disable) (gravity) (of|for) %entities%", - "(enable|:disable) %entities%'s (gravity)" + "(enable|:disable) gravity (of|for) %entities%", + "(enable|:disable) %entities%'s gravity" ) .supplier(EffGravity::new) .build() From d7380d2a55888fd7c043d59f5f5e5b6a575f34c9 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 9 May 2026 12:00:11 -0700 Subject: [PATCH 15/43] Improve description --- .../entity/elements/conditions/CondProjectileIsCritical.java | 5 ++++- .../entity/elements/effects/EffProjectileCriticalState.java | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index d2b76564305..f61ec602810 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -14,7 +14,10 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Projectile Is Critical") -@Description("Checks whether or not a projectile is in critical state. Currently this only applies to arrows and tridents.") +@Description(""" + Check whether a projectile is in its critical state. When in critical state the projectile will have a trail of particles and deal more damage. + Currently this only applies to arrows and tridents. + """) @Example(""" on shoot: if event-projectile is not in projectile critical state: diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index e7769b70912..ef8f7c836d6 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -18,7 +18,10 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Projectile Critical State") -@Description("Change whether a projectile is in its critical state. As of now this only applies to arrows and tridents.") +@Description(""" + Change whether a projectile is in its critical state. When in critical state the projectile will have a trail of particles and deal more damage. + Currently this only applies to arrows and tridents. + """) @Example(""" on shoot: enable projectile critical state of event-projectile From 15dd43d48419f5e7e8a8631757af1512b1fd2417 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 9 May 2026 12:03:50 -0700 Subject: [PATCH 16/43] Deprecate Flight Mode expression --- .../ch/njol/skript/expressions/ExprFlightMode.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java index 47032801823..4d5c2201859 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java +++ b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java @@ -6,22 +6,33 @@ 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.SkriptParser; +import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Flight Mode") @Description("Whether the player(s) are allowed to fly. Use Make Fly effect to force player(s) to fly.") @Example("set flight mode of player to true") @Example("send \"%flying state of all players%\"") @Since("2.2-dev34") +@Deprecated(since = "INSERT VERSION", forRemoval = true) public class ExprFlightMode extends SimplePropertyExpression { static { register(ExprFlightMode.class, Boolean.class, "fl(y[ing]|ight) (mode|state)", "players"); } + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the Make Fly effect instead."); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } + @Override public Boolean convert(final Player player) { return player.getAllowFlight(); From 42c84c6401724441ccd4cc5cbba3965d70d374c5 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 9 May 2026 13:19:04 -0700 Subject: [PATCH 17/43] Apply suggestions from code review Co-authored-by: sovdee <10354869+sovdeeth@users.noreply.github.com> --- src/test/skript/tests/syntaxes/effects/EffGravity.sk | 2 +- .../skript/tests/syntaxes/effects/EffProjectileCriticalState.sk | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/skript/tests/syntaxes/effects/EffGravity.sk b/src/test/skript/tests/syntaxes/effects/EffGravity.sk index 2487b0c28a2..eb644dd0d05 100644 --- a/src/test/skript/tests/syntaxes/effects/EffGravity.sk +++ b/src/test/skript/tests/syntaxes/effects/EffGravity.sk @@ -16,4 +16,4 @@ test "Entity Gravity Effect with multiple entities": assert {_pigs::*} don't have gravity with "Failed to disable gravity of 2 pigs" enable {_pigs::*}'s gravity assert {_pigs::*} have gravity with "Failed to enable gravity of 2 pigs" - delete entities within {_pigs::*} \ No newline at end of file + delete entities within {_pigs::*} diff --git a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk index 8f2e0fa48e1..343b9dc4af2 100644 --- a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk +++ b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk @@ -34,4 +34,4 @@ test "Projectile Critical State Effect with multiple projectiles": assert {_tridents::*} are in arrow critical mode with "Failed to enable critical state of the 2 tridents" disable projectile critical mode of {_tridents::*} assert {_tridents::*} aren't in projectile critical state with "Failed to disable the critical state of the 2 tridents" - delete {_tridents::*} \ No newline at end of file + delete {_tridents::*} From 6510462785f4d8146acfbc37aa13d55069a4fe37 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 09:45:46 -0700 Subject: [PATCH 18/43] Make deprecation messages more forceful --- src/main/java/ch/njol/skript/expressions/ExprAI.java | 2 +- src/main/java/ch/njol/skript/expressions/ExprFlightMode.java | 2 +- src/main/java/ch/njol/skript/expressions/ExprGlowing.java | 2 +- src/main/java/ch/njol/skript/expressions/ExprGravity.java | 2 +- .../ch/njol/skript/expressions/ExprProjectileCriticalState.java | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/ch/njol/skript/expressions/ExprAI.java b/src/main/java/ch/njol/skript/expressions/ExprAI.java index 636b46f6348..affddc5e2cb 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprAI.java +++ b/src/main/java/ch/njol/skript/expressions/ExprAI.java @@ -29,7 +29,7 @@ public class ExprAI extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the AI effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the AI effect instead: 'enable ai for %livingentities%'."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java index 4d5c2201859..45adbc7010b 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java +++ b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java @@ -29,7 +29,7 @@ public class ExprFlightMode extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the Make Fly effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the Make Fly effect instead: 'make %players% fly'"); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java index d333e46f2c3..6b96f2f3cda 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java @@ -28,7 +28,7 @@ public class ExprGlowing extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the glowing effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the glowing effect instead: 'make %entities% glow'"); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index 72f5b3ddf24..eca0512e5c5 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -28,7 +28,7 @@ public class ExprGravity extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the gravity effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the gravity effect instead: 'enable gravity of %entities%'"); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java index eabdcb78c0b..164a521313e 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java +++ b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java @@ -38,7 +38,7 @@ public class ExprProjectileCriticalState extends SimplePropertyExpression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated. Consider using the projectile critical state effect instead."); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the projectile critical state effect instead: 'make %projectiles% crit'"); return super.init(expressions, matchedPattern, isDelayed, parseResult); } From da5660ce57403c76fef9211ee8bab4584ca89ce3 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 09:46:28 -0700 Subject: [PATCH 19/43] Make syntax simpler --- .../elements/conditions/CondProjectileIsCritical.java | 9 ++++----- .../elements/effects/EffProjectileCriticalState.java | 5 ++--- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index f61ec602810..63ac6d03b76 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -10,7 +10,6 @@ import ch.njol.util.Kleenean; import org.bukkit.entity.AbstractArrow; import org.bukkit.entity.Projectile; -import org.skriptlang.skript.log.runtime.RuntimeErrorProducer; import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Projectile Is Critical") @@ -20,19 +19,19 @@ """) @Example(""" on shoot: - if event-projectile is not in projectile critical state: + if event-projectile will crit: enable projectile critical state of event-projectile """) @Since("INSERT VERSION") -public class CondProjectileIsCritical extends PropertyCondition implements RuntimeErrorProducer { +public class CondProjectileIsCritical extends PropertyCondition { public static void register(SyntaxRegistry registry) { registry.register( SyntaxRegistry.CONDITION, infoBuilder( CondProjectileIsCritical.class, - PropertyType.BE, - "in (projectile|arrow) critical (state|mode)", + PropertyType.WILL, + "crit[ical]", "projectiles" ) .supplier(CondProjectileIsCritical::new) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index ef8f7c836d6..b39d9f022dd 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -24,7 +24,7 @@ """) @Example(""" on shoot: - enable projectile critical state of event-projectile + make event-projectile crit """) @Since("INSERT VERSION") public class EffProjectileCriticalState extends Effect implements RuntimeErrorProducer { @@ -34,8 +34,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffProjectileCriticalState.class) .addPatterns( - "(enable|:disable) (projectile|arrow) critical (state|mode) (of|for) %projectiles%", - "(enable|:disable) %projectiles%'s (projectile|arrow) critical (state|mode)" + "make %projectiles% [negate:not] crit[ical]" ) .supplier(EffProjectileCriticalState::new) .build() From 9b7f7fec55e351a5276d7a4d906710eaca7be3cd Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 10:07:28 -0700 Subject: [PATCH 20/43] Improve Description --- .../bukkit/entity/elements/conditions/CondIsGlowing.java | 6 +++++- .../skript/bukkit/entity/elements/effects/EffGlowing.java | 6 +++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java index 00feb96d040..cc7d5620cfe 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondIsGlowing.java @@ -6,7 +6,11 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Is Glowing") -@Description("Checks whether or not an entity is glowing.") +@Description( + "Check whether an entity is glowing. Glowing entites have outlines that can be " + + "seen through blocks. This will change the entity's glowing property (NBT). This " + + "is not related to the glowing potion effect." +) @Example(""" command /glow: trigger: diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java index cf7221249e5..db5b632ce0a 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -16,7 +16,11 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Entity Glow") -@Description("Change whether an entity is glowing.") +@Description( + "Change whether an entity is glowing. Glowing entites have outlines that can be " + + "seen through blocks. This will change the entity's glowing property (NBT). This " + + "is not related to the glowing potion effect." +) @Example("make target entity glow") @Example("make player stop glowing") @Since("INSERT VERSION") From 2b850d7e664d10be8456daee2430f56b43d700ba Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 10:09:19 -0700 Subject: [PATCH 21/43] Remove redundant innit --- .../elements/conditions/CondProjectileIsCritical.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index 63ac6d03b76..b97fb2a4cb5 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -39,12 +39,6 @@ public static void register(SyntaxRegistry registry) { ); } - @Override - public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - setNegated(matchedPattern == 1); - return super.init(exprs, matchedPattern, isDelayed, parseResult); - } - @Override public boolean check(Projectile projectile) { if (projectile instanceof AbstractArrow abstractArrow) { From 4bfc25aeac12288bc7ab960e67701077fc658694 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 10:12:23 -0700 Subject: [PATCH 22/43] import ParseResult from skriptparser --- .../skript/bukkit/entity/elements/effects/EffAI.java | 4 ++-- .../skript/bukkit/entity/elements/effects/EffGlowing.java | 4 ++-- .../skript/bukkit/entity/elements/effects/EffGravity.java | 4 ++-- .../entity/elements/effects/EffProjectileCriticalState.java | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java index 1400955df82..10692c555d4 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -6,7 +6,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxStringBuilder; import ch.njol.util.Kleenean; import org.bukkit.entity.LivingEntity; @@ -39,7 +39,7 @@ public static void register(SyntaxRegistry registry) { private boolean negated; @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java index db5b632ce0a..d0d56e764f5 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -6,7 +6,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxStringBuilder; import ch.njol.util.Kleenean; import org.bukkit.entity.Entity; @@ -44,7 +44,7 @@ public static void register(SyntaxRegistry registry) { private boolean negated; @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = (parseResult.hasTag("negate") || matchedPattern == 2); diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index e74d2963833..496bb7de680 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -6,7 +6,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxStringBuilder; import ch.njol.util.Kleenean; import org.bukkit.entity.Entity; @@ -39,7 +39,7 @@ public static void register(SyntaxRegistry registry) { private boolean negated; @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index b39d9f022dd..f33b1f1f426 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -6,7 +6,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxStringBuilder; import ch.njol.util.Kleenean; import org.bukkit.entity.AbstractArrow; @@ -45,7 +45,7 @@ public static void register(SyntaxRegistry registry) { private boolean negated; @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked projectiles = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); From 20a4204b45e0a63f2303942e87fbdee75b78b792 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 10:29:15 -0700 Subject: [PATCH 23/43] Update to reflect new syntax --- .../effects/EffProjectileCriticalState.java | 10 +++-- .../effects/EffProjectileCriticalState.sk | 40 +++++++++---------- 2 files changed, 26 insertions(+), 24 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index f33b1f1f426..31b60323087 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -19,7 +19,8 @@ @Name("Projectile Critical State") @Description(""" - Change whether a projectile is in its critical state. When in critical state the projectile will have a trail of particles and deal more damage. + Change whether a projectile is in its critical state. When in critical state \ + the projectile will have a trail of particles and deal more damage. Currently this only applies to arrows and tridents. """) @Example(""" @@ -48,7 +49,7 @@ public static void register(SyntaxRegistry registry) { public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked projectiles = (Expression) expressions[0]; - negated = parseResult.hasTag("disable"); + negated = parseResult.hasTag("negate"); return true; } @@ -66,8 +67,9 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .append(negated ? "disable" : "enable") - .append("projectile critical state", projectiles) + .append("make", projectiles) + .appendIf(negated, "not") + .append("crit") .toString(); } diff --git a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk index 343b9dc4af2..eb437274508 100644 --- a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk +++ b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk @@ -1,37 +1,37 @@ test "Projectile Critical State Effect": shoot arrow from test-location: - assert event-projectile isn't in projectile critical state with "A normally shot arrow shouldn't be in critical state" - enable event-projectile's arrow critical state - assert event-projectile is in arrow critical mode with "Failed to enable critical state of the arrow" - disable projectile critical mode of event-projectile - assert event-projectile isn't in projectile critical state with "Failed to disable the critical state of the arrow" + assert event-projectile won't crit with "A normally shot arrow shouldn't crit" + make event-projectile crit + assert event-projectile will crit with "Failed to make arrow crit" + make event-projectile not crit + assert event-projectile won't crit with "Failed to make the arrow not crit" delete event-projectile shoot trident from test-location: - assert event-projectile isn't in projectile critical state with "A normally shot trident shouldn't be in critical state" - enable event-projectile's arrow critical state - assert event-projectile is in arrow critical mode with "Failed to enable critical state of the trident" - disable projectile critical mode of event-projectile - assert event-projectile isn't in projectile critical state with "Failed to disable the critical state of the trident" + assert event-projectile won't crit with "A normally shot trident shouldn't crit" + make event-projectile crit + assert event-projectile will crit with "Failed to make the trident crit" + make event-projectile not crit + assert event-projectile won't crit with "Failed to make the trident not crit" delete event-projectile test "Projectile Critical State Effect with multiple projectiles": shoot arrow and arrow from test-location: add event-projectile to {_arrows::*} - assert {_arrows::*} aren't in projectile critical state with "Normally shot arrows shouldn't be in critical state" - enable {_arrows::*}'s arrow critical state - assert {_arrows::*} are in arrow critical mode with "Failed to enable critical state of the 2 arrows" - disable projectile critical mode of {_arrows::*} - assert {_arrows::*} aren't in projectile critical state with "Failed to disable the critical state of the 2 arrows" + assert {_arrows::*} won't crit with "Normally shot arrows shouldn't crit" + make {_arrows::*} crit + assert {_arrows::*} will crit with "Failed to make the 2 arrows crit" + make {_arrows::*} not crit + assert {_arrows::*} won't crit with "Failed to make the 2 arrows not crit" delete {_arrows::*} shoot trident and trident from test-location: add event-projectile to {_tridents::*} - assert {_tridents::*} aren't in projectile critical state with "Normally shot tridents shouldn't be in critical state" - enable {_tridents::*}'s arrow critical state - assert {_tridents::*} are in arrow critical mode with "Failed to enable critical state of the 2 tridents" - disable projectile critical mode of {_tridents::*} - assert {_tridents::*} aren't in projectile critical state with "Failed to disable the critical state of the 2 tridents" + assert {_tridents::*} won't crit with "Normally shot tridents shouldn't crit" + make {_tridents::*} crit + assert {_tridents::*} will crit with "Failed to make the 2 tridents crit" + make {_tridents::*} not crit + assert {_tridents::*} won't crit with "Failed to make the 2 tridents not crit" delete {_tridents::*} From eddabb43d7e606ab46fc3ebb88d77d81f5afdea6 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 10:34:04 -0700 Subject: [PATCH 24/43] Clean up imports --- .../entity/elements/conditions/CondProjectileIsCritical.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index b97fb2a4cb5..f6087bc9e34 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -5,9 +5,6 @@ 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.SkriptParser; -import ch.njol.util.Kleenean; import org.bukkit.entity.AbstractArrow; import org.bukkit.entity.Projectile; import org.skriptlang.skript.registration.SyntaxRegistry; From 35423a87687b784df17a5a7522c6f58d1dbb4b27 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 11:14:35 -0700 Subject: [PATCH 25/43] Include the projectile in the runtime error --- .../entity/elements/conditions/CondProjectileIsCritical.java | 3 ++- .../entity/elements/effects/EffProjectileCriticalState.java | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index f6087bc9e34..e32ac6a1b08 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -5,6 +5,7 @@ import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; +import ch.njol.skript.entity.EntityData; import org.bukkit.entity.AbstractArrow; import org.bukkit.entity.Projectile; import org.skriptlang.skript.registration.SyntaxRegistry; @@ -41,7 +42,7 @@ public boolean check(Projectile projectile) { if (projectile instanceof AbstractArrow abstractArrow) { return abstractArrow.isCritical(); } - warning("This projectile is not supported. Critical projectile state only applies to arrows and tridents."); + warning("This projectile (" + EntityData.toString(projectile) + ") is not supported. Critical projectile state only applies to arrows and tridents."); return false; } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index 31b60323087..0e91e32e413 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -4,6 +4,7 @@ import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; +import ch.njol.skript.entity.EntityData; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser.ParseResult; @@ -59,7 +60,7 @@ protected void execute(Event event) { if (projectile instanceof AbstractArrow abstractArrow) { abstractArrow.setCritical(!negated); } else { - warning("This projectile is not supported. This only applies to arrows and tridents."); + warning("This projectile (" + EntityData.toString(projectile) + ") is not supported. This only applies to arrows and tridents."); } } } From 4e6a6e4d5052a499897186a4e62fceab6e096d1c Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 11:44:07 -0700 Subject: [PATCH 26/43] Improve description --- .../ch/njol/skript/conditions/CondAI.java | 36 ------------- .../skript/bukkit/entity/EntityModule.java | 2 + .../entity/elements/conditions/CondAI.java | 53 +++++++++++++++++++ .../bukkit/entity/elements/effects/EffAI.java | 8 ++- 4 files changed, 62 insertions(+), 37 deletions(-) delete mode 100644 src/main/java/ch/njol/skript/conditions/CondAI.java create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondAI.java diff --git a/src/main/java/ch/njol/skript/conditions/CondAI.java b/src/main/java/ch/njol/skript/conditions/CondAI.java deleted file mode 100644 index da7c896917b..00000000000 --- a/src/main/java/ch/njol/skript/conditions/CondAI.java +++ /dev/null @@ -1,36 +0,0 @@ -package ch.njol.skript.conditions; - -import org.bukkit.entity.LivingEntity; - -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.Since; - -@Name("Has AI") -@Description("Checks whether an entity has AI.") -@Example("target entity has ai") -@Since("2.5") -public class CondAI extends PropertyCondition { - - static { - register(CondAI.class, PropertyType.HAVE, "(ai|artificial intelligence)", "livingentities"); - } - - @Override - public boolean check(LivingEntity entity) { - return entity.hasAI(); - } - - @Override - protected PropertyType getPropertyType() { - return PropertyType.HAVE; - } - - @Override - protected String getPropertyName() { - return "artificial intelligence"; - } - -} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java index 6c6af78423f..1d5f2807304 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java @@ -7,6 +7,7 @@ import org.skriptlang.skript.addon.HierarchicalAddonModule; import org.skriptlang.skript.addon.SkriptAddon; import org.skriptlang.skript.bukkit.entity.displays.DisplayModule; +import org.skriptlang.skript.bukkit.entity.elements.conditions.CondAI; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondHasGravity; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondIsGlowing; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondProjectileIsCritical; @@ -45,6 +46,7 @@ protected void loadSelf(SkriptAddon addon) { } register(addon, + CondAI::register, CondHasGravity::register, CondIsGlowing::register, CondProjectileIsCritical::register, diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondAI.java new file mode 100644 index 00000000000..155e837eadd --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondAI.java @@ -0,0 +1,53 @@ +package org.skriptlang.skript.bukkit.entity.elements.conditions; + +import org.bukkit.entity.LivingEntity; + +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.Since; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Has AI") +@Description( + "Check whether an entity has AI. Entities without AI will not try to attack " + + "other entities and will not be able to move at all. This includes knockback " + + "from getting hit, falling due to gravity, getting pushed by entities/water, " + + "changing velocity with commands and any other form of movement. Accumulated " + + "knockback and velocity changes will be applied when ai is enabled again." +) +@Example("target entity has ai") +@Since("2.5") +public class CondAI extends PropertyCondition { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.CONDITION, + infoBuilder( + CondAI.class, + PropertyType.HAVE, + "(ai|artificial intelligence)", + "livingentities" + ) + .supplier(CondAI::new) + .build() + ); + } + + @Override + public boolean check(LivingEntity entity) { + return entity.hasAI(); + } + + @Override + protected PropertyType getPropertyType() { + return PropertyType.HAVE; + } + + @Override + protected String getPropertyName() { + return "artificial intelligence"; + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java index 10692c555d4..b89fd4b5f75 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -16,7 +16,13 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Entity AI") -@Description("Change whether an entity has AI.") +@Description( + "Change whether an entity has AI. Entities without AI will not try to attack " + + "other entities and will not be able to move at all. This includes knockback " + + "from getting hit, falling due to gravity, getting pushed by entities/water, " + + "changing velocity with commands and any other form of movement. Accumulated " + + "knockback and velocity changes will be applied when ai is enabled again." +) @Example("enable artificial intelligence of target entity") @Example("disable ai of last spawned entity") @Since("INSERT VERSION") From d5852814a5a4a605ca7148f544d5871c543ab5b3 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 12:14:45 -0700 Subject: [PATCH 27/43] Improve description --- .../bukkit/entity/elements/conditions/CondHasGravity.java | 5 ++++- .../skript/bukkit/entity/elements/effects/EffGravity.java | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java index f8fdf5075b5..933bf4fc59e 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java @@ -9,7 +9,10 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Has Gravity") -@Description("Checks whether or not an entity experiences gravity.") +@Description( + "Change whether an entity is affected by gravity. This will override any effects " + + "from the gravity attribute or potions like slow falling." +) @Example("send whether player has gravity") @Since("INSERT VERSION") public class CondHasGravity extends PropertyCondition { diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index 496bb7de680..04fd4726e8d 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -16,7 +16,10 @@ import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Entity Gravity") -@Description("Change whether an entity is affected by gravity.") +@Description( + "Change whether an entity is affected by gravity. This will override any effects " + + "from the gravity attribute or potions like slow falling." +) @Example("enable gravity of target entity") @Example("disable last spawned entity's gravity") @Since("INSERT VERSION") From 0edbe1f58aa403ab54681b075c41552f4fd51fba Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 12:43:00 -0700 Subject: [PATCH 28/43] Make gravity use experiences for its syntax --- .../skript/bukkit/entity/EntityModule.java | 4 +- .../elements/conditions/CondGravity.java | 66 +++++++++++++++++++ .../elements/conditions/CondHasGravity.java | 44 ------------- .../tests/syntaxes/effects/EffGravity.sk | 12 ++-- 4 files changed, 74 insertions(+), 52 deletions(-) create mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java delete mode 100644 src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java index 1d5f2807304..b8746546866 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java @@ -8,7 +8,7 @@ import org.skriptlang.skript.addon.SkriptAddon; import org.skriptlang.skript.bukkit.entity.displays.DisplayModule; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondAI; -import org.skriptlang.skript.bukkit.entity.elements.conditions.CondHasGravity; +import org.skriptlang.skript.bukkit.entity.elements.conditions.CondGravity; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondIsGlowing; import org.skriptlang.skript.bukkit.entity.elements.conditions.CondProjectileIsCritical; import org.skriptlang.skript.bukkit.entity.elements.effects.EffAI; @@ -47,7 +47,7 @@ protected void loadSelf(SkriptAddon addon) { register(addon, CondAI::register, - CondHasGravity::register, + CondGravity::register, CondIsGlowing::register, CondProjectileIsCritical::register, diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java new file mode 100644 index 00000000000..f5c865e293c --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java @@ -0,0 +1,66 @@ +package org.skriptlang.skript.bukkit.entity.elements.conditions; + +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.lang.Condition; +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 org.bukkit.entity.Entity; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; + +@Name("Has Gravity") +@Description( + "Change whether an entity is affected by gravity. This will override any effects " + + "from the gravity attribute or potions like slow falling." +) +@Example("send whether player has gravity") +@Since("INSERT VERSION") +public class CondGravity extends Condition { + + public static void register(SyntaxRegistry registry) { + registry.register( + SyntaxRegistry.CONDITION, + SyntaxInfo.builder(CondGravity.class) + .addPatterns( + "%entities% experience[s] gravity", + "%entities% (doesn't|does not|do not|don't) experience gravity", + "%entities% (is|are) affected by gravity", + "%entities% (isn't|is not|aren't|are not) affected by gravity" + ) + .supplier(CondGravity::new) + .build() + ); + } + + private Expression entities; + + @Override + public boolean init(final Expression[] exprs, final int matchedPattern, final Kleenean isDelayed, final ParseResult parseResult) { + //noinspection unchecked + entities = (Expression) exprs[0]; + setNegated(matchedPattern % 2 == 1); + return true; + } + + @Override + public boolean check(Event event) { + return entities.check(event, Entity::hasGravity, isNegated()); + } + + @Override + public String toString(final @Nullable Event event, final boolean debug) { + return new SyntaxStringBuilder(event, debug) + .append(entities) + .appendIf(isNegated(), "do not") + .append("experience gravity") + .toString(); + } + +} diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java deleted file mode 100644 index 933bf4fc59e..00000000000 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondHasGravity.java +++ /dev/null @@ -1,44 +0,0 @@ -package org.skriptlang.skript.bukkit.entity.elements.conditions; - -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.Since; -import org.bukkit.entity.Entity; -import org.skriptlang.skript.registration.SyntaxRegistry; - -@Name("Has Gravity") -@Description( - "Change whether an entity is affected by gravity. This will override any effects " + - "from the gravity attribute or potions like slow falling." -) -@Example("send whether player has gravity") -@Since("INSERT VERSION") -public class CondHasGravity extends PropertyCondition { - - public static void register(SyntaxRegistry registry) { - registry.register( - SyntaxRegistry.CONDITION, - infoBuilder( - CondHasGravity.class, - PropertyType.HAVE, - "gravity", - "entities" - ) - .supplier(CondHasGravity::new) - .build() - ); - } - - @Override - public boolean check(Entity entity) { - return entity.hasGravity(); - } - - @Override - protected String getPropertyName() { - return "gravity"; - } - -} diff --git a/src/test/skript/tests/syntaxes/effects/EffGravity.sk b/src/test/skript/tests/syntaxes/effects/EffGravity.sk index eb644dd0d05..f2fed93ee7c 100644 --- a/src/test/skript/tests/syntaxes/effects/EffGravity.sk +++ b/src/test/skript/tests/syntaxes/effects/EffGravity.sk @@ -1,19 +1,19 @@ test "Entity Gravity Effect": spawn pig at test-location: - assert entity has gravity with "Spawned pig didn't have gravity" + assert entity experiences gravity with "Spawned pig didn't have gravity" disable entity's gravity - assert entity doesn't have gravity with "Failed to disable gravity of pig" + assert entity doesn't experience gravity with "Failed to disable gravity of pig" enable gravity of entity - assert entity has gravity with "Failed to enable gravity of pig" + assert entity is affected by gravity with "Failed to enable gravity of pig" delete entity test "Entity Gravity Effect with multiple entities": spawn 2 pigs at test-location: add entity to {_pigs::*} - assert {_pigs::*} have gravity with "Spawned pigs didn't have ai" + assert {_pigs::*} experience gravity with "Spawned pigs didn't have ai" disable gravity of {_pigs::*} - assert {_pigs::*} don't have gravity with "Failed to disable gravity of 2 pigs" + assert {_pigs::*} aren't affected by gravity with "Failed to disable gravity of 2 pigs" enable {_pigs::*}'s gravity - assert {_pigs::*} have gravity with "Failed to enable gravity of 2 pigs" + assert {_pigs::*} are affected by gravity with "Failed to enable gravity of 2 pigs" delete entities within {_pigs::*} From adf580fb121133a0e15dadf47d56d363dcc52e59 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 12:54:01 -0700 Subject: [PATCH 29/43] Update example --- .../skript/bukkit/entity/elements/conditions/CondGravity.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java index f5c865e293c..8a97a8dfeb8 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java @@ -15,12 +15,12 @@ import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; -@Name("Has Gravity") +@Name("Experiences Gravity") @Description( "Change whether an entity is affected by gravity. This will override any effects " + "from the gravity attribute or potions like slow falling." ) -@Example("send whether player has gravity") +@Example("send whether player experiences gravity") @Since("INSERT VERSION") public class CondGravity extends Condition { From 452ebb3efab3443309a4e9e4cfcd34b92e3ff6c5 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 2 Jun 2026 13:12:03 -0700 Subject: [PATCH 30/43] Make sure the runtime error works --- .../tests/syntaxes/effects/EffProjectileCriticalState.sk | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk index eb437274508..0644e145956 100644 --- a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk +++ b/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk @@ -1,3 +1,5 @@ +using error catching + test "Projectile Critical State Effect": shoot arrow from test-location: assert event-projectile won't crit with "A normally shot arrow shouldn't crit" @@ -15,6 +17,12 @@ test "Projectile Critical State Effect": assert event-projectile won't crit with "Failed to make the trident not crit" delete event-projectile + shoot snowball from test-location: + catch runtime errors: + make event-projectile crit + set {_error} to "This projectile (snowball) is not supported. This only applies to arrows and tridents." + assert last caught runtime errors contains {_error} with "Making a snowball crit did not trigger the runtime error" + test "Projectile Critical State Effect with multiple projectiles": shoot arrow and arrow from test-location: add event-projectile to {_arrows::*} From fba035c4c3a7a0b7adaa2fde9e649f4d894cd024 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 9 Jun 2026 18:24:24 -0700 Subject: [PATCH 31/43] Add deprecation message to description --- src/main/java/ch/njol/skript/expressions/ExprAI.java | 2 +- src/main/java/ch/njol/skript/expressions/ExprFlightMode.java | 2 +- src/main/java/ch/njol/skript/expressions/ExprGlowing.java | 2 +- src/main/java/ch/njol/skript/expressions/ExprGravity.java | 4 ++-- .../njol/skript/expressions/ExprProjectileCriticalState.java | 4 ++-- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/main/java/ch/njol/skript/expressions/ExprAI.java b/src/main/java/ch/njol/skript/expressions/ExprAI.java index affddc5e2cb..218a5e97021 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprAI.java +++ b/src/main/java/ch/njol/skript/expressions/ExprAI.java @@ -17,7 +17,7 @@ import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Entity AI") -@Description("Returns whether an entity has AI.") +@Description("Returns whether an entity has AI. This expression is deprecated and will be removed in a future version. Use the Entity AI effect instead.") @Example("set artificial intelligence of target entity to false") @Since("2.5") @Deprecated(since = "INSERT VERSION", forRemoval = true) diff --git a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java index 45adbc7010b..04e7db68bad 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java +++ b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java @@ -16,7 +16,7 @@ import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Flight Mode") -@Description("Whether the player(s) are allowed to fly. Use Make Fly effect to force player(s) to fly.") +@Description("Whether the player(s) are allowed to fly. This expression is deprecated and will be removed in a future version. Use Make Fly effect to force player(s) to fly instead.") @Example("set flight mode of player to true") @Example("send \"%flying state of all players%\"") @Since("2.2-dev34") diff --git a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java index 6b96f2f3cda..412cdd17ed8 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java @@ -16,7 +16,7 @@ import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Glowing") -@Description("Indicates if targeted entity is glowing (new 1.9 effect) or not. Glowing entities can be seen through walls.") +@Description("Indicates if targeted entity is glowing (new 1.9 effect) or not. Glowing entities can be seen through walls. This expression is deprecated and will be removed in a future version. Use the Entity Glow/a> effect instead.") @Example("set glowing of player to true") @Since("2.2-dev18") @Deprecated(since = "INSERT VERSION", forRemoval = true) diff --git a/src/main/java/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index eca0512e5c5..20819ef98ee 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -16,7 +16,7 @@ import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Gravity") -@Description("If entity is affected by gravity or not, i.e. if it has Minecraft 1.10+ NoGravity flag.") +@Description("If entity is affected by gravity or not, i.e. if it has Minecraft 1.10+ NoGravity flag. This expression is deprecated and will be removed in a future version. Use the Entity Gravity effect instead.") @Example("set gravity of player off") @Since("2.2-dev21") @Deprecated(since = "INSERT VERSION", forRemoval = true) @@ -28,7 +28,7 @@ public class ExprGravity extends SimplePropertyExpression { @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the gravity effect instead: 'enable gravity of %entities%'"); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the gravity effect instead: 'enable gravity of %entities%'"); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java index 164a521313e..952363d96ff 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java +++ b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java @@ -20,7 +20,7 @@ import org.skriptlang.skript.lang.script.ScriptWarning; @Name("Projectile Critical State") -@Description("A projectile's critical state. The only currently accepted projectiles are arrows and tridents.") +@Description("A projectile's critical state. The only currently accepted projectiles are arrows and tridents. This expression is deprecated and will be removed in a future version. Use the Projectile Critical State effect instead.") @Example(""" on shoot: event-projectile is an arrow @@ -38,7 +38,7 @@ public class ExprProjectileCriticalState extends SimplePropertyExpression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the projectile critical state effect instead: 'make %projectiles% crit'"); + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the projectile critical state effect instead: 'make %projectiles% crit'"); return super.init(expressions, matchedPattern, isDelayed, parseResult); } From 23ee71292cfa336a9dfc2311b7110e41a8b50449 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 9 Jun 2026 23:44:50 -0700 Subject: [PATCH 32/43] Apply suggestions from code review Co-authored-by: SirSmurfy2 <82696841+Absolutionism@users.noreply.github.com> --- .../skript/bukkit/entity/elements/conditions/CondGravity.java | 4 ++-- .../skript/bukkit/entity/elements/effects/EffGravity.java | 2 +- .../entity/elements/effects/EffProjectileCriticalState.java | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java index 8a97a8dfeb8..e2634a1bef5 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java @@ -42,7 +42,7 @@ public static void register(SyntaxRegistry registry) { private Expression entities; @Override - public boolean init(final Expression[] exprs, final int matchedPattern, final Kleenean isDelayed, final ParseResult parseResult) { + public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) exprs[0]; setNegated(matchedPattern % 2 == 1); @@ -55,7 +55,7 @@ public boolean check(Event event) { } @Override - public String toString(final @Nullable Event event, final boolean debug) { + public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) .append(entities) .appendIf(isNegated(), "do not") diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index 04fd4726e8d..3cb283c4c50 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -30,7 +30,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffGravity.class) .addPatterns( - "(enable|:disable) gravity (of|for) %entities%", + "(enable|:disable) [the] gravity (of|for) %entities%", "(enable|:disable) %entities%'s gravity" ) .supplier(EffGravity::new) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index 0e91e32e413..20514b4cb09 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -29,7 +29,7 @@ make event-projectile crit """) @Since("INSERT VERSION") -public class EffProjectileCriticalState extends Effect implements RuntimeErrorProducer { +public class EffProjectileCriticalState extends Effect { public static void register(SyntaxRegistry registry) { registry.register( From 204addcebaf391974cbb67df473deb507e9a8c53 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Tue, 9 Jun 2026 23:49:41 -0700 Subject: [PATCH 33/43] add [the] to syntax --- .../skriptlang/skript/bukkit/entity/elements/effects/EffAI.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java index b89fd4b5f75..b819beb7ece 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -33,7 +33,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffAI.class) .addPatterns( - "(enable|:disable) (ai|artificial intelligence) (of|for) %livingentities%", + "(enable|:disable) [the] (ai|artificial intelligence) (of|for) %livingentities%", "(enable|:disable) %livingentities%'s (ai|artificial intelligence)" ) .supplier(EffAI::new) From 5cd15ee436e2f5836eaf7ca44e6b5a5462b3fbf3 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sun, 14 Jun 2026 20:43:42 -0700 Subject: [PATCH 34/43] Use the user's input to make a working example in the deprecation message --- src/main/java/ch/njol/skript/expressions/ExprAI.java | 6 +++--- .../java/ch/njol/skript/expressions/ExprFlightMode.java | 6 +++--- src/main/java/ch/njol/skript/expressions/ExprGlowing.java | 6 +++--- src/main/java/ch/njol/skript/expressions/ExprGravity.java | 6 +++--- .../skript/expressions/ExprProjectileCriticalState.java | 6 +++--- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/main/java/ch/njol/skript/expressions/ExprAI.java b/src/main/java/ch/njol/skript/expressions/ExprAI.java index 218a5e97021..4c17c020dad 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprAI.java +++ b/src/main/java/ch/njol/skript/expressions/ExprAI.java @@ -1,7 +1,7 @@ package ch.njol.skript.expressions; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.Kleenean; import org.bukkit.entity.LivingEntity; import org.bukkit.event.Event; @@ -28,8 +28,8 @@ public class ExprAI extends SimplePropertyExpression { } @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the AI effect instead: 'enable ai for %livingentities%'."); + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the AI effect instead: 'enable ai for " + expressions[0].toString(null, false) + "'."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java index 04e7db68bad..4f0a1d49092 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java +++ b/src/main/java/ch/njol/skript/expressions/ExprFlightMode.java @@ -7,7 +7,7 @@ import ch.njol.skript.doc.Since; import ch.njol.skript.expressions.base.SimplePropertyExpression; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Player; @@ -28,8 +28,8 @@ public class ExprFlightMode extends SimplePropertyExpression { } @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the Make Fly effect instead: 'make %players% fly'"); + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the Make Fly effect instead: 'make " + expressions[0].toString(null, false) + " fly'."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java index 412cdd17ed8..7377eeeabc3 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java @@ -1,7 +1,7 @@ package ch.njol.skript.expressions; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.Kleenean; import org.bukkit.entity.Entity; import org.bukkit.event.Event; @@ -27,8 +27,8 @@ public class ExprGlowing extends SimplePropertyExpression { } @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the glowing effect instead: 'make %entities% glow'"); + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the glowing effect instead: 'make " + expressions[0].toString(null, false) + " glow'."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index 20819ef98ee..be75626bce9 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -1,7 +1,7 @@ package ch.njol.skript.expressions; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.Kleenean; import org.bukkit.entity.Entity; import org.bukkit.event.Event; @@ -27,8 +27,8 @@ public class ExprGravity extends SimplePropertyExpression { } @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the gravity effect instead: 'enable gravity of %entities%'"); + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the gravity effect instead: 'enable gravity of " + expressions[0].toString(null, false) + "'."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } diff --git a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java index 952363d96ff..fb4c4ffcf29 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java +++ b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java @@ -1,7 +1,7 @@ package ch.njol.skript.expressions; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.Kleenean; import org.bukkit.entity.AbstractArrow; import org.bukkit.entity.Arrow; @@ -37,8 +37,8 @@ public class ExprProjectileCriticalState extends SimplePropertyExpression[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the projectile critical state effect instead: 'make %projectiles% crit'"); + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + ScriptWarning.printDeprecationWarning("This expression is deprecated and will be removed in a future version. Use the projectile critical state effect instead: 'make " + expressions[0].toString(null, false) + " crit'."); return super.init(expressions, matchedPattern, isDelayed, parseResult); } From 54d2dcf768fb43f96eaba48c56072dde6dbe682a Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sun, 14 Jun 2026 21:07:13 -0700 Subject: [PATCH 35/43] Use property condition --- .../elements/conditions/CondGravity.java | 35 ++++++++----------- 1 file changed, 14 insertions(+), 21 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java index e2634a1bef5..4604128af72 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondGravity.java @@ -1,18 +1,14 @@ package org.skriptlang.skript.bukkit.entity.elements.conditions; +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.Since; -import ch.njol.skript.lang.Condition; 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 org.bukkit.entity.Entity; -import org.bukkit.event.Event; -import org.jetbrains.annotations.Nullable; -import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Experiences Gravity") @@ -22,45 +18,42 @@ ) @Example("send whether player experiences gravity") @Since("INSERT VERSION") -public class CondGravity extends Condition { +public class CondGravity extends PropertyCondition { public static void register(SyntaxRegistry registry) { registry.register( SyntaxRegistry.CONDITION, - SyntaxInfo.builder(CondGravity.class) + infoBuilder( + CondGravity.class, + PropertyType.BE, + "affected by gravity", + "entities" + ) .addPatterns( "%entities% experience[s] gravity", - "%entities% (doesn't|does not|do not|don't) experience gravity", - "%entities% (is|are) affected by gravity", - "%entities% (isn't|is not|aren't|are not) affected by gravity" + "%entities% (doesn't|does not|do not|don't) experience gravity" ) .supplier(CondGravity::new) .build() ); } - private Expression entities; - @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked - entities = (Expression) exprs[0]; + setExpr((Expression) exprs[0]); setNegated(matchedPattern % 2 == 1); return true; } @Override - public boolean check(Event event) { - return entities.check(event, Entity::hasGravity, isNegated()); + public boolean check(Entity entity) { + return entity.hasGravity(); } @Override - public String toString(@Nullable Event event, boolean debug) { - return new SyntaxStringBuilder(event, debug) - .append(entities) - .appendIf(isNegated(), "do not") - .append("experience gravity") - .toString(); + protected String getPropertyName() { + return "affected by gravity"; } } From 9e3a154f586a2f2b184e71864d4dfa5f7f29f9ba Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sun, 14 Jun 2026 21:08:16 -0700 Subject: [PATCH 36/43] Make toString match the pattern --- .../entity/elements/conditions/CondProjectileIsCritical.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index e32ac6a1b08..c0eda5aaffc 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -47,7 +47,7 @@ public boolean check(Projectile projectile) { } protected String getPropertyName() { - return "projectile critical state"; + return "critical"; } } From 006f24ff5509291e2a9e53715b451c8b50dfdfa5 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sun, 14 Jun 2026 21:12:30 -0700 Subject: [PATCH 37/43] Move tests to their own module --- .../skript/tests/{syntaxes/effects => bukkit/entity}/EffAi.sk | 0 .../tests/{syntaxes/effects => bukkit/entity}/EffGlowing.sk | 0 .../tests/{syntaxes/effects => bukkit/entity}/EffGravity.sk | 0 .../effects => bukkit/entity}/EffProjectileCriticalState.sk | 0 4 files changed, 0 insertions(+), 0 deletions(-) rename src/test/skript/tests/{syntaxes/effects => bukkit/entity}/EffAi.sk (100%) rename src/test/skript/tests/{syntaxes/effects => bukkit/entity}/EffGlowing.sk (100%) rename src/test/skript/tests/{syntaxes/effects => bukkit/entity}/EffGravity.sk (100%) rename src/test/skript/tests/{syntaxes/effects => bukkit/entity}/EffProjectileCriticalState.sk (100%) diff --git a/src/test/skript/tests/syntaxes/effects/EffAi.sk b/src/test/skript/tests/bukkit/entity/EffAi.sk similarity index 100% rename from src/test/skript/tests/syntaxes/effects/EffAi.sk rename to src/test/skript/tests/bukkit/entity/EffAi.sk diff --git a/src/test/skript/tests/syntaxes/effects/EffGlowing.sk b/src/test/skript/tests/bukkit/entity/EffGlowing.sk similarity index 100% rename from src/test/skript/tests/syntaxes/effects/EffGlowing.sk rename to src/test/skript/tests/bukkit/entity/EffGlowing.sk diff --git a/src/test/skript/tests/syntaxes/effects/EffGravity.sk b/src/test/skript/tests/bukkit/entity/EffGravity.sk similarity index 100% rename from src/test/skript/tests/syntaxes/effects/EffGravity.sk rename to src/test/skript/tests/bukkit/entity/EffGravity.sk diff --git a/src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk b/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk similarity index 100% rename from src/test/skript/tests/syntaxes/effects/EffProjectileCriticalState.sk rename to src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk From 468dd763a755bef82e174f5b093c07f1db8888cf Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sun, 14 Jun 2026 22:34:47 -0700 Subject: [PATCH 38/43] Add toggle mode to syntax --- .../skript/bukkit/entity/elements/effects/EffAI.java | 12 ++++++++---- .../bukkit/entity/elements/effects/EffGravity.java | 12 ++++++++---- src/test/skript/tests/bukkit/entity/EffAi.sk | 8 ++++++++ src/test/skript/tests/bukkit/entity/EffGravity.sk | 8 ++++++++ 4 files changed, 32 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java index b819beb7ece..2eb6043bd44 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -25,6 +25,7 @@ ) @Example("enable artificial intelligence of target entity") @Example("disable ai of last spawned entity") +@Example("toggle target entity's ai") @Since("INSERT VERSION") public class EffAI extends Effect { @@ -33,8 +34,8 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffAI.class) .addPatterns( - "(enable|:disable) [the] (ai|artificial intelligence) (of|for) %livingentities%", - "(enable|:disable) %livingentities%'s (ai|artificial intelligence)" + "(enable|:disable|:toggle) [the] (ai|artificial intelligence) (of|for) %livingentities%", + "(enable|:disable|:toggle) %livingentities%'s (ai|artificial intelligence)" ) .supplier(EffAI::new) .build() @@ -43,26 +44,29 @@ public static void register(SyntaxRegistry registry) { private Expression entities; private boolean negated; + private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); + toggle = parseResult.hasTag("toggle"); return true; } @Override protected void execute(Event event) { for (LivingEntity entity : entities.getArray(event)) { - entity.setAI(!negated); + entity.setAI(toggle ? !entity.hasAI() : !negated); } } @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .append(negated ? "disable" : "enable") + .appendIf(toggle, "toggle") + .appendIf(!toggle, negated ? "disable" : "enable") .append("ai of", entities) .toString(); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index 3cb283c4c50..65d191bf8e8 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -22,6 +22,7 @@ ) @Example("enable gravity of target entity") @Example("disable last spawned entity's gravity") +@Example("toggle target entity's gravity") @Since("INSERT VERSION") public class EffGravity extends Effect { @@ -30,8 +31,8 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffGravity.class) .addPatterns( - "(enable|:disable) [the] gravity (of|for) %entities%", - "(enable|:disable) %entities%'s gravity" + "(enable|:disable|:toggle) [the] gravity (of|for) %entities%", + "(enable|:disable|:toggle) %entities%'s gravity" ) .supplier(EffGravity::new) .build() @@ -40,26 +41,29 @@ public static void register(SyntaxRegistry registry) { private Expression entities; private boolean negated; + private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); + toggle = parseResult.hasTag("toggle"); return true; } @Override protected void execute(Event event) { for (Entity entity : entities.getArray(event)) { - entity.setGravity(!negated); + entity.setGravity(toggle ? !entity.hasGravity() : !negated); } } @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .append(negated ? "disable" : "enable") + .appendIf(toggle, "toggle") + .appendIf(!toggle, negated ? "disable" : "enable") .append("gravity of", entities) .toString(); } diff --git a/src/test/skript/tests/bukkit/entity/EffAi.sk b/src/test/skript/tests/bukkit/entity/EffAi.sk index 4222dfcadf9..18441b5c9a1 100644 --- a/src/test/skript/tests/bukkit/entity/EffAi.sk +++ b/src/test/skript/tests/bukkit/entity/EffAi.sk @@ -5,6 +5,10 @@ test "Entity AI Effect": assert entity doesn't have ai with "Failed to disable ai of pig" enable artificial intelligence of entity assert entity has ai with "Failed to enable ai of pig" + toggle ai of entity + assert entity doesn't have ai with "Failed to toggle ai of pig to false" + toggle entity's ai + assert entity has ai with "Failed to toggle ai of pig to true" delete entity test "Entity AI Effect with multiple entities": @@ -16,4 +20,8 @@ test "Entity AI Effect with multiple entities": assert {_pigs::*} don't have ai with "Failed to disable ai of 2 pigs" enable artificial intelligence of {_pigs::*} assert {_pigs::*} have ai with "Failed to enable ai of 2 pigs" + toggle ai of {_pigs::*} + assert {_pigs::*} don't have ai with "Failed to toggle ai of 2 pigs to false" + toggle {_pigs::*}'s ai + assert {_pigs::*} have ai with "Failed to toggle ai of 2 pigs to true" delete entities within {_pigs::*} diff --git a/src/test/skript/tests/bukkit/entity/EffGravity.sk b/src/test/skript/tests/bukkit/entity/EffGravity.sk index f2fed93ee7c..04ec89e80ca 100644 --- a/src/test/skript/tests/bukkit/entity/EffGravity.sk +++ b/src/test/skript/tests/bukkit/entity/EffGravity.sk @@ -5,6 +5,10 @@ test "Entity Gravity Effect": assert entity doesn't experience gravity with "Failed to disable gravity of pig" enable gravity of entity assert entity is affected by gravity with "Failed to enable gravity of pig" + toggle gravity of entity + assert entity isn't affected by gravity with "Failed to toggle gravity of pig to false" + toggle entity's gravity + assert entity experiences gravity with "Failed to toggle gravity of pig to true" delete entity test "Entity Gravity Effect with multiple entities": @@ -16,4 +20,8 @@ test "Entity Gravity Effect with multiple entities": assert {_pigs::*} aren't affected by gravity with "Failed to disable gravity of 2 pigs" enable {_pigs::*}'s gravity assert {_pigs::*} are affected by gravity with "Failed to enable gravity of 2 pigs" + toggle gravity of {_pigs::*} + assert {_pigs::*} don't experience gravity with "Failed to toggle gravity of 2 pigs to false" + toggle {_pigs::*}'s gravity + assert {_pigs::*} experience gravity with "Failed to toggle gravity of 2 pigs to true" delete entities within {_pigs::*} From 5e02e59e7ae0853153815e1b7a0855b67678f511 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Mon, 15 Jun 2026 11:56:30 -0700 Subject: [PATCH 39/43] Add toggle mode to syntax --- .../conditions/CondProjectileIsCritical.java | 2 +- .../entity/elements/effects/EffGlowing.java | 14 ++++++++++++-- .../effects/EffProjectileCriticalState.java | 15 ++++++++++++--- .../skript/tests/bukkit/entity/EffGlowing.sk | 16 ++++++++++++++++ .../bukkit/entity/EffProjectileCriticalState.sk | 16 ++++++++++++++++ 5 files changed, 57 insertions(+), 6 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index c0eda5aaffc..a36c5647a56 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -29,7 +29,7 @@ public static void register(SyntaxRegistry registry) { infoBuilder( CondProjectileIsCritical.class, PropertyType.WILL, - "crit[ical]", + "[be] crit[ical]", "projectiles" ) .supplier(CondProjectileIsCritical::new) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java index d0d56e764f5..94dd179c801 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -23,6 +23,7 @@ ) @Example("make target entity glow") @Example("make player stop glowing") +@Example("toggle whether {_mobs::*} are glowing") @Since("INSERT VERSION") public class EffGlowing extends Effect { @@ -33,7 +34,8 @@ public static void register(SyntaxRegistry registry) { .addPatterns( "make %entities% [negate:not] glow", "make %entities% (negate:stop|start) glowing", - "stop %entities% from glowing" + "stop %entities% from glowing", + "toggle whether %entities% (is|are) glowing" ) .supplier(EffGlowing::new) .build() @@ -42,24 +44,32 @@ public static void register(SyntaxRegistry registry) { private Expression entities; private boolean negated; + private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = (parseResult.hasTag("negate") || matchedPattern == 2); + toggle = matchedPattern == 3; return true; } @Override protected void execute(Event event) { for (Entity entity : entities.getArray(event)) { - entity.setGlowing(!negated); + entity.setGlowing(toggle ? !entity.isGlowing() : !negated); } } @Override public String toString(@Nullable Event event, boolean debug) { + if (toggle) { + return new SyntaxStringBuilder(event, debug) + .append("toggle whether", entities, "is glowing") + .toString(); + } + return new SyntaxStringBuilder(event, debug) .append("make", entities) .appendIf(negated, "not") diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index 20514b4cb09..cb1df9f3fc4 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -14,7 +14,6 @@ import org.bukkit.entity.Projectile; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; -import org.skriptlang.skript.log.runtime.RuntimeErrorProducer; import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; @@ -27,6 +26,7 @@ @Example(""" on shoot: make event-projectile crit + toggle whether event-projectile will be critical """) @Since("INSERT VERSION") public class EffProjectileCriticalState extends Effect { @@ -36,7 +36,8 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffProjectileCriticalState.class) .addPatterns( - "make %projectiles% [negate:not] crit[ical]" + "make %projectiles% [negate:not] crit[ical]", + "toggle whether %projectiles% will [be] crit[ical]" ) .supplier(EffProjectileCriticalState::new) .build() @@ -45,12 +46,14 @@ public static void register(SyntaxRegistry registry) { private Expression projectiles; private boolean negated; + private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked projectiles = (Expression) expressions[0]; negated = parseResult.hasTag("negate"); + toggle = matchedPattern == 1; return true; } @@ -58,7 +61,7 @@ public boolean init(Expression[] expressions, int matchedPattern, Kleenean is protected void execute(Event event) { for (Projectile projectile : projectiles.getArray(event)) { if (projectile instanceof AbstractArrow abstractArrow) { - abstractArrow.setCritical(!negated); + abstractArrow.setCritical(toggle ? !abstractArrow.isCritical() : !negated); } else { warning("This projectile (" + EntityData.toString(projectile) + ") is not supported. This only applies to arrows and tridents."); } @@ -67,6 +70,12 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { + if (toggle) { + return new SyntaxStringBuilder(event, debug) + .append("toggle whether", projectiles, "will crit") + .toString(); + } + return new SyntaxStringBuilder(event, debug) .append("make", projectiles) .appendIf(negated, "not") diff --git a/src/test/skript/tests/bukkit/entity/EffGlowing.sk b/src/test/skript/tests/bukkit/entity/EffGlowing.sk index daf308c9501..010662e03f6 100644 --- a/src/test/skript/tests/bukkit/entity/EffGlowing.sk +++ b/src/test/skript/tests/bukkit/entity/EffGlowing.sk @@ -9,6 +9,10 @@ test "Entity Glowing": assert entity is glowing with "Failed to make pig glow" make entity not glow assert entity is not glowing with "Failed to make pig not glow" + toggle whether entity is glowing + assert entity is glowing with "Failed to toggle glowing of pig to true" + toggle whether entity is glowing + assert entity isn't glowing with "Failed to toggle glowing of pig to false" delete entity spawn dropped apple at test-location: @@ -21,6 +25,10 @@ test "Entity Glowing": assert entity is glowing with "Failed to make dropped item glow" make entity not glow assert entity is not glowing with "Failed to make dropped item not glow" + toggle whether entity is glowing + assert entity is glowing with "Failed to toggle glowing of dropped item to true" + toggle whether entity is glowing + assert entity isn't glowing with "Failed to toggle glowing of dropped item to false" delete entity test "Entity Glowing for multiple entities": @@ -36,6 +44,10 @@ test "Entity Glowing for multiple entities": assert {_pigs::*} are glowing with "Failed to make 2 pigs glow" make {_pigs::*} not glow assert {_pigs::*} are not glowing with "Failed to make 2 pigs not glow" + toggle whether {_pigs::*} are glowing + assert {_pigs::*} are glowing with "Failed to toggle glowing of 2 pigs to true" + toggle whether {_pigs::*} are glowing + assert {_pigs::*} aren't glowing with "Failed to toggle glowing of 2 pigs to false" delete entities within {_pigs::*} spawn 2 dropped apples at test-location: @@ -50,4 +62,8 @@ test "Entity Glowing for multiple entities": assert {_dropped items::*} is glowing with "Failed to make 2 dropped items glow" make {_dropped items::*} not glow assert {_dropped items::*} is not glowing with "Failed to make 2 dropped items not glow" + toggle whether {_dropped items::*} are glowing + assert {_dropped items::*} are glowing with "Failed to toggle glowing of 2 dropped items to true" + toggle whether {_dropped items::*} are glowing + assert {_dropped items::*} aren't glowing with "Failed to toggle glowing of 2 dropped items to false" delete entities within {_dropped items::*} diff --git a/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk b/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk index 0644e145956..bd73ede9f40 100644 --- a/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk +++ b/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk @@ -7,6 +7,10 @@ test "Projectile Critical State Effect": assert event-projectile will crit with "Failed to make arrow crit" make event-projectile not crit assert event-projectile won't crit with "Failed to make the arrow not crit" + toggle whether event-projectile will crit + assert event-projectile will crit with "Failed to toggle crit of arrow to true" + toggle whether event-projectile will crit + assert event-projectile won't crit with "Failed to toggle crit of arrow to false" delete event-projectile shoot trident from test-location: @@ -15,6 +19,10 @@ test "Projectile Critical State Effect": assert event-projectile will crit with "Failed to make the trident crit" make event-projectile not crit assert event-projectile won't crit with "Failed to make the trident not crit" + toggle whether event-projectile will crit + assert event-projectile will crit with "Failed to toggle crit of trident to true" + toggle whether event-projectile will crit + assert event-projectile won't crit with "Failed to toggle crit of trident to false" delete event-projectile shoot snowball from test-location: @@ -32,6 +40,10 @@ test "Projectile Critical State Effect with multiple projectiles": assert {_arrows::*} will crit with "Failed to make the 2 arrows crit" make {_arrows::*} not crit assert {_arrows::*} won't crit with "Failed to make the 2 arrows not crit" + toggle whether {_arrows::*} will crit + assert {_arrows::*} will crit with "Failed to toggle crit of 2 arrows to true" + toggle whether {_arrows::*} will crit + assert {_arrows::*} won't crit with "Failed to toggle crit of 2 arrows to false" delete {_arrows::*} shoot trident and trident from test-location: @@ -42,4 +54,8 @@ test "Projectile Critical State Effect with multiple projectiles": assert {_tridents::*} will crit with "Failed to make the 2 tridents crit" make {_tridents::*} not crit assert {_tridents::*} won't crit with "Failed to make the 2 tridents not crit" + toggle whether {_tridents::*} will crit + assert {_tridents::*} will crit with "Failed to toggle crit of 2 tridents to true" + toggle whether {_tridents::*} will crit + assert {_tridents::*} won't crit with "Failed to toggle crit of 2 tridents to false" delete {_tridents::*} From abb4db08690845cfb73f3595360eb5b3b905e738 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Mon, 22 Jun 2026 17:16:02 -0700 Subject: [PATCH 40/43] Remove toggle syntax since this will be handled by whether --- .../bukkit/entity/elements/effects/EffAI.java | 12 ++++-------- .../entity/elements/effects/EffGlowing.java | 14 ++------------ .../entity/elements/effects/EffGravity.java | 12 ++++-------- .../effects/EffProjectileCriticalState.java | 14 ++------------ src/test/skript/tests/bukkit/entity/EffAi.sk | 8 -------- .../skript/tests/bukkit/entity/EffGlowing.sk | 16 ---------------- .../skript/tests/bukkit/entity/EffGravity.sk | 8 -------- .../bukkit/entity/EffProjectileCriticalState.sk | 16 ---------------- 8 files changed, 12 insertions(+), 88 deletions(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java index 2eb6043bd44..b819beb7ece 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -25,7 +25,6 @@ ) @Example("enable artificial intelligence of target entity") @Example("disable ai of last spawned entity") -@Example("toggle target entity's ai") @Since("INSERT VERSION") public class EffAI extends Effect { @@ -34,8 +33,8 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffAI.class) .addPatterns( - "(enable|:disable|:toggle) [the] (ai|artificial intelligence) (of|for) %livingentities%", - "(enable|:disable|:toggle) %livingentities%'s (ai|artificial intelligence)" + "(enable|:disable) [the] (ai|artificial intelligence) (of|for) %livingentities%", + "(enable|:disable) %livingentities%'s (ai|artificial intelligence)" ) .supplier(EffAI::new) .build() @@ -44,29 +43,26 @@ public static void register(SyntaxRegistry registry) { private Expression entities; private boolean negated; - private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); - toggle = parseResult.hasTag("toggle"); return true; } @Override protected void execute(Event event) { for (LivingEntity entity : entities.getArray(event)) { - entity.setAI(toggle ? !entity.hasAI() : !negated); + entity.setAI(!negated); } } @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .appendIf(toggle, "toggle") - .appendIf(!toggle, negated ? "disable" : "enable") + .append(negated ? "disable" : "enable") .append("ai of", entities) .toString(); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java index 94dd179c801..d0d56e764f5 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -23,7 +23,6 @@ ) @Example("make target entity glow") @Example("make player stop glowing") -@Example("toggle whether {_mobs::*} are glowing") @Since("INSERT VERSION") public class EffGlowing extends Effect { @@ -34,8 +33,7 @@ public static void register(SyntaxRegistry registry) { .addPatterns( "make %entities% [negate:not] glow", "make %entities% (negate:stop|start) glowing", - "stop %entities% from glowing", - "toggle whether %entities% (is|are) glowing" + "stop %entities% from glowing" ) .supplier(EffGlowing::new) .build() @@ -44,32 +42,24 @@ public static void register(SyntaxRegistry registry) { private Expression entities; private boolean negated; - private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = (parseResult.hasTag("negate") || matchedPattern == 2); - toggle = matchedPattern == 3; return true; } @Override protected void execute(Event event) { for (Entity entity : entities.getArray(event)) { - entity.setGlowing(toggle ? !entity.isGlowing() : !negated); + entity.setGlowing(!negated); } } @Override public String toString(@Nullable Event event, boolean debug) { - if (toggle) { - return new SyntaxStringBuilder(event, debug) - .append("toggle whether", entities, "is glowing") - .toString(); - } - return new SyntaxStringBuilder(event, debug) .append("make", entities) .appendIf(negated, "not") diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java index 65d191bf8e8..3cb283c4c50 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -22,7 +22,6 @@ ) @Example("enable gravity of target entity") @Example("disable last spawned entity's gravity") -@Example("toggle target entity's gravity") @Since("INSERT VERSION") public class EffGravity extends Effect { @@ -31,8 +30,8 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffGravity.class) .addPatterns( - "(enable|:disable|:toggle) [the] gravity (of|for) %entities%", - "(enable|:disable|:toggle) %entities%'s gravity" + "(enable|:disable) [the] gravity (of|for) %entities%", + "(enable|:disable) %entities%'s gravity" ) .supplier(EffGravity::new) .build() @@ -41,29 +40,26 @@ public static void register(SyntaxRegistry registry) { private Expression entities; private boolean negated; - private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked entities = (Expression) expressions[0]; negated = parseResult.hasTag("disable"); - toggle = parseResult.hasTag("toggle"); return true; } @Override protected void execute(Event event) { for (Entity entity : entities.getArray(event)) { - entity.setGravity(toggle ? !entity.hasGravity() : !negated); + entity.setGravity(!negated); } } @Override public String toString(@Nullable Event event, boolean debug) { return new SyntaxStringBuilder(event, debug) - .appendIf(toggle, "toggle") - .appendIf(!toggle, negated ? "disable" : "enable") + .append(negated ? "disable" : "enable") .append("gravity of", entities) .toString(); } diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java index cb1df9f3fc4..7c158239248 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -26,7 +26,6 @@ @Example(""" on shoot: make event-projectile crit - toggle whether event-projectile will be critical """) @Since("INSERT VERSION") public class EffProjectileCriticalState extends Effect { @@ -36,8 +35,7 @@ public static void register(SyntaxRegistry registry) { SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffProjectileCriticalState.class) .addPatterns( - "make %projectiles% [negate:not] crit[ical]", - "toggle whether %projectiles% will [be] crit[ical]" + "make %projectiles% [negate:not] crit[ical]" ) .supplier(EffProjectileCriticalState::new) .build() @@ -46,14 +44,12 @@ public static void register(SyntaxRegistry registry) { private Expression projectiles; private boolean negated; - private boolean toggle; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { //noinspection unchecked projectiles = (Expression) expressions[0]; negated = parseResult.hasTag("negate"); - toggle = matchedPattern == 1; return true; } @@ -61,7 +57,7 @@ public boolean init(Expression[] expressions, int matchedPattern, Kleenean is protected void execute(Event event) { for (Projectile projectile : projectiles.getArray(event)) { if (projectile instanceof AbstractArrow abstractArrow) { - abstractArrow.setCritical(toggle ? !abstractArrow.isCritical() : !negated); + abstractArrow.setCritical(!negated); } else { warning("This projectile (" + EntityData.toString(projectile) + ") is not supported. This only applies to arrows and tridents."); } @@ -70,12 +66,6 @@ protected void execute(Event event) { @Override public String toString(@Nullable Event event, boolean debug) { - if (toggle) { - return new SyntaxStringBuilder(event, debug) - .append("toggle whether", projectiles, "will crit") - .toString(); - } - return new SyntaxStringBuilder(event, debug) .append("make", projectiles) .appendIf(negated, "not") diff --git a/src/test/skript/tests/bukkit/entity/EffAi.sk b/src/test/skript/tests/bukkit/entity/EffAi.sk index 18441b5c9a1..4222dfcadf9 100644 --- a/src/test/skript/tests/bukkit/entity/EffAi.sk +++ b/src/test/skript/tests/bukkit/entity/EffAi.sk @@ -5,10 +5,6 @@ test "Entity AI Effect": assert entity doesn't have ai with "Failed to disable ai of pig" enable artificial intelligence of entity assert entity has ai with "Failed to enable ai of pig" - toggle ai of entity - assert entity doesn't have ai with "Failed to toggle ai of pig to false" - toggle entity's ai - assert entity has ai with "Failed to toggle ai of pig to true" delete entity test "Entity AI Effect with multiple entities": @@ -20,8 +16,4 @@ test "Entity AI Effect with multiple entities": assert {_pigs::*} don't have ai with "Failed to disable ai of 2 pigs" enable artificial intelligence of {_pigs::*} assert {_pigs::*} have ai with "Failed to enable ai of 2 pigs" - toggle ai of {_pigs::*} - assert {_pigs::*} don't have ai with "Failed to toggle ai of 2 pigs to false" - toggle {_pigs::*}'s ai - assert {_pigs::*} have ai with "Failed to toggle ai of 2 pigs to true" delete entities within {_pigs::*} diff --git a/src/test/skript/tests/bukkit/entity/EffGlowing.sk b/src/test/skript/tests/bukkit/entity/EffGlowing.sk index 010662e03f6..daf308c9501 100644 --- a/src/test/skript/tests/bukkit/entity/EffGlowing.sk +++ b/src/test/skript/tests/bukkit/entity/EffGlowing.sk @@ -9,10 +9,6 @@ test "Entity Glowing": assert entity is glowing with "Failed to make pig glow" make entity not glow assert entity is not glowing with "Failed to make pig not glow" - toggle whether entity is glowing - assert entity is glowing with "Failed to toggle glowing of pig to true" - toggle whether entity is glowing - assert entity isn't glowing with "Failed to toggle glowing of pig to false" delete entity spawn dropped apple at test-location: @@ -25,10 +21,6 @@ test "Entity Glowing": assert entity is glowing with "Failed to make dropped item glow" make entity not glow assert entity is not glowing with "Failed to make dropped item not glow" - toggle whether entity is glowing - assert entity is glowing with "Failed to toggle glowing of dropped item to true" - toggle whether entity is glowing - assert entity isn't glowing with "Failed to toggle glowing of dropped item to false" delete entity test "Entity Glowing for multiple entities": @@ -44,10 +36,6 @@ test "Entity Glowing for multiple entities": assert {_pigs::*} are glowing with "Failed to make 2 pigs glow" make {_pigs::*} not glow assert {_pigs::*} are not glowing with "Failed to make 2 pigs not glow" - toggle whether {_pigs::*} are glowing - assert {_pigs::*} are glowing with "Failed to toggle glowing of 2 pigs to true" - toggle whether {_pigs::*} are glowing - assert {_pigs::*} aren't glowing with "Failed to toggle glowing of 2 pigs to false" delete entities within {_pigs::*} spawn 2 dropped apples at test-location: @@ -62,8 +50,4 @@ test "Entity Glowing for multiple entities": assert {_dropped items::*} is glowing with "Failed to make 2 dropped items glow" make {_dropped items::*} not glow assert {_dropped items::*} is not glowing with "Failed to make 2 dropped items not glow" - toggle whether {_dropped items::*} are glowing - assert {_dropped items::*} are glowing with "Failed to toggle glowing of 2 dropped items to true" - toggle whether {_dropped items::*} are glowing - assert {_dropped items::*} aren't glowing with "Failed to toggle glowing of 2 dropped items to false" delete entities within {_dropped items::*} diff --git a/src/test/skript/tests/bukkit/entity/EffGravity.sk b/src/test/skript/tests/bukkit/entity/EffGravity.sk index 04ec89e80ca..f2fed93ee7c 100644 --- a/src/test/skript/tests/bukkit/entity/EffGravity.sk +++ b/src/test/skript/tests/bukkit/entity/EffGravity.sk @@ -5,10 +5,6 @@ test "Entity Gravity Effect": assert entity doesn't experience gravity with "Failed to disable gravity of pig" enable gravity of entity assert entity is affected by gravity with "Failed to enable gravity of pig" - toggle gravity of entity - assert entity isn't affected by gravity with "Failed to toggle gravity of pig to false" - toggle entity's gravity - assert entity experiences gravity with "Failed to toggle gravity of pig to true" delete entity test "Entity Gravity Effect with multiple entities": @@ -20,8 +16,4 @@ test "Entity Gravity Effect with multiple entities": assert {_pigs::*} aren't affected by gravity with "Failed to disable gravity of 2 pigs" enable {_pigs::*}'s gravity assert {_pigs::*} are affected by gravity with "Failed to enable gravity of 2 pigs" - toggle gravity of {_pigs::*} - assert {_pigs::*} don't experience gravity with "Failed to toggle gravity of 2 pigs to false" - toggle {_pigs::*}'s gravity - assert {_pigs::*} experience gravity with "Failed to toggle gravity of 2 pigs to true" delete entities within {_pigs::*} diff --git a/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk b/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk index bd73ede9f40..0644e145956 100644 --- a/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk +++ b/src/test/skript/tests/bukkit/entity/EffProjectileCriticalState.sk @@ -7,10 +7,6 @@ test "Projectile Critical State Effect": assert event-projectile will crit with "Failed to make arrow crit" make event-projectile not crit assert event-projectile won't crit with "Failed to make the arrow not crit" - toggle whether event-projectile will crit - assert event-projectile will crit with "Failed to toggle crit of arrow to true" - toggle whether event-projectile will crit - assert event-projectile won't crit with "Failed to toggle crit of arrow to false" delete event-projectile shoot trident from test-location: @@ -19,10 +15,6 @@ test "Projectile Critical State Effect": assert event-projectile will crit with "Failed to make the trident crit" make event-projectile not crit assert event-projectile won't crit with "Failed to make the trident not crit" - toggle whether event-projectile will crit - assert event-projectile will crit with "Failed to toggle crit of trident to true" - toggle whether event-projectile will crit - assert event-projectile won't crit with "Failed to toggle crit of trident to false" delete event-projectile shoot snowball from test-location: @@ -40,10 +32,6 @@ test "Projectile Critical State Effect with multiple projectiles": assert {_arrows::*} will crit with "Failed to make the 2 arrows crit" make {_arrows::*} not crit assert {_arrows::*} won't crit with "Failed to make the 2 arrows not crit" - toggle whether {_arrows::*} will crit - assert {_arrows::*} will crit with "Failed to toggle crit of 2 arrows to true" - toggle whether {_arrows::*} will crit - assert {_arrows::*} won't crit with "Failed to toggle crit of 2 arrows to false" delete {_arrows::*} shoot trident and trident from test-location: @@ -54,8 +42,4 @@ test "Projectile Critical State Effect with multiple projectiles": assert {_tridents::*} will crit with "Failed to make the 2 tridents crit" make {_tridents::*} not crit assert {_tridents::*} won't crit with "Failed to make the 2 tridents not crit" - toggle whether {_tridents::*} will crit - assert {_tridents::*} will crit with "Failed to toggle crit of 2 tridents to true" - toggle whether {_tridents::*} will crit - assert {_tridents::*} won't crit with "Failed to toggle crit of 2 tridents to false" delete {_tridents::*} From e788da9d20d916930a18f40984b58c84f9255f66 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Mon, 22 Jun 2026 17:16:35 -0700 Subject: [PATCH 41/43] Use isNegated() instead of a constant False --- .../entity/elements/conditions/CondProjectileIsCritical.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java index a36c5647a56..958cf088451 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -43,7 +43,7 @@ public boolean check(Projectile projectile) { return abstractArrow.isCritical(); } warning("This projectile (" + EntityData.toString(projectile) + ") is not supported. Critical projectile state only applies to arrows and tridents."); - return false; + return isNegated(); } protected String getPropertyName() { From bc58d2db9b736ee30cc93ac9af125e314af5b197 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 15 Aug 2026 10:40:29 -0700 Subject: [PATCH 42/43] Fix indentation --- .../java/org/skriptlang/skript/bukkit/entity/EntityModule.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java index ddece550bba..5a8de03b75a 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/EntityModule.java @@ -100,7 +100,7 @@ protected void loadSelf(SkriptAddon addon) { EffGlowing::register, EffGravity::register, EffProjectileCriticalState::register, - EffTeleport::register, + EffTeleport::register, ExprDeathMessage::register, ExprPathfindingLocation::register, From 5a561905e61cd5a6528ae2a9de96d3aa2ac36405 Mon Sep 17 00:00:00 2001 From: Phill310 Date: Sat, 15 Aug 2026 10:40:46 -0700 Subject: [PATCH 43/43] Fix example --- src/main/java/ch/njol/skript/expressions/ExprGravity.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index be75626bce9..417ec629052 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -17,7 +17,7 @@ @Name("Gravity") @Description("If entity is affected by gravity or not, i.e. if it has Minecraft 1.10+ NoGravity flag. This expression is deprecated and will be removed in a future version. Use the Entity Gravity effect instead.") -@Example("set gravity of player off") +@Example("set gravity of player to off") @Since("2.2-dev21") @Deprecated(since = "INSERT VERSION", forRemoval = true) public class ExprGravity extends SimplePropertyExpression {