Switch to JOML vectors.

src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java

@@ -1,7 +1,10 @@
 package ch.njol.skript.bukkitutil;
 
-import java.util.EnumSet;
-
+import ch.njol.skript.Skript;
+import com.destroystokyo.paper.entity.ai.Goal;
+import com.destroystokyo.paper.entity.ai.GoalKey;
+import com.destroystokyo.paper.entity.ai.GoalType;
+import io.papermc.paper.entity.LookAnchor;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.NamespacedKey;
@@ -12,12 +15,7 @@
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
 
-import com.destroystokyo.paper.entity.ai.Goal;
-import com.destroystokyo.paper.entity.ai.GoalKey;
-import com.destroystokyo.paper.entity.ai.GoalType;
-
-import ch.njol.skript.Skript;
-import io.papermc.paper.entity.LookAnchor;
+import java.util.EnumSet;
 
 public class PaperEntityUtils {
 
@@ -67,9 +65,9 @@ public static void lookAt(Object target, @Nullable Float headRotationSpeed, @Nul
 			return;
 		}
 		for (LivingEntity entity : entities) {
-			if (!(entity instanceof Mob))
+			if (!(entity instanceof Mob mob))
 				continue;
-			mobLookAt(target, headRotationSpeed, maxHeadPitch, (Mob) entity);
+			mobLookAt(target, headRotationSpeed, maxHeadPitch, mob);
 		}
 	}
 
@@ -94,19 +92,18 @@ public static void lookAt(LookAnchor entityAnchor, Object target, @Nullable Floa
 			}
 			if (entity instanceof Player) {
 				Player player = (Player) entity;
-				if (target instanceof Vector) {
-					Vector vector = (Vector) target;
+				if (target instanceof Vector vector) {
 					player.lookAt(player.getEyeLocation().add(vector), LookAnchor.EYES);
 					player.lookAt(player.getEyeLocation().add(vector), LookAnchor.FEET);
-				} else if (target instanceof Location) {
-					player.lookAt((Location) target, LookAnchor.EYES);
-					player.lookAt((Location) target, LookAnchor.FEET);
-				} else if (target instanceof Entity) {
-					player.lookAt((Entity) target, LookAnchor.EYES, entityAnchor);
-					player.lookAt((Entity) target, LookAnchor.FEET, entityAnchor);
+				} else if (target instanceof Location location) {
+					player.lookAt(location, LookAnchor.EYES);
+					player.lookAt(location, LookAnchor.FEET);
+				} else if (target instanceof Entity targetEntity) {
+					player.lookAt(targetEntity, LookAnchor.EYES, entityAnchor);
+					player.lookAt(targetEntity, LookAnchor.FEET, entityAnchor);
 				}
-			} else if (entity instanceof Mob) {
-				mobLookAt(target, headRotationSpeed, maxHeadPitch, (Mob) entity);
+			} else if (entity instanceof Mob mob) {
+				mobLookAt(target, headRotationSpeed, maxHeadPitch, mob);
 			}
 		}
 	}

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

@@ -57,7 +57,6 @@
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 import org.bukkit.util.CachedServerIcon;
-import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.StreamCorruptedException;
@@ -396,73 +395,6 @@ public Location deserialize(final String s) {
 				})
 				.cloner(Location::clone));
 
