Merge branch 'dev/feature' into dev/LiteralMultipleWarning

Author: Absolutionism

gradle.properties

@@ -5,7 +5,7 @@ org.gradle.parallel=true
 
 groupid=ch.njol
 name=skript
-version=2.11.1
+version=2.11.2
 jarName=Skript.jar
 testEnv=java21/paper-1.21.5
 testEnvJavaVersion=21

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

@@ -13,7 +13,6 @@
 import ch.njol.skript.util.*;
 import ch.njol.skript.util.slot.InventorySlot;
 import ch.njol.skript.util.slot.Slot;
-import com.destroystokyo.paper.event.block.AnvilDamagedEvent;
 import com.destroystokyo.paper.event.block.BeaconEffectEvent;
 import com.destroystokyo.paper.event.entity.EndermanAttackPlayerEvent;
 import com.destroystokyo.paper.event.entity.ProjectileCollideEvent;
@@ -547,8 +546,6 @@ else if (hand == EquipmentSlot.OFF_HAND)
 			EventValues.registerEventValue(EntityMoveEvent.class, Location.class, EntityMoveEvent::getFrom);
 			EventValues.registerEventValue(EntityMoveEvent.class, Location.class, EntityMoveEvent::getTo, TIME_FUTURE);
 		}
-		//PlayerToggleFlightEvent
-		EventValues.registerEventValue(PlayerToggleFlightEvent.class, Player.class, PlayerEvent::getPlayer);
 		//CreatureSpawnEvent
 		EventValues.registerEventValue(CreatureSpawnEvent.class, SpawnReason.class, CreatureSpawnEvent::getSpawnReason);
 		//FireworkExplodeEvent

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

@@ -4,7 +4,6 @@
 import ch.njol.skript.util.Timespan;
 import ch.njol.skript.util.Timespan.TimePeriod;
 import ch.njol.skript.util.Utils;
-import ch.njol.util.Math2;
 import org.bukkit.util.Vector;
 import org.skriptlang.skript.lang.arithmetic.Arithmetics;
 import org.skriptlang.skript.lang.arithmetic.Operator;
@@ -91,9 +90,9 @@ public class DefaultOperations {
 		});
 
 		// Timespan - Timespan
-		Arithmetics.registerOperation(Operator.ADDITION, Timespan.class, (left, right) -> new Timespan(Math2.addClamped(left.getAs(TimePeriod.MILLISECOND), right.getAs(TimePeriod.MILLISECOND))));
-		Arithmetics.registerOperation(Operator.SUBTRACTION, Timespan.class, (left, right) -> new Timespan(Math.max(0, left.getAs(TimePeriod.MILLISECOND) - right.getAs(TimePeriod.MILLISECOND))));
-		Arithmetics.registerDifference(Timespan.class, (left, right) -> new Timespan(Math.abs(left.getAs(TimePeriod.MILLISECOND) - right.getAs(TimePeriod.MILLISECOND))));
+		Arithmetics.registerOperation(Operator.ADDITION, Timespan.class, Timespan::add);
+		Arithmetics.registerOperation(Operator.SUBTRACTION, Timespan.class, Timespan::subtract);
+		Arithmetics.registerDifference(Timespan.class, Timespan::difference);
 		Arithmetics.registerDefaultValue(Timespan.class, Timespan::new);
 
 		// Timespan - Number

src/main/java/ch/njol/skript/events/EvtClick.java

@@ -178,14 +178,16 @@ public boolean check(Event event) {
 				if (entity != null) {
 					if (object instanceof EntityData<?> entityData) {
 						return entityData.isInstance(entity);
-					} else {
-						Relation compare = DefaultComparators.entityItemComparator.compare(EntityData.fromEntity(entity), (ItemType) object);
+					} else if (object instanceof ItemType itemType) {
+						// for cases like `on right click on oak boat` try to compare the boat item to the boat entity
+						// therefore blockdata check isn't needed here
+						Relation compare = DefaultComparators.entityItemComparator.compare(EntityData.fromEntity(entity), itemType);
 						return Relation.EQUAL.isImpliedBy(compare);
 					}
 				} else if (object instanceof ItemType itemType) {
 					return itemType.isOfType(block);
-				} else if (blockDataCheck != null && object instanceof BlockData blockData)  {
-					return blockDataCheck.matches(blockData);
+				} else if (object instanceof BlockData blockData) {
+					return blockDataCheck != null && blockDataCheck.matches(blockData);
 				}
 				return false;
 			});

