EntityData Overhaul

.github/CODEOWNERS

@@ -66,3 +66,6 @@
 
 # Functions
 /src/main/java/ch/njol/skript/lang/function @Efnilite @skriptlang/core-developers
+
+# EntityData
+/src/main/java/ch/njol/skript/entity @Absolutionism @skriptlang/core-developers

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

@@ -0,0 +1,89 @@
+package ch.njol.skript.conditions;
+
+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.entity.EntityData;
+import ch.njol.skript.entity.EntityType;
+import ch.njol.skript.lang.Condition;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.SyntaxStringBuilder;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+@Name("Is Spawnable")
+@Description("""
+	Whether an entity type can be spawned in a world. If no world is provided, will default to the first world.
+	Any general types such as 'monster, mob, entity, living entity' etc. will never be spawnable.
+	""")
+@Example("""
+	if a pig is spawnable: # true
+	if a monster can be spawned: # false
+	""")
+@Since("INSERT VERSION")
+public class CondIsSpawnable extends Condition {
+
+	static {
+		Skript.registerCondition(CondIsSpawnable.class, ConditionType.COMBINED,
+			"%entitytypes% is spawnable [in [the [world]] %-world%]",
+			"%entitytypes% can be spawned [in [the [world]] %-world%]",
+			"%entitytypes% (isn't|is not) spawnable [in [the [world]] %-world%]",
+			"%entitytypes% (can't|can not) be spawned [in [the [world]] %-world%]");
+	}
+
+	private Expression<?> types;
+	private @Nullable Expression<World> world = null;
+
+	@Override
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		types = exprs[0];
+		if (exprs[1] != null) {
+			//noinspection unchecked
+			world = (Expression<World>) exprs[1];
+		}
+		setNegated(matchedPattern >= 2);
+		return true;
+	}
+
+	@Override
+	public boolean check(Event event) {
+		World world = null;
+		if (this.world != null) {
+			world = this.world.getSingle(event);
+		}
+		if (world == null)
+			world = Bukkit.getWorlds().get(0);
+
+		World finalWorld = world;
+		return SimpleExpression.check(types.getArray(event), object -> {
+			if (object instanceof EntityData<?> entityData) {
+				return entityData.canSpawn(finalWorld);
+			} else if (object instanceof EntityType entityType) {
+				EntityData<?> entityData = entityType.data;
+				if (entityData != null)
+					return entityData.canSpawn(finalWorld);
+			}
+			return false;
+		}, isNegated(), types.getAnd());
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
+		builder.append(types, "is");
+		if (isNegated())
+			builder.append("not");
+		builder.append("spawnable");
+		if (world != null)
+			builder.append("in", world);
+		return builder.toString();
+	}
+
+}

src/main/java/ch/njol/skript/doc/Documentation.java

@@ -309,7 +309,7 @@ private static void insertSyntaxElement(final PrintWriter pw, final SyntaxElemen
 			Skript.warning("" + elementClass.getSimpleName() + "'s description or 'since' is invalid");
 			return;
 		}