-		Classes.registerClass(new ClassInfo<>(Vector.class, "vector")
-				.user("vectors?")
-				.name("Vector")
-				.description("Vector is a collection of numbers. In Minecraft, 3D vectors are used to express velocities of entities.")
-				.usage("vector(x, y, z)")
-				.examples("")
-				.since("2.2-dev23")
-				.defaultExpression(new EventValueExpression<>(Vector.class))
-				.parser(new Parser<Vector>() {
-					@Override
-					@Nullable
-					public Vector parse(final String s, final ParseContext context) {
-						return null;
-					}
-
-					@Override
-					public boolean canParse(final ParseContext context) {
-						return false;
-					}
-
-					@Override
-					public String toString(final Vector vec, final int flags) {
-						return "x: " + Skript.toString(vec.getX()) + ", y: " + Skript.toString(vec.getY()) + ", z: " + Skript.toString(vec.getZ());
-					}
-
-					@Override
-					public String toVariableNameString(final Vector vec) {
-						return "vector:" + vec.getX() + "," + vec.getY() + "," + vec.getZ();
-					}
-
-					@Override
-					public String getDebugMessage(final Vector vec) {
-						return "(" + vec.getX() + "," + vec.getY() + "," + vec.getZ() + ")";
-					}
-				})
-				.serializer(new Serializer<Vector>() {
-					@Override
-					public Fields serialize(Vector o) {
-						Fields f = new Fields();
-						f.putPrimitive("x", o.getX());
-						f.putPrimitive("y", o.getY());
-						f.putPrimitive("z", o.getZ());
-						return f;
-					}
-
-					@Override
-					public void deserialize(Vector o, Fields f) {
-						assert false;
-					}
-
-					@Override
-					public Vector deserialize(final Fields f) throws StreamCorruptedException {
-						return new Vector(f.getPrimitive("x", double.class), f.getPrimitive("y", double.class), f.getPrimitive("z", double.class));
-					}
-
-					@Override
-					public boolean mustSyncDeserialization() {
-						return false;
-					}
-
-					@Override
-					protected boolean canBeInstantiated() {
-						return false;
-					}
-				})
-				.cloner(Vector::clone));
-
 		Classes.registerClass(new ClassInfo<>(World.class, "world")
 				.user("worlds?")
 				.name("World")

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

@@ -10,17 +10,7 @@
 import ch.njol.skript.entity.BoatData;
 import ch.njol.skript.entity.EntityData;
 import ch.njol.skript.entity.RabbitData;
-import ch.njol.skript.util.BlockUtils;
-import ch.njol.skript.util.Color;
-import ch.njol.skript.util.Date;
-import ch.njol.skript.util.EnchantmentType;
-import ch.njol.skript.util.Experience;
-import ch.njol.skript.util.GameruleValue;
-import ch.njol.skript.util.StructureType;
-import ch.njol.skript.util.Time;
-import ch.njol.skript.util.Timeperiod;
-import ch.njol.skript.util.Timespan;
-import ch.njol.skript.util.WeatherType;
+import ch.njol.skript.util.*;
 import ch.njol.skript.util.slot.EquipmentSlot;
 import ch.njol.skript.util.slot.Slot;
 import ch.njol.skript.util.slot.SlotWithIndex;
@@ -41,6 +31,8 @@
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.Vector;
+import org.joml.Vector3d;
 import org.skriptlang.skript.lang.comparator.Comparator;
 import org.skriptlang.skript.lang.comparator.Comparators;
 import org.skriptlang.skript.lang.comparator.Relation;
@@ -619,12 +611,12 @@ public boolean supportsOrdering() {
 		});
 
 		// Location - Location
