Finish remaining syntax

Author: Burbulinis

src/main/java/org/skriptlang/skript/bukkit/spawners/elements/conditions/CondIsActivated.java

@@ -6,6 +6,7 @@
 import org.bukkit.block.data.type.TrialSpawner.State;
 import org.skriptlang.skript.bukkit.spawners.SpawnerModule;
 import org.skriptlang.skript.bukkit.spawners.util.SpawnerUtils;
+import org.skriptlang.skript.registration.SyntaxRegistry;
 
 @Name("Spawner - Is Active")
 @Description(
@@ -18,22 +19,28 @@
 		"\tsend \"The spawner is activated!\""
 })
 @Since("INSERT VERSION")
-@RequiredPlugins("MC 1.21+")
+@RequiredPlugins("Minecraft 1.21+ (for trial spawners, spawner minecarts)")
 public class CondIsActivated extends PropertyCondition<Object> {
 
-	static {
-		register(SpawnerModule.SYNTAX_REGISTRY, CondIsActivated.class,
-			"[an] (activated|active) spawner", "blocks/entities/trialspawnerconfigs");
+	public static void register(SyntaxRegistry registry) {
+		registry.register(SyntaxRegistry.CONDITION, infoBuilder(CondIsActivated.class, PropertyType.BE,
+			"[an] (activated|active) spawner", SpawnerUtils.spawnerPropertyType)
+				.supplier(CondIsActivated::new)
+				.build()
+		);
 	}
 
 	@Override
 	public boolean check(Object object) {
-		if (SpawnerUtils.isSpawner(object)) {
-			return SpawnerUtils.getAsSkriptSpawner(object).isActivated();
+		if (SpawnerUtils.isCreatureSpawner(object)) {
+			return SpawnerUtils.getCreatureSpawner(object).isActivated();
+		} else if (SpawnerUtils.isSpawnerMinecart(object)) {
+			return SpawnerUtils.getSpawnerMinecart(object).isActivated();
 		} else if (SpawnerUtils.isTrialSpawner(object)) {
-			TrialSpawner data = ((TrialSpawner) SpawnerUtils.getAsSkriptTrialSpawner(object).getBlockData());
-			return data.getTrialSpawnerState() == State.ACTIVE;
+			TrialSpawner trialSpawner = (TrialSpawner) SpawnerUtils.getTrialSpawner(object).getBlockData();
+			return trialSpawner.getTrialSpawnerState() == State.ACTIVE;
 		}
+
 		return false;
 	}
 

src/main/java/org/skriptlang/skript/bukkit/spawners/elements/conditions/CondIsOminous.java

@@ -2,10 +2,9 @@
 
 import ch.njol.skript.conditions.base.PropertyCondition;
 import ch.njol.skript.doc.*;
-import org.bukkit.block.Block;
 import org.bukkit.block.TrialSpawner;
-import org.skriptlang.skript.bukkit.spawners.SpawnerModule;
-import org.skriptlang.skript.bukkit.spawners.util.TrialSpawnerConfig;
+import org.skriptlang.skript.bukkit.spawners.util.SpawnerUtils;
+import org.skriptlang.skript.registration.SyntaxRegistry;
 
 @Name("Trial Spawner - Is Ominous")
 @Description(
@@ -20,23 +19,27 @@
 		"\tsend \"That's true! The config is not ominous.\""
 })
 @Since("INSERT VERSION")
-@RequiredPlugins("MC 1.21+")
+@RequiredPlugins("Minecraft 1.21+")
 public class CondIsOminous extends PropertyCondition<Object> {
 
-	static {
-		register(SpawnerModule.SYNTAX_REGISTRY, CondIsOminous.class,
-			"ominous", "trialspawnerconfigs/blocks/blockdatas");
+	public static void register(SyntaxRegistry registry) {
+		if (!SpawnerUtils.IS_RUNNING_1_21)
+			return;
+		registry.register(SyntaxRegistry.CONDITION, infoBuilder(CondIsOminous.class, PropertyType.BE,
+			"ominous", "blocks/blockdatas")
+				.supplier(CondIsOminous::new)
+				.build()
+		);
 	}
 
 	@Override
 	public boolean check(Object object) {
-		if (object instanceof TrialSpawnerConfig config) {
-			return config.ominous();
-		} else if (object instanceof Block block && block.getState() instanceof TrialSpawner spawner) {
-			return spawner.isOminous();
+		if (SpawnerUtils.isTrialSpawner(object)) {
+			return SpawnerUtils.getTrialSpawner(object).isOminous();
 		} else if (object instanceof org.bukkit.block.data.type.TrialSpawner spawner) {
 			return spawner.isOminous();
 		}
+
 		return false;
 	}
 

src/main/java/org/skriptlang/skript/bukkit/spawners/elements/conditions/CondIsTracking.java

@@ -1,11 +1,14 @@
 package org.skriptlang.skript.bukkit.spawners.elements.conditions;
 
+import ch.njol.skript.conditions.base.PropertyCondition;
 import ch.njol.skript.doc.*;
 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.block.Block;
 import org.bukkit.block.TrialSpawner;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
@@ -29,72 +32,71 @@
 		"\tsend \"indeed! you are being tracked..\""
 })
 @Since("INSERT VERSION")
-@RequiredPlugins("MC 1.21+")
+@RequiredPlugins("Minecraft 1.21+")
 public class CondIsTracking extends Condition {
 
-	static {
-		var info = SyntaxInfo.builder(CondIsTracking.class)
-			.origin(SyntaxOrigin.of(SpawnerModule.ADDON))
+	public static void register(SyntaxRegistry registry) {
+		registry.register(SyntaxRegistry.CONDITION, SyntaxInfo.builder(CondIsTracking.class)
 			.supplier(CondIsTracking::new)
 			.priority(SyntaxInfo.COMBINED)
 			.addPatterns(
-				"%block/trialspawnerconfig% (is|are) [trial] spawner entity tracking %entities%",
-				"%block/trialspawnerconfig% (is|are) [trial] spawner player tracking %players%",
-				"%block/trialspawnerconfig% (isn't|is not|aren't|are not) [trial] spawner entity tracking %entities%",
-				"%block/trialspawnerconfig% (isn't|is not|aren't|are not) [trial] spawner player tracking %entities%")
-			.build();
-
-		SpawnerModule.SYNTAX_REGISTRY.register(SyntaxRegistry.CONDITION, info);
+				"%blocks% (is|are) player tracking %players%",
+				"%blocks% (isn't|is not|aren't|are not) player tracking %players%",
+				"%blocks% (is|are) entity tracking %entities%",
+				"%blocks% (isn't|is not|aren't|are not) entity tracking %entities%")
+			.build()
+		);
 	}
 
-	private Expression<?> spawner, entities;
+	private Expression<Block> spawners;
+	private Expression<Entity> entities;
 	private boolean player;
 
 	@Override
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		if (matchedPattern == 0 || matchedPattern == 2) {
-			spawner = exprs[0];
-			entities = exprs[1];
-		} else {
-			spawner = exprs[1];
-			entities = exprs[0];
-		}
-		player = matchedPattern == 1 || matchedPattern == 3;
-		setNegated(matchedPattern > 1);
+		//noinspection unchecked
+		spawners = (Expression<Block>) exprs[0];
+		//noinspection unchecked
+		entities = (Expression<Entity>) exprs[1];
+		player = matchedPattern < 2;
+		setNegated(matchedPattern == 1 || matchedPattern == 3);
 		return true;
 	}
 
 	@Override
 	public boolean check(Event event) {
-		Object object = this.spawner.getSingle(event);
-		if (object == null)
-			return isNegated();
-
-		if (!SpawnerUtils.isTrialSpawner(object))
-			return isNegated();
+		return spawners.check(event, block -> {
+			if (!SpawnerUtils.isTrialSpawner(block))
+				return false;
 
-		TrialSpawner spawner = SpawnerUtils.getAsSkriptTrialSpawner(object);
+			TrialSpawner spawner = SpawnerUtils.getTrialSpawner(block);
 
-		assert spawner != null;
+			return entities.check(event, entity -> {
+				if (player) {
+					return spawner.isTrackingPlayer((Player) entity);
+				} else {
+					return spawner.isTrackingEntity(entity);
+				}
+			});
 
-		return entities.check(event, entity -> {
-			if (player) {
-				return spawner.isTrackingPlayer((Player) entity);
-			} else {
-				return spawner.isTrackingEntity((Entity) entity);
-			}
 		}, isNegated());
 	}
 
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
 
-		builder.append(spawner);
+		builder.append(spawners);
 		if (isNegated()) {
-			builder.append("isn't tracking");
+			builder.append("aren't");
+		} else {
+			builder.append("are");
+		}
+
+		if (player) {
+			builder.append("player tracking");
 		} else {
-			builder.append("is tracking");
+			builder.append("entity tracking");
 		}
 		builder.append(entities);
 

src/main/java/org/skriptlang/skript/bukkit/spawners/elements/effects/EffEjectReward.java

@@ -5,6 +5,7 @@
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.util.Kleenean;
+import org.bukkit.block.Block;
 import org.bukkit.block.data.type.TrialSpawner;
 import org.bukkit.block.data.type.TrialSpawner.State;
 import org.bukkit.event.Event;
@@ -19,37 +20,36 @@
 @Description("Make a trial spawner or a trial spawner configuration eject a reward out of it.")
 @Examples("eject the trial spawner rewards of target block")
 @Since("INSERT VERSION")
-@RequiredPlugins("MC 1.21+")
+@RequiredPlugins("Minecraft 1.21+")
 public class EffEjectReward extends Effect {
 
-	static {
-		var info = SyntaxInfo.builder(EffEjectReward.class)
-			.origin(SyntaxOrigin.of(SpawnerModule.ADDON))
+	public static void register(SyntaxRegistry registry) {
+		registry.register(SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffEjectReward.class)
 			.supplier(EffEjectReward::new)
 			.priority(SyntaxInfo.COMBINED)
 			.addPatterns(
-				"eject [the] trial spawner reward[s] of %blocks/trialspawnerconfigs%",
-				"eject [the] %blocks/trialspawnerconfigs%'[s] trial spawner reward[s]")
-			.build();
-
-		SpawnerModule.SYNTAX_REGISTRY.register(SyntaxRegistry.EFFECT, info);
+				"(spit out|eject) [the] trial reward[s] of %blocks%",
+				"(spit out|eject) %blocks%'[s] trial reward[s]")
+			.build()
+		);
 	}
 
-	private Expression<?> objects;
+	private Expression<Block> blocks;
 
 	@Override
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		objects = exprs[0];
+		//noinspection unchecked
+		blocks = (Expression<Block>) exprs[0];
 		return true;
 	}
 
 	@Override
 	protected void execute(Event event) {
-		for (Object object : objects.getArray(event)) {
-			if (!SpawnerUtils.isTrialSpawner(object))
+		for (Block block : blocks.getArray(event)) {
+			if (!SpawnerUtils.isTrialSpawner(block))
 				continue;
 
-			org.bukkit.block.TrialSpawner state = SpawnerUtils.getAsSkriptTrialSpawner(object);
+			org.bukkit.block.TrialSpawner state = SpawnerUtils.getTrialSpawner(block);
 			TrialSpawner data = (TrialSpawner) state.getBlockData();
 
 			data.setTrialSpawnerState(State.EJECTING_REWARD);
@@ -60,7 +60,7 @@ protected void execute(Event event) {
 
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
-		return "eject trial spawner rewards from " + objects.toString(event, debug);
+		return "spit out the trial rewards of " + blocks.toString(event, debug);
 	}
 
 }

src/main/java/org/skriptlang/skript/bukkit/spawners/elements/effects/EffMakeOminous.java

@@ -12,6 +12,7 @@
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.bukkit.spawners.SpawnerModule;
+import org.skriptlang.skript.bukkit.spawners.util.SpawnerUtils;
 import org.skriptlang.skript.registration.SyntaxInfo;
 import org.skriptlang.skript.registration.SyntaxOrigin;
 import org.skriptlang.skript.registration.SyntaxRegistry;
@@ -25,18 +26,18 @@
 		"\tmake the trial spawner state of event-block ominous"
 })
 @Since("INSERT VERSION")
-@RequiredPlugins("MC 1.21+")
+@RequiredPlugins("Minecraft 1.21+")
 public class EffMakeOminous extends Effect {
 
-	static {
-		var info = SyntaxInfo.builder(EffMakeOminous.class)
-			.origin(SyntaxOrigin.of(SpawnerModule.ADDON))
+	public static void register(SyntaxRegistry registry) {
+		if (!SpawnerUtils.IS_RUNNING_1_21)
+			return;
+		registry.register(SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffMakeOminous.class)
 			.supplier(EffMakeOminous::new)
 			.priority(SyntaxInfo.COMBINED)
-			.addPatterns("make [the] trial spawner state of %blocks/blockdatas% (:ominous|normal)")
-			.build();
-
-		SpawnerModule.SYNTAX_REGISTRY.register(SyntaxRegistry.EFFECT, info);
+			.addPatterns("make %blocks/blockdatas% (:ominous|regular|normal)")
+			.build()
+		);
 	}
 
 	private boolean ominous;
@@ -65,11 +66,11 @@ protected void execute(Event event) {
 	public String toString(@Nullable Event event, boolean debug) {
 		SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug);
 
-		builder.append("make the trial spawner state of", spawners);
+		builder.append("make", spawners);
 		if (ominous) {
 			builder.append("ominous");
 		} else {
-			builder.append("regular");
+			builder.append("normal");
 		}
 
 		return builder.toString();

src/main/java/org/skriptlang/skript/bukkit/spawners/elements/effects/EffSpawnerItem.java

@@ -0,0 +1,63 @@
+package org.skriptlang.skript.bukkit.spawners.elements.effects;
+
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.util.Kleenean;
+import org.bukkit.block.CreatureSpawner;
+import org.bukkit.entity.minecart.SpawnerMinecart;
+import org.bukkit.event.Event;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.spawners.util.SpawnerUtils;
+import org.skriptlang.skript.registration.SyntaxInfo;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+public class EffSpawnerItem extends Effect {
+
+	public static void register(SyntaxRegistry registry) {
+		registry.register(SyntaxRegistry.EFFECT, SyntaxInfo.builder(EffSpawnerItem.class)
+			.supplier(EffSpawnerItem::new)
+			.priority(SyntaxInfo.COMBINED)
+			.addPatterns(
+				"make " + SpawnerUtils.spawnerPropertyType + " spawn %itemstack%",
+				"force " + SpawnerUtils.spawnerPropertyType + " to spawn %itemstack%")
+			.build()
+		);
+	}
+
+	private Expression<?> spawners;
+	private Expression<ItemStack> itemStack;
+
+	@Override
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		spawners = exprs[0];
+		//noinspection unchecked
+		itemStack = (Expression<ItemStack>) exprs[1];
+		return true;
+	}
+
+	@Override
+	protected void execute(Event event) {
+		ItemStack item = itemStack.getSingle(event);
+		if (item == null)
+			return;
+
+		for (Object object : spawners.getArray(event)) {
+			if (SpawnerUtils.isCreatureSpawner(object)) {
+				CreatureSpawner spawner = SpawnerUtils.getCreatureSpawner(object);
+				spawner.setSpawnedItem(item);
+				spawner.update(true, false);
+			} else if (SpawnerUtils.isSpawnerMinecart(object)) {
+				SpawnerMinecart minecart = SpawnerUtils.getSpawnerMinecart(object);
+				minecart.setSpawnedItem(item);
+			}
+		}
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "force " + spawners.toString(event, debug) + " to spawn " + itemStack.toString(event, debug);
+	}
+
+}