Merge branch 'dev/feature' into feature/simplification-2

Author: APickledWalrus

LICENSING.md

@@ -0,0 +1,48 @@
+Skript is licensed under the [GNU General Public License (Version 3)](LICENSE).
+
+However, to foster a better open-source community, and in the interest of further opening this project in the future,
+we ask that contributors release their code under the MIT License.
+Since it is less restrictive than GPLv3, it provides us and other developers
+with greater flexibility when making use of contributed code.
+
+To learn more about this license, you can visit [choosealicense.com](https://choosealicense.com/licenses/mit/).
+You can also view the full text of the license below:
+<details>
+<summary>MIT License</summary>
+
+```text
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+</details>
+
+If you wish to release your contributions to this repository under the MIT License,
+please add your name below in your pull request.
+
+When adding your name, please follow the example format below:
+
+`<name> (<commit email address>)`
+> [!NOTE]
+> For name, you may choose to use your real name or GitHub account name. \
+> If you use more than one commit email address, please include all of them.
+
+```text
+APickledWalrus (apickledwalrus@icloud.com, apickledwalrus@gmail.com)
+Sovde (10354869+sovdeeth@users.noreply.github.com)
+UnderscoreTud (98935832+UnderscoreTud@users.noreply.github.com)
+```

README.md

@@ -191,5 +191,6 @@ contact us about any problems you might have with them.
 ## Developers
 You can find all contributors [here](https://github.com/SkriptLang/Skript/graphs/contributors).
 
-All code is owned by its writer, licensed for others under GPLv3 (see LICENSE)
-unless otherwise specified.
+All code is owned by its writer, licensed for others under GPLv3 (see [LICENSE](LICENSE)).
+Some contributors may choose to release their code under the MIT License.
+Further information can be found within [LICENSING.md](LICENSING.md).

code-conventions.md

@@ -64,6 +64,8 @@ With the exception of contacting our own resources (e.g. to check for updates) c
 ## Licensing
 
 Code contributed must be licensed under GPLv3, by **you**.
+Some contributors may choose to release their code under the MIT License.
+Further information can be found within [LICENSING.md](LICENSING.md).
 We expect that any code you contribute is either owned by you or you have explicit permission to provide and license it to us.
 
 Licenses do not need to be printed in individual files (or packages) unless the licence applying to the code in

src/main/java/ch/njol/skript/classes/data/DefaultOperations.java

@@ -2,7 +2,6 @@
 
 import ch.njol.skript.util.Date;
 import ch.njol.skript.util.Timespan;
-import ch.njol.skript.util.Timespan.TimePeriod;
 import ch.njol.skript.util.Utils;
 import org.bukkit.util.Vector;
 import org.skriptlang.skript.lang.arithmetic.Arithmetics;
@@ -92,36 +91,30 @@ public class DefaultOperations {
 		// Timespan - Timespan
 		Arithmetics.registerOperation(Operator.ADDITION, Timespan.class, Timespan::add);
 		Arithmetics.registerOperation(Operator.SUBTRACTION, Timespan.class, Timespan::subtract);
+		Arithmetics.registerOperation(Operator.DIVISION, Timespan.class, Timespan.class, Number.class, Timespan::divide);
 		Arithmetics.registerDifference(Timespan.class, Timespan::difference);
 		Arithmetics.registerDefaultValue(Timespan.class, Timespan::new);
 
 		// Timespan - Number
 		// Number - Timespan
 		Arithmetics.registerOperation(Operator.MULTIPLICATION, Timespan.class, Number.class, (left, right) -> {
 			double scalar = right.doubleValue();
-			if (scalar < 0 || !Double.isFinite(scalar))
+			if (scalar < 0 || Double.isNaN(scalar))
 				return null;
-			double value = left.getAs(TimePeriod.MILLISECOND) * scalar;
-			return new Timespan((long) Math.min(value, Long.MAX_VALUE));
+			return left.multiply(scalar);
 		}, (left, right) -> {
 			double scalar = left.doubleValue();
-			if (scalar < 0 || !Double.isFinite(scalar))
+			if (scalar < 0 || Double.isNaN(scalar))
 				return null;
-			double value = right.getAs(TimePeriod.MILLISECOND) * scalar;
-			return new Timespan((long) Math.min(value, Long.MAX_VALUE));
+			return right.multiply(scalar);
 		});
 		Arithmetics.registerOperation(Operator.DIVISION, Timespan.class, Number.class, (left, right) -> {
 			double scalar = right.doubleValue();
-			if (scalar <= 0 || !Double.isFinite(scalar))
+			if (scalar < 0 || Double.isNaN(scalar))
 				return null;
-			double value = left.getAs(TimePeriod.MILLISECOND) / scalar;
-			return new Timespan((long) Math.min(value, Long.MAX_VALUE));
+			return left.divide(scalar);
 		});
 
-		// Timespan / Timespan = Number
-		Arithmetics.registerOperation(Operator.DIVISION, Timespan.class, Timespan.class, Number.class,
-				(left, right) -> left.getAs(TimePeriod.MILLISECOND) / (double) right.getAs(TimePeriod.MILLISECOND));
-
 		// Date - Timespan
 		Arithmetics.registerOperation(Operator.ADDITION, Date.class, Timespan.class, Date::plus);
 		Arithmetics.registerOperation(Operator.SUBTRACTION, Date.class, Timespan.class, Date::minus);

src/main/java/ch/njol/skript/conditions/CondIsInfinite.java

@@ -2,25 +2,30 @@
 
 import ch.njol.skript.conditions.base.PropertyCondition;
 import ch.njol.skript.doc.Description;
-import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Example;
 import ch.njol.skript.doc.Name;
 import ch.njol.skript.doc.Since;
+import ch.njol.skript.util.Timespan;
 import org.bukkit.potion.PotionEffect;
 
-// This class can be expanded apon for other types if needed.
 @Name("Is Infinite")
-@Description("Checks whether potion effects are infinite.")
-@Examples("all of the active potion effects of the player are infinite")
+@Description("Checks whether potion effects or timespans are infinite.")
+@Example("all of the active potion effects of the player are infinite")
+@Example("if timespan argument is infinite:")
 @Since("2.7")
-public class CondIsInfinite extends PropertyCondition<PotionEffect> {
+public class CondIsInfinite extends PropertyCondition<Object> {
 
 	static {
-		register(CondIsInfinite.class, "infinite", "potioneffects");
+		register(CondIsInfinite.class, "infinite", "potioneffects/timespans");
 	}
 
 	@Override
-	public boolean check(PotionEffect potion) {
-		return potion.isInfinite();
+	public boolean check(Object object) {
+		if (object instanceof PotionEffect potionEffect)
+			return potionEffect.isInfinite();
+		if (object instanceof Timespan timespan)
+			return timespan.isInfinite();
+		return false;
 	}
 
 	@Override

src/main/java/ch/njol/skript/effects/EffPotion.java

@@ -107,7 +107,11 @@ protected void execute(Event event) {
 				Timespan timespan = this.duration.getSingle(event);
 				if (timespan == null)
 					return;
-				duration = (int) Math.min(timespan.getAs(Timespan.TimePeriod.TICK), Integer.MAX_VALUE);
+				if (timespan.isInfinite()) {
+					duration = PotionEffect.INFINITE_DURATION;
+				} else {
+					duration = (int) Math.min(timespan.getAs(Timespan.TimePeriod.TICK), Integer.MAX_VALUE);
+				}
 			}
 			for (LivingEntity entity : entities.getArray(event)) {
 				for (PotionEffectType potionEffectType : potionEffectTypes) {

src/main/java/ch/njol/skript/effects/EffPush.java

@@ -8,49 +8,83 @@
 import ch.njol.skript.lang.Effect;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.SyntaxStringBuilder;
 import ch.njol.skript.util.Direction;
 import ch.njol.util.Kleenean;
+import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.event.Event;
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.function.Function;
+
 @Name("Push")
-@Description("Push entities around.")
+@Description("Push entities in a given direction or towards a specific location.")
 @Example("push the player upwards")
 @Example("push the victim downwards at speed 0.5")
-@Example("push player along vector from player to player's target at speed 2")
-@Since("1.4.6")
+@Example("push player towards player's target at speed 2")
+@Example("pull player along vector(1,1,1) at speed 1.5")
+@Since({"1.4.6", "INSERT VERSION (push towards)"})
 public class EffPush extends Effect {
 
 	static {
-		Skript.registerEffect(EffPush.class, "(push|thrust) %entities% [along] %direction% [(at|with) (speed|velocity|force) %-number%]");
+		Skript.registerEffect(EffPush.class,
+			"(push|thrust) %entities% [along] %direction% [(at|with) [a] (speed|velocity|force) [of] %-number%]",
+			"(push|thrust|pull) %entities% (towards|away:away from) %location% [(at|with) [a] (speed|velocity|force) [of] %-number%]");
 	}
 
 	private Expression<Entity> entities;
-	private Expression<Direction> direction;
+	private @Nullable Expression<Direction> direction;
+	private @Nullable Expression<Location> target;
+	private boolean awayFrom = false;
 	private @Nullable Expression<Number> speed = null;
 
 	@SuppressWarnings({"unchecked", "null"})
 	@Override
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
 		entities = (Expression<Entity>) exprs[0];
-		direction = (Expression<Direction>) exprs[1];
+		if (matchedPattern == 0) {
+			direction = (Expression<Direction>) exprs[1];
+		} else {
+			target = (Expression<Location>) exprs[1];
+			awayFrom = parseResult.hasTag("away");
+		}
 		speed = (Expression<Number>) exprs[2];
 		return true;
 	}
 
 	@Override
 	protected void execute(Event event) {
-		Direction direction = this.direction.getSingle(event);
-		if (direction == null)
-			return;
 		Number speed = this.speed != null ? this.speed.getSingle(event) : null;
 		if (this.speed != null && speed == null)
 			return;
+
+		Function<Entity, Vector> getDirection;
+		if (this.direction != null) {
+			// push along
+			Direction direction = this.direction.getSingle(event);
+			if (direction == null)
+				return;
+			getDirection = direction::getDirection;
+		} else {
+			// push towards
+			assert this.target != null;
+			Location target = this.target.getSingle(event);
+			if (target == null)
+				return;
+			Vector targetVector = target.toVector();
+			getDirection = entity -> {
+					Vector direction = targetVector.subtract(entity.getLocation().toVector());
+					if (awayFrom)
+						direction.multiply(-1);
+					return direction;
+				};
+		}
+
 		Entity[] entities = this.entities.getArray(event);
 		for (Entity entity : entities) {
-			Vector pushDirection = direction.getDirection(entity);
+			Vector pushDirection = getDirection.apply(entity);
 			if (speed != null)
 				pushDirection.normalize().multiply(speed.doubleValue());
 			if (!(Double.isFinite(pushDirection.getX()) && Double.isFinite(pushDirection.getY()) && Double.isFinite(pushDirection.getZ()))) {
@@ -60,11 +94,23 @@ protected void execute(Event event) {
 			entity.setVelocity(entity.getVelocity().add(pushDirection));
 		}
 	}
-	
+
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
-		return "push " + entities.toString(event, debug) + " " + direction.toString(event, debug) +
-				(speed != null ? " at speed " + speed.toString(event, debug) : "");
+		var ssb = new SyntaxStringBuilder(event, debug).append("push", entities);
+		if (direction != null) {
+			ssb.append(direction);
+		} else {
+			assert target != null;
+			if (awayFrom) {
+				ssb.append("away from", target);
+			} else {
+				ssb.append("towards", target);
+			}
+		}
+		if (speed != null)
+			ssb.append("at a speed of", speed);
+		return ssb.toString();
 	}
 
 }

src/main/java/ch/njol/skript/expressions/ExprPotionEffect.java

@@ -28,8 +28,8 @@
 public class ExprPotionEffect extends SimpleExpression<PotionEffect> {
 	static {
 		Skript.registerExpression(ExprPotionEffect.class, PotionEffect.class, ExpressionType.COMBINED,
-			"[new] potion effect of %potioneffecttype% [potion] [[[of] tier] %-number%] [(1¦without particles)] [for %-timespan%]",
-			"[new] ambient potion effect of %potioneffecttype% [potion] [[[of] tier] %-number%] [(1¦without particles)] [for %-timespan%]");
+			"[a] [new] potion effect of %potioneffecttype% [potion] [[[of] tier] %-number%] [(1¦without particles)] [for %-timespan%]",
+			"[a] [new] ambient potion effect of %potioneffecttype% [potion] [[[of] tier] %-number%] [(1¦without particles)] [for %-timespan%]");
 	}
 
 	@SuppressWarnings("null")
@@ -66,8 +66,9 @@ protected PotionEffect[] get(final Event e) {
 		int ticks = 15 * 20; // 15 second default potion length
 		if (this.timespan != null) {
 			Timespan timespan = this.timespan.getSingle(e);
-			if (timespan != null)
-				ticks = (int) timespan.getAs(Timespan.TimePeriod.TICK);
+			if (timespan != null) {
+				ticks = timespan.isInfinite() ? PotionEffect.INFINITE_DURATION : (int) timespan.getAs(Timespan.TimePeriod.TICK);
+			}
 		}
 		return new PotionEffect[]{new PotionEffect(potionEffectType, ticks, tier, ambient, particles)};
 	}

src/main/java/ch/njol/skript/expressions/LitEternity.java

@@ -0,0 +1,49 @@
+package ch.njol.skript.expressions;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Example;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.SimpleLiteral;
+import ch.njol.skript.util.Timespan;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+@Name("An Eternity")
+@Description({"Represents a timespan with an infinite duration. " +
+	"An eternity is also created when arithmetic results in a timespan larger than about 292 million years.",
+	"Infinite timespans generally follow the rules of infinity, where most math operations do nothing. " +
+	"However, operations that would return NaN with numbers will instead return a timespan of 0 seconds.",
+	"Note that an eternity will often be treated as the longest duration something supports, rather than a true eternity."
+})
+@Example("set fire to the player for an eternity")
+@Since("INSERT VERSION")
+public class LitEternity extends SimpleLiteral<Timespan> {
+
+	static {
+		Skript.registerExpression(LitEternity.class, Timespan.class, ExpressionType.SIMPLE,
+				"[an] eternity",
+				"forever",
+				"[an] (indefinite|infinite) (duration|timespan)");
+	}
+
+	public LitEternity() {
+		super(new Timespan[]{Timespan.infinite()}, Timespan.class, true);
+	}
+
+	@Override
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		return true;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "an eternity";
+	}
+
+}