-		Comparators.registerComparator(Location.class, Location.class, new Comparator<Location, Location>() {
+		Comparators.registerComparator(Location.class, Location.class, new Comparator<>() {
 			@Override
 			public Relation compare(Location first, Location second) {
 				return Relation.get(
-						// compare worlds
-						Objects.equals(first.getWorld(), second.getWorld()) &&
+					// compare worlds
+					Objects.equals(first.getWorld(), second.getWorld()) &&
 						// compare xyz coords
 						first.toVector().equals(second.toVector()) &&
 						// normalize yaw and pitch to [-180, 180) and [-90, 90] respectively
@@ -633,13 +625,20 @@ public Relation compare(Location first, Location second) {
 						Location.normalizePitch(first.getPitch()) == Location.normalizePitch(second.getPitch())
 				);
 			}
-
-			@Override
-			public boolean supportsOrdering() {
-				return false;
-			}
 		});
 
+		// Vectors
+
+		double vectorEpsilon = 0.000001; // vectors often are made from float sources, so can't use 1e-10.
+		Comparators.registerComparator(Vector3d.class, Vector3d.class, (a, b) -> Relation.get(
+				Math.abs(a.x - b.x) < vectorEpsilon
+				&& Math.abs(a.y - b.y) < vectorEpsilon
+				&& Math.abs(a.z - b.z) < vectorEpsilon));
+		Comparators.registerComparator(Vector.class, Vector3d.class, (a, b) -> Relation.get(
+			Math.abs(a.getX() - b.x) < vectorEpsilon
+				&& Math.abs(a.getY() - b.y) < vectorEpsilon
+				&& Math.abs(a.getZ() - b.z) < vectorEpsilon));
+
 		// Potion Effect Type
 		Comparators.registerComparator(PotionEffectType.class, PotionEffectType.class, (one, two) -> Relation.get(one.equals(two)));
 

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

@@ -35,6 +35,7 @@
 import org.bukkit.util.Vector;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.UnknownNullability;
+import org.joml.Vector3d;
 import org.skriptlang.skript.lang.converter.Converter;
 import org.skriptlang.skript.lang.converter.Converters;
 import org.skriptlang.skript.lang.script.Script;
@@ -267,8 +268,12 @@ public void setAmount(Number amount) {
 		// Enchantment - EnchantmentType
 		Converters.registerConverter(Enchantment.class, EnchantmentType.class, e -> new EnchantmentType(e, -1));
 
-		// Vector - Direction
-		Converters.registerConverter(Vector.class, Direction.class, Direction::new);
+		// Vector3d - Vector
+		Converters.registerConverter(Vector3d.class, Vector.class, Vector::fromJOML, Converter.NO_RIGHT_CHAINING);
+		Converters.registerConverter(Vector.class, Vector3d.class, Vector::toVector3d);
+
+		// Vector3d - Direction
+		Converters.registerConverter(Vector3d.class, Direction.class, Direction::new);
 
 		// EnchantmentOffer - EnchantmentType
 		Converters.registerConverter(EnchantmentOffer.class, EnchantmentType.class, eo -> new EnchantmentType(eo.getEnchantment(), eo.getEnchantmentLevel()));

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

@@ -17,10 +17,10 @@
 import org.bukkit.OfflinePlayer;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
-import org.bukkit.util.Vector;
 import org.jetbrains.annotations.Nullable;
 import org.joml.AxisAngle4f;
 import org.joml.Quaternionf;
+import org.joml.Vector3d;
 import org.joml.Vector3f;
 
 import java.math.BigDecimal;
@@ -462,17 +462,17 @@ public Date[] executeSimple(Object[][] params) {
 			.examples("date(2014, 10, 1) # 0:00, 1st October 2014", "date(1990, 3, 5, 14, 30) # 14:30, 5th May 1990", "date(1999, 12, 31, 23, 59, 59, 999, -3*60, 0) # almost year 2000 in parts of Brazil (-3 hours offset, no DST)")
 			.since("2.2"));
 
-		Functions.registerFunction(new SimpleJavaFunction<Vector>("vector", new Parameter[] {
+		Functions.registerFunction(new SimpleJavaFunction<>("vector", new Parameter[]{
 			new Parameter<>("x", DefaultClasses.NUMBER, true, null),
 			new Parameter<>("y", DefaultClasses.NUMBER, true, null),
 			new Parameter<>("z", DefaultClasses.NUMBER, true, null)
 		}, DefaultClasses.VECTOR, true) {
 			@Override
-			public Vector[] executeSimple(Object[][] params) {
-				return new Vector[] {new Vector(
-					((Number)params[0][0]).doubleValue(),
-					((Number)params[1][0]).doubleValue(),
-					((Number)params[2][0]).doubleValue()
+			public Vector3d[] executeSimple(Object[][] params) {
+				return new Vector3d[]{new Vector3d(
+					((Number) params[0][0]).doubleValue(),
+					((Number) params[1][0]).doubleValue(),
+					((Number) params[2][0]).doubleValue()
 				)};
 			}
 
@@ -649,10 +649,10 @@ public Quaternionf[] executeSimple(Object[][] params) {
 						@Override
 						public Quaternionf[] executeSimple(Object[][] params) {
 							float angle = (float) (((Number) params[0][0]).floatValue() / 180 * Math.PI);
-							Vector v = ((Vector) params[1][0]);
-							if (v.isZero() || !Double.isFinite(v.getX()) || !Double.isFinite(v.getY()) || !Double.isFinite(v.getZ()))
+							Vector3d v = ((Vector3d) params[1][0]);
+							if (Math2.vectorIsZero(v) || !v.isFinite())
 								return new Quaternionf[0];
-							Vector3f axis = ((Vector) params[1][0]).toVector3f();
+							Vector3f axis = new Vector3f((float) v.x, (float) v.y, (float) v.z);
 							return CollectionUtils.array(new Quaternionf(new AxisAngle4f(angle, axis)));
 						}
 					})

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

@@ -4,7 +4,7 @@
 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.joml.Vector3d;
 import org.skriptlang.skript.lang.arithmetic.Arithmetics;
 import org.skriptlang.skript.lang.arithmetic.Operator;
 
@@ -64,30 +64,22 @@ public class DefaultOperations {
 		Arithmetics.registerDefaultValue(Number.class, () -> 0L);
 
 		// Vector - Vector
-		Arithmetics.registerOperation(Operator.ADDITION, Vector.class, (left, right) -> left.clone().add(right));
-		Arithmetics.registerOperation(Operator.SUBTRACTION, Vector.class, (left, right) -> left.clone().subtract(right));
-		Arithmetics.registerOperation(Operator.MULTIPLICATION, Vector.class, (left, right) -> left.clone().multiply(right));
-		Arithmetics.registerOperation(Operator.DIVISION, Vector.class, (left, right) -> left.clone().divide(right));
-		Arithmetics.registerDifference(Vector.class,
-			(left, right) -> new Vector(Math.abs(left.getX() - right.getX()), Math.abs(left.getY() - right.getY()), Math.abs(left.getZ() - right.getZ())));
-		Arithmetics.registerDefaultValue(Vector.class, Vector::new);
+		Arithmetics.registerOperation(Operator.ADDITION, Vector3d.class, (left, right) -> left.add(right, new Vector3d()));
+		Arithmetics.registerOperation(Operator.SUBTRACTION, Vector3d.class, (left, right) -> left.sub(right, new Vector3d()));
+		Arithmetics.registerOperation(Operator.MULTIPLICATION, Vector3d.class, (left, right) -> left.mul(right, new Vector3d()));
+		Arithmetics.registerOperation(Operator.DIVISION, Vector3d.class, (left, right) -> left.div(right, new Vector3d()));
+		Arithmetics.registerDifference(Vector3d.class,
+			(left, right) -> new Vector3d(Math.abs(left.x() - right.x()), Math.abs(left.y() - right.y()), Math.abs(left.z() - right.z())));
+		Arithmetics.registerDefaultValue(Vector3d.class, Vector3d::new);
 
 		// Vector - Number
 		// Number - Vector
-		Arithmetics.registerOperation(Operator.MULTIPLICATION, Vector.class, Number.class, (left, right) -> left.clone().multiply(right.doubleValue()), (left, right) -> {
-			double number = left.doubleValue();
-			Vector leftVector = new Vector(number, number, number);
-			return leftVector.multiply(right);
-		});
-		Arithmetics.registerOperation(Operator.DIVISION, Vector.class, Number.class, (left, right) -> {
-			double number = right.doubleValue();
-			Vector rightVector = new Vector(number, number, number);
-			return left.clone().divide(rightVector);
-		}, (left, right) -> {
-			double number = left.doubleValue();
-			Vector leftVector = new Vector(number, number, number);
-			return leftVector.divide(right);
-		});
+		Arithmetics.registerOperation(Operator.MULTIPLICATION, Vector3d.class, Number.class,
+			(left, right) -> left.mul(right.doubleValue(), new Vector3d()),
+			(left, right) -> right.mul(left.doubleValue(), new Vector3d()));
+		Arithmetics.registerOperation(Operator.DIVISION, Vector3d.class, Number.class,
+			(left, right) -> left.div(right.doubleValue(), new Vector3d()),
+			(left, right) -> new Vector3d(left.doubleValue()).div(right));
 
 		// Timespan - Timespan
 		Arithmetics.registerOperation(Operator.ADDITION, Timespan.class, Timespan::add);