diff --git a/src/main/java/ch/njol/skript/expressions/ExprAI.java b/src/main/java/ch/njol/skript/expressions/ExprAI.java index 33faceabbcb..636b46f6348 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprAI.java +++ b/src/main/java/ch/njol/skript/expressions/ExprAI.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.LivingEntity; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; @@ -11,16 +14,24 @@ 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.") @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) { + ScriptWarning.printDeprecationWarning("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/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(); diff --git a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java b/src/main/java/ch/njol/skript/expressions/ExprGlowing.java index 31770fcc7e7..d333e46f2c3 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGlowing.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGlowing.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; @@ -10,16 +13,24 @@ 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.") @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) { + ScriptWarning.printDeprecationWarning("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/ch/njol/skript/expressions/ExprGravity.java b/src/main/java/ch/njol/skript/expressions/ExprGravity.java index e71c4cbb408..72f5b3ddf24 100644 --- a/src/main/java/ch/njol/skript/expressions/ExprGravity.java +++ b/src/main/java/ch/njol/skript/expressions/ExprGravity.java @@ -1,26 +1,36 @@ 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; -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.") @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) { + ScriptWarning.printDeprecationWarning("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/ch/njol/skript/expressions/ExprProjectileCriticalState.java b/src/main/java/ch/njol/skript/expressions/ExprProjectileCriticalState.java index 806e36fb2e8..eabdcb78c0b 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; @@ -14,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.") @@ -23,6 +27,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 +35,12 @@ 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."); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } @Nullable @Override 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..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,13 @@ 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; +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 +45,15 @@ protected void loadSelf(SkriptAddon addon) { } register(addon, + CondHasGravity::register, + CondIsGlowing::register, + CondProjectileIsCritical::register, + + EffAI::register, + EffGlowing::register, + EffGravity::register, + EffProjectileCriticalState::register, + ExprDeathMessage::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"; + } + +} 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..00feb96d040 --- /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 an 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/conditions/CondProjectileIsCritical.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java new file mode 100644 index 00000000000..f61ec602810 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/conditions/CondProjectileIsCritical.java @@ -0,0 +1,62 @@ +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.SyntaxRegistry; + +@Name("Projectile Is Critical") +@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: + 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, + infoBuilder( + CondProjectileIsCritical.class, + PropertyType.BE, + "in (projectile|arrow) critical (state|mode)", + "projectiles" + ) + .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. Critical projectile state 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/EffAI.java b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java new file mode 100644 index 00000000000..1400955df82 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffAI.java @@ -0,0 +1,64 @@ +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|for) %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) + .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 new file mode 100644 index 00000000000..cf7221249e5 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGlowing.java @@ -0,0 +1,66 @@ +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.Entity; +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", + "stop %entities% from 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") || matchedPattern == 2); + return true; + } + + @Override + protected void execute(Event event) { + for (Entity 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(); + } + +} 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..e74d2963833 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffGravity.java @@ -0,0 +1,64 @@ +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.Entity; +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|for) %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 (Entity entity : entities.getArray(event)) { + entity.setGravity(!negated); + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return new SyntaxStringBuilder(event, debug) + .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 new file mode 100644 index 00000000000..ef8f7c836d6 --- /dev/null +++ b/src/main/java/org/skriptlang/skript/bukkit/entity/elements/effects/EffProjectileCriticalState.java @@ -0,0 +1,75 @@ +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.log.runtime.RuntimeErrorProducer; +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. 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 + """) +@Since("INSERT VERSION") +public class EffProjectileCriticalState extends Effect implements RuntimeErrorProducer { + + public static void register(SyntaxRegistry registry) { + registry.register( + 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)" + ) + .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); + } else { + warning("This projectile is not supported. This only applies to arrows and tridents."); + } + } + } + + @Override + public String toString(@Nullable Event event, boolean debug) { + return new SyntaxStringBuilder(event, debug) + .append(negated ? "disable" : "enable") + .append("projectile critical state", projectiles) + .toString(); + } + +} 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..eb644dd0d05 --- /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::*} 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..343b9dc4af2 --- /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::*}