-		final String patterns = cleanPatterns(StringUtils.join(info.patterns, "\n", 0, elementClass == CondCompare.class ? 8 : info.patterns.length));
+		String patterns = cleanPatterns(StringUtils.join(info.patterns, "\n", 0, elementClass == CondCompare.class ? 8 : info.getPatterns().length));
 		insertOnDuplicateKeyUpdate(pw, "syntax_elements",
 				"id, name, type, patterns, description, examples, since",
 				"patterns = TRIM(LEADING '\n' FROM CONCAT(patterns, '\n', '" + escapeSQL(patterns) + "'))",
@@ -341,7 +341,7 @@ private static void insertEvent(final PrintWriter pw, final SkriptEventInfo<?> i
 			Skript.warning("description or 'since' of " + info.getName() + " (" + info.getElementClass().getSimpleName() + ") is invalid");
 			return;
 		}
-		final String patterns = cleanPatterns(info.getName().startsWith("On ") ? "[on] " + StringUtils.join(info.patterns, "\n[on] ") : StringUtils.join(info.patterns, "\n"));
+		String patterns = cleanPatterns(info.getName().startsWith("On ") ? "[on] " + StringUtils.join(info.getPatterns(), "\n[on] ") : StringUtils.join(info.patterns, "\n"));
 		insertOnDuplicateKeyUpdate(pw, "syntax_elements",
 				"id, name, type, patterns, description, examples, since",
 				"patterns = '" + escapeSQL(patterns) + "'",

src/main/java/ch/njol/skript/doc/HTMLGenerator.java

@@ -528,7 +528,7 @@ private String generateAnnotated(String descTemp, SyntaxElementInfo<?> info, @Nu
 			String[] split = data.split(" ");
 			String pattern = readFile(new File(templateDir + "/templates/" + split[1]));
 			StringBuilder patterns = new StringBuilder();
-			for (String line : getDefaultIfNullOrEmpty(info.patterns, "Missing patterns.")) {
+			for (String line : getDefaultIfNullOrEmpty(info.getPatterns(), "Missing patterns.")) {
 				assert line != null;
 				line = cleanPatterns(line);
 				String parsed = pattern.replace("${element.pattern}", line);
@@ -668,7 +668,7 @@ private String generateEvent(String descTemp, SkriptEventInfo<?> info, @Nullable
 			String[] split = data.split(" ");
 			String pattern = readFile(new File(templateDir + "/templates/" + split[1]));
 			StringBuilder patterns = new StringBuilder();
-			for (String line : getDefaultIfNullOrEmpty(info.patterns, "Missing patterns.")) {
+			for (String line : getDefaultIfNullOrEmpty(info.getPatterns(), "Missing patterns.")) {
 				assert line != null;
 				line = "[on] " + cleanPatterns(line);
 				String parsed = pattern.replace("${element.pattern}", line);

src/main/java/ch/njol/skript/entity/AxolotlData.java

@@ -1,55 +1,67 @@
 package ch.njol.skript.entity;
 
-import ch.njol.skript.Skript;
 import ch.njol.skript.lang.Literal;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.util.coll.CollectionUtils;
 import org.bukkit.entity.Axolotl;
 import org.bukkit.entity.Axolotl.Variant;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Objects;
+
 public class AxolotlData extends EntityData<Axolotl> {
 
+	private static final EntityPatterns<Variant> PATTERNS = new EntityPatterns<>(new Object[][]{
+		{"axolotl", null},
+		{"lucy axolotl", Variant.LUCY},
+		{"wild axolotl", Variant.WILD},
+		{"gold axolotl", Variant.GOLD},
+		{"cyan axolotl", Variant.CYAN},
+		{"blue axolotl", Variant.BLUE}
+	});
+	private static final Variant[] VARIANTS = Variant.values();
+
 	static {
-		if (Skript.classExists("org.bukkit.entity.Axolotl")) {
-			EntityData.register(AxolotlData.class, "axolotl", Axolotl.class, 0,
-				"axolotl", "lucy axolotl", "wild axolotl", "gold axolotl", "cyan axolotl", "blue axolotl");
-		}
+		EntityData.register(AxolotlData.class, "axolotl", Axolotl.class, 0, PATTERNS.getPatterns());
 	}
 
-	@Nullable
-	private Variant variant = null;
+	private @Nullable Variant variant = null;
 
 	public AxolotlData() {}
 
 	public AxolotlData(@Nullable Variant variant) {
 		this.variant = variant;
-		matchedPattern = variant != null ? variant.ordinal() + 1 : 0;
+		super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0];
 	}
 
 	@Override
-	protected boolean init(Literal<?>[] exprs, int matchedPattern, ParseResult parseResult) {
-		if (matchedPattern > 0)
-			variant = Variant.values()[matchedPattern - 1];
+	protected boolean init(Literal<?>[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) {
+		variant = PATTERNS.getInfo(matchedCodeName);
 		return true;
 	}
 
 	@Override
-	protected boolean init(@Nullable Class<? extends Axolotl> c, @Nullable Axolotl axolotl) {
-		if (axolotl != null)
+	protected boolean init(@Nullable Class<? extends Axolotl> entityClass, @Nullable Axolotl axolotl) {
+		if (axolotl != null) {
 			variant = axolotl.getVariant();
+			super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0];
+		}
 		return true;
 	}
 
 	@Override
-	public void set(Axolotl entity) {
-		if (variant != null)
-			entity.setVariant(variant);
+	public void set(Axolotl axolotl) {
+		Variant variant = this.variant;
+		if (variant == null)
+			variant = CollectionUtils.getRandom(VARIANTS);
+		assert variant != null;
+		axolotl.setVariant(variant);
 	}
 
 	@Override
-	protected boolean match(Axolotl entity) {
-		return variant == null || variant == entity.getVariant();
+	protected boolean match(Axolotl axolotl) {
+		return variant == null || variant == axolotl.getVariant();
 	}
 
 	@Override
@@ -58,27 +70,27 @@ public Class<? extends Axolotl> getType() {
 	}
 
 	@Override
-	public @NotNull EntityData getSuperType() {
-		return new AxolotlData(variant);
+	public @NotNull EntityData<?> getSuperType() {
+		return new AxolotlData();
 	}
 
 	@Override
 	protected int hashCode_i() {
-		return variant != null ? variant.hashCode() : 0;
+		return variant == null ? 0 : Objects.hashCode(variant);
 	}
 
 	@Override
-	protected boolean equals_i(EntityData<?> data) {
-		if (!(data instanceof AxolotlData))
+	protected boolean equals_i(EntityData<?> entityData) {
+		if (!(entityData instanceof AxolotlData other))
 			return false;
-		return variant == ((AxolotlData) data).variant;
+		return variant == other.variant;
 	}
 
 	@Override
-	public boolean isSupertypeOf(EntityData<?> data) {
-		if (!(data instanceof AxolotlData))
+	public boolean isSupertypeOf(EntityData<?> entityData) {
+		if (!(entityData instanceof AxolotlData other))
 			return false;
-		return variant == null || variant == ((AxolotlData) data).variant;
+		return variant == null || variant == other.variant;
 	}
 
 }