diff --git a/src/main/java/ch/njol/skript/expressions/ExprCreeperMaxFuseTicks.java b/src/main/java/ch/njol/skript/expressions/ExprCreeperMaxFuseTicks.java deleted file mode 100644 index a14766b6341..00000000000 --- a/src/main/java/ch/njol/skript/expressions/ExprCreeperMaxFuseTicks.java +++ /dev/null @@ -1,84 +0,0 @@ -package ch.njol.skript.expressions; - -import org.bukkit.entity.Creeper; -import org.bukkit.entity.LivingEntity; -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 ch.njol.util.coll.CollectionUtils; - -@Name("Creeper Max Fuse Ticks") -@Description("The max fuse ticks that a creeper has.") -@Example("set target entity's max fuse ticks to 20 #1 second") -@Since("2.5") -public class ExprCreeperMaxFuseTicks extends SimplePropertyExpression { - - static { - if(Skript.methodExists(LivingEntity.class, "getMaxFuseTicks")) - register(ExprCreeperMaxFuseTicks.class, Long.class, "[creeper] max[imum] fuse tick[s]", "livingentities"); - } - - @Override - public Long convert(LivingEntity e) { - return e instanceof Creeper ? (long) ((Creeper) e).getMaxFuseTicks() : 0; - } - - @Override - @Nullable - public Class[] acceptChange(final ChangeMode mode) { - if (mode == ChangeMode.REMOVE_ALL) - return null; - return CollectionUtils.array(Number.class); - } - - @Override - public void change(final Event e, final @Nullable Object[] delta, final ChangeMode mode) { - int d = delta == null ? 0 : ((Number) delta[0]).intValue(); - for (LivingEntity le : getExpr().getArray(e)) { - if (le instanceof Creeper) { - Creeper c = (Creeper) le; - switch (mode) { - case ADD: - int r1 = c.getMaxFuseTicks() + d; - if (r1 < 0) r1 = 0; - c.setMaxFuseTicks(r1); - break; - case SET: - c.setMaxFuseTicks(d); - break; - case DELETE: - c.setMaxFuseTicks(0); - break; - case RESET: - c.setMaxFuseTicks(30); //Seems to be the same for powered creepers? - break; - case REMOVE: - int r2 = c.getMaxFuseTicks() - d; - if (r2 < 0) r2 = 0; - c.setMaxFuseTicks(r2); - break; - case REMOVE_ALL: - assert false; - } - } - } - } - - @Override - public Class getReturnType() { - return Long.class; - } - - @Override - protected String getPropertyName() { - return "creeper max fuse ticks"; - } - -} diff --git a/src/main/java/ch/njol/skript/expressions/ExprFuseTicks.java b/src/main/java/ch/njol/skript/expressions/ExprFuseTicks.java new file mode 100644 index 00000000000..4f08876da87 --- /dev/null +++ b/src/main/java/ch/njol/skript/expressions/ExprFuseTicks.java @@ -0,0 +1,117 @@ +package ch.njol.skript.expressions; + +import ch.njol.skript.classes.Changer.ChangeMode; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.expressions.base.SimplePropertyExpression; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Timespan; +import ch.njol.skript.util.Timespan.TimePeriod; +import ch.njol.util.Kleenean; +import ch.njol.util.coll.CollectionUtils; +import org.bukkit.entity.Entity; +import org.bukkit.entity.Creeper; +import org.bukkit.entity.TNTPrimed; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; + +@Name("Entity Fuse Duration") +@Description("Get or set how long until a Creeper/Primed TNT explodes. For Creepers, the fuse time will be 0 seconds and if set it will be ticking down even if the entity is not currently in exploding animation.") +@Example("send \"Run! That guy is going to explode in %fuse ticks of player's target%\"") +@Example("send the max fuse ticks of target") +@Since("INSERT VERSION") +public class ExprFuseTicks extends SimplePropertyExpression { + + static { + register(ExprFuseTicks.class, Timespan.class, "[:max[imum]] fuse (duration|length)", "entities"); + } + + private boolean max; + + @Override + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + max = (parseResult.hasTag("max")); + return super.init(expressions, matchedPattern, isDelayed, parseResult); + } + + @Override + public @Nullable Timespan convert(Entity entity) { + if (entity instanceof Creeper creeper) { + return new Timespan(TimePeriod.TICK, (max ? creeper.getMaxFuseTicks() : creeper.getFuseTicks())); + } + if (entity instanceof TNTPrimed tntprimed) { + return new Timespan(TimePeriod.TICK, tntprimed.getFuseTicks()); + } + return null; + } + + + @Override + public Class @Nullable [] acceptChange(ChangeMode mode) { + if (max) { + Skript.error("The maximum fuse length of an entity cannot be changed."); + return null; + } + return switch (mode) { + case ADD, SET, REMOVE -> CollectionUtils.array(Timespan.class); + case RESET, DELETE -> CollectionUtils.array(); + default -> null; + }; + } + + @Override + public void change(Event event, Object @Nullable [] delta, ChangeMode mode) { + Entity[] entities = getExpr().getArray(event); + int change = delta == null ? 0 : (int) ((Timespan) delta[0]).getAs(Timespan.TimePeriod.TICK); + switch (mode) { + case REMOVE: + change = -change; + + case ADD: + for (Entity entity : entities) + if (entity instanceof Creeper creeper) { + creeper.setFuseTicks(creeper.getFuseTicks() + change); + } else if (entity instanceof TNTPrimed tntprimed) { + tntprimed.setFuseTicks(tntprimed.getFuseTicks() + change); + } + + break; + case SET: + for (Entity entity : entities) + if (entity instanceof Creeper creeper) { + creeper.setMaxFuseTicks(change); + creeper.setFuseTicks(change); + } else if (entity instanceof TNTPrimed tntprimed) { + tntprimed.setFuseTicks(change); + } + break; + + case DELETE: + case RESET: + for (Entity entity : entities) + if (entity instanceof Creeper creeper) { + creeper.setFuseTicks(creeper.getMaxFuseTicks()); + } else if (entity instanceof TNTPrimed tntprimed) { + tntprimed.setFuseTicks(80); + } + + break; + default: + assert false; + } + } + + @Override + public Class getReturnType() { + return Timespan.class; + } + + @Override + protected String getPropertyName() { + return "fuse duration"; + } + +}