String -> UUID

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

@@ -21,6 +21,7 @@
 import ch.njol.skript.util.BlockUtils;
 import ch.njol.skript.util.PotionEffectUtils;
 import ch.njol.skript.util.StringMode;
+import ch.njol.skript.util.Utils;
 import ch.njol.util.StringUtils;
 import ch.njol.yggdrasil.Fields;
 import io.papermc.paper.world.MoonPhase;
@@ -71,10 +72,7 @@ public class BukkitClasses {
 
 	public BukkitClasses() {}
 
-	public static final Pattern UUID_PATTERN = Pattern.compile("(?i)[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}");
-
 	static {
-		final boolean GET_ENTITY_METHOD_EXISTS = Skript.methodExists(Bukkit.class, "getEntity", UUID.class);
 		Classes.registerClass(new ClassInfo<>(Entity.class, "entity")
 				.user("entit(y|ies)")
 				.name("Entity")
@@ -91,25 +89,10 @@ public BukkitClasses() {}
 				.defaultExpression(new EventValueExpression<>(Entity.class))
 				.parser(new Parser<Entity>() {
 					@Override
-					@Nullable
-					public Entity parse(final String s, final ParseContext context) {
-						UUID uuid;
-						try {
-							uuid = UUID.fromString(s);
-						} catch (IllegalArgumentException iae) {
-							return null;
-						}
-						if (GET_ENTITY_METHOD_EXISTS) {
-							return Bukkit.getEntity(uuid);
-						} else {
-							for (World world : Bukkit.getWorlds()) {
-								for (Entity entity : world.getEntities()) {
-									if (entity.getUniqueId().equals(uuid)) {
-										return entity;
-									}
-								}
-							}
-						}
+					public @Nullable Entity parse(final String s, final ParseContext context) {
+						if (Utils.isValidUUID(s))
+							return Bukkit.getEntity(UUID.fromString(s));
+
 						return null;
 					}
 
@@ -643,8 +626,10 @@ public Player parse(String string, ParseContext context) {
 						if (context == ParseContext.COMMAND || context == ParseContext.PARSE) {
 							if (string.isEmpty())
 								return null;
-							if (UUID_PATTERN.matcher(string).matches())
+
+							if (Utils.isValidUUID(string))
 								return Bukkit.getPlayer(UUID.fromString(string));
+
 							String name = string.toLowerCase(Locale.ENGLISH);
 							int nameLength = name.length(); // caching
 							List<Player> players = new ArrayList<>();
@@ -709,16 +694,11 @@ public String getDebugMessage(final Player p) {
 				.after("string", "world")
 				.parser(new Parser<OfflinePlayer>() {
 					@Override
-					@Nullable
-					public OfflinePlayer parse(final String s, final ParseContext context) {
-						if (context == ParseContext.COMMAND || context == ParseContext.PARSE) {
-							if (UUID_PATTERN.matcher(s).matches())
-								return Bukkit.getOfflinePlayer(UUID.fromString(s));
-							else if (!SkriptConfig.playerNameRegexPattern.value().matcher(s).matches())
-								return null;
+					public @Nullable OfflinePlayer parse(final String s, final ParseContext context) {
+						if (Utils.isValidUUID(s))
+							return Bukkit.getOfflinePlayer(UUID.fromString(s));
+						else if (SkriptConfig.playerNameRegexPattern.value().matcher(s).matches())
 							return Bukkit.getOfflinePlayer(s);
-						}
-						assert false;
 						return null;
 					}
 

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

@@ -45,6 +45,7 @@
 import org.skriptlang.skript.lang.comparator.Relation;
 
 import java.util.Objects;
+import java.util.UUID;
 
 @SuppressWarnings({"rawtypes"})
 public class DefaultComparators {
@@ -665,6 +666,10 @@ public Relation compare(EntitySnapshot snap1, EntitySnapshot snap2) {
 				}
 			});
 		}
+
+		// UUID
+		Comparators.registerComparator(UUID.class, UUID.class, (one, two) -> Relation.get(one.equals(two)));
+		Comparators.registerComparator(UUID.class, String.class, (one, two) -> Relation.get(one.toString().equals(two)));
 	}
 
 }

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

@@ -11,6 +11,7 @@
 import ch.njol.skript.entity.XpOrbData;
 import ch.njol.skript.lang.util.common.AnyAmount;
 import ch.njol.skript.lang.util.common.AnyNamed;
+import ch.njol.skript.lang.util.common.AnyValued;
 import ch.njol.skript.util.*;
 import ch.njol.skript.util.slot.Slot;
 import org.bukkit.*;
@@ -39,6 +40,8 @@
 import org.skriptlang.skript.lang.converter.Converters;
 import org.skriptlang.skript.lang.script.Script;
 
+import java.util.UUID;
+
 public class DefaultConverters {
 
 	public DefaultConverters() {}
@@ -275,6 +278,20 @@ public void setAmount(Number amount) {
 		Converters.registerConverter(Script.class, Config.class, Script::getConfig);
 		Converters.registerConverter(Config.class, Node.class, Config::getMainNode);
 
+		// UUID -> String & AnyValued
+		Converters.registerConverter(UUID.class, String.class, UUID::toString);
+		Converters.registerConverter(UUID.class, AnyValued.class, uuid -> new AnyValued<String>() {
+			@Override
+			public String value() {
+				return uuid.toString();
+			}
+
+			@Override
+			public Class<String> valueType() {
+				return String.class;
+			}
+		});
+
 //		// Entity - String (UUID) // Very slow, thus disabled for now
 //		Converters.registerConverter(String.class, Entity.class, new Converter<String, Entity>() {
 //

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

@@ -11,10 +11,7 @@
 import ch.njol.skript.lang.util.SimpleLiteral;
 import ch.njol.skript.registrations.Classes;
 import ch.njol.skript.registrations.DefaultClasses;
-import ch.njol.skript.util.Color;
-import ch.njol.skript.util.ColorRGB;
-import ch.njol.skript.util.Contract;
-import ch.njol.skript.util.Date;
+import ch.njol.skript.util.*;
 import ch.njol.util.Math2;
 import ch.njol.util.StringUtils;
 import ch.njol.util.coll.CollectionUtils;
@@ -544,9 +541,8 @@ public Player[] executeSimple(Object[][] params) {
 				boolean isExact = (boolean) params[1][0];
 				UUID uuid = null;
 				if (name.length() > 16 || name.contains("-")) { // shortcut
-					try {
+					if (Utils.isValidUUID(name))
 						uuid = UUID.fromString(name);
-					} catch (IllegalArgumentException ignored) {}
 				}
 				return CollectionUtils.array(uuid != null ? Bukkit.getPlayer(uuid) : (isExact ? Bukkit.getPlayerExact(name) : Bukkit.getPlayer(name)));
 			}
@@ -569,10 +565,8 @@ public OfflinePlayer[] executeSimple(Object[][] params) {
 					String name = (String) params[0][0];
 					UUID uuid = null;
 					if (name.length() > 16 || name.contains("-")) { // shortcut
-						try {
+						if (Utils.isValidUUID(name))
 							uuid = UUID.fromString(name);
-						} catch (IllegalArgumentException ignored) {
-						}
 					}
 					OfflinePlayer result;
 

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

@@ -19,6 +19,9 @@
 import org.jetbrains.annotations.Nullable;
 import org.joml.Quaternionf;
 
+import java.io.NotSerializableException;
+import java.io.StreamCorruptedException;
+import java.util.UUID;
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -325,6 +328,19 @@ public String toVariableNameString(Quaternionf quaternion) {
 						return null;
 					}
 				}));
+
+		Classes.registerClass(new ClassInfo<>(UUID.class, "uuid")
+			.user("uuids?")
+			.name("UUID")
+			.description(
+				"UUIDs are unique identifiers that ensure things can be reliably distinguished from each other. "
+					+ "They're generated in a way that makes it practically impossible for duplicates to occur.",
+				"Read more about UUIDs and how they are used in Minecraft "
+					+ "in <a href='https://minecraft.wiki/w/UUID'>the UUID wiki</a>.")
+			.since("INSERT VERSION")
+			.parser(new UUIDParser())
+			.serializer(new UUIDSerializer())
+		);
 	}
 
 	/**
@@ -793,4 +809,61 @@ public boolean mustSyncDeserialization() {
 
 	}
 
+	private static class UUIDParser extends Parser<UUID> {
+
+		@Override
+		public @Nullable UUID parse(String string, ParseContext context) {
+			if (Utils.isValidUUID(string))
+				return UUID.fromString(string);
+			return null;
+		}
+
+		@Override
+		public String toString(UUID uuid, int flags) {
+			return uuid.toString();
+		}
+
+		@Override
+		public String toVariableNameString(UUID uuid) {
+			return uuid.toString();
+		}
+
+	}
+
+	private static class UUIDSerializer extends Serializer<UUID> {
+
+		@Override
+		public Fields serialize(UUID uuid) {
+			Fields fields = new Fields();
+
+			fields.putPrimitive("mostsignificantbits", uuid.getMostSignificantBits());
+			fields.putPrimitive("leastsignificantbits", uuid.getLeastSignificantBits());
+
+			return fields;
+		}
+
+		@Override
+		public void deserialize(UUID o, Fields f) throws NotSerializableException {
+			throw new NotSerializableException();
+		}
+
+		@Override
+		protected UUID deserialize(Fields fields) throws StreamCorruptedException {
+			long mostSignificantBits = fields.getAndRemovePrimitive("mostsignificantbits", long.class);
+			long leastSignificantBits = fields.getAndRemovePrimitive("leastsignificantbits", long.class);
+			return new UUID(mostSignificantBits, leastSignificantBits);
+		}
+
+		@Override
+		public boolean mustSyncDeserialization() {
+			return false;
+		}
+
+		@Override
+		protected boolean canBeInstantiated() {
+			return false;
+		}
+
+	}
+
 }