src/main/java/ch/njol/skript/expressions/arithmetic/ArithmeticChain.java

@@ -34,8 +34,7 @@ public class ArithmeticChain<L, R, T> implements ArithmeticGettable<T> {
 	private final ArithmeticGettable<R> right;
 	private final Operator operator;
 	private final Class<? extends T> returnType;
-	@Nullable
-	private OperationInfo<? extends L, ? extends R, ? extends T> operationInfo;
+	private final @Nullable OperationInfo<? extends L, ? extends R, ? extends T> operationInfo;
 
 	public ArithmeticChain(ArithmeticGettable<L> left, Operator operator, ArithmeticGettable<R> right, @Nullable OperationInfo<L, R, T> operationInfo) {
 		this.left = left;
@@ -63,6 +62,7 @@ public T get(Event event) {
 		if (leftClass == Object.class && rightClass == Object.class)
 			return null;
 
+		OperationInfo<? extends L, ? extends R, ? extends T> operationInfo = this.operationInfo;
 		if (left == null && leftClass == Object.class) {
 			operationInfo = lookupOperationInfo(rightClass, OperationInfo::getRight);
 		} else if (right == null && rightClass == Object.class) {

src/main/java/ch/njol/skript/util/Timespan.java

@@ -5,6 +5,7 @@
 import ch.njol.skript.localization.GeneralWords;
 import ch.njol.skript.localization.Language;
 import ch.njol.skript.localization.Noun;
+import ch.njol.util.Math2;
 import ch.njol.util.NonNullPair;
 import ch.njol.util.coll.CollectionUtils;
 import ch.njol.yggdrasil.YggdrasilSerializable;
@@ -254,6 +255,36 @@ public Duration getDuration() {
 		return Duration.ofMillis(millis);
 	}
 
+	/**
+	 * Safely adds the specified timespan to this timespan, handling potential overflow.
+	 * @param timespan The timespan to add to this timespan
+	 * @return a new Timespan object
+	 */
+	public Timespan add(Timespan timespan) {
+		long millis = Math2.addClamped(this.millis, timespan.getAs(TimePeriod.MILLISECOND));
+		return new Timespan(millis);
+	}
+
+	/**
+	 * Safely subtracts the specified timespan from this timespan, handling potential underflow.
+	 * @param timespan The timespan to subtract from this timespan
+	 * @return a new Timespan object
+	 */
+	public Timespan subtract(Timespan timespan) {
+		long millis = Math.max(0, this.millis - timespan.getAs(TimePeriod.MILLISECOND));
+		return new Timespan(millis);
+	}
+
+	/**
+	 * Calculates the difference between the specified timespan and this timespan.
+	 * @param timespan The timespan to get the difference of
+	 * @return a new Timespan object
+	 */
+	public Timespan difference(Timespan timespan) {
+		long millis = Math.abs(this.millis - timespan.getAs(TimePeriod.MILLISECOND));
+		return new Timespan(millis);
+	}
+
 	@Override
 	public long get(TemporalUnit unit) {
 		if (unit instanceof TimePeriod period)

src/test/skript/tests/syntaxes/expressions/ExprArithmetic.sk

@@ -263,3 +263,18 @@ test "arithmetic return types":
 	# however, we can get more specific return types by returning the superclass of the return types of all Object-Number operations
 	set {_location} to location(0,10,0,"world")
 	assert (y-coordinate of {_location} - 4) is 6 with "y-coordinate of {_location} - 4 is not 6 (got '%y-coordinate of {_location} - 4%')"
+
+test "arithmetic type switcheroo":
+	# operation info swap test
+	set {_a} to 1
+	set {_b} to 1
+	loop 2 times:
+		set {_x} to {_a} * {_b}
+		assert {_x} is set with "Failed to get a result"
+		set {_b} to a random vector
+
+	# operation info trick test
+	set {_a} to "Hello"
+	loop 2 times:
+		set {_x} to {_a} + {_b}
+		set {_b} to 5