diff --git a/build.gradle b/build.gradle
index fcd904d9863..4cc665864db 100644
--- a/build.gradle
+++ b/build.gradle
@@ -5,7 +5,6 @@ import java.time.LocalTime
 
 plugins {
 	id 'com.github.johnrengelman.shadow' version '8.1.1'
-	id 'com.github.hierynomus.license' version '0.16.1'
 	id 'maven-publish'
 	id 'java'
 }
@@ -55,7 +54,7 @@ task checkAliases {
 }
 
 task testJar(type: ShadowJar) {
-	dependsOn(compileTestJava, licenseTest)
+	dependsOn(compileTestJava)
 	archiveFileName = 'Skript-JUnit.jar'
 	from sourceSets.test.output, sourceSets.main.output, project.configurations.testShadow
 }
@@ -141,15 +140,6 @@ publishing {
 	}
 }
 
-license {
-	header file('licenseheader.txt')
-	exclude('**/Metrics.java') // Not under GPLv3
-	exclude('**/BurgerHelper.java') // Not exclusively GPLv3
-	exclude('**/*.sk') // Sample scripts and maybe aliases
-	exclude('**/*.lang') // Language files do not have headers (still under GPLv3)
-	exclude('**/*.json') // JSON files do not have headers
-}
-
 task releaseJavadoc(type: Javadoc) {
 	title = project.name + ' ' + project.property('version')
 	source = sourceSets.main.allJava
@@ -204,7 +194,6 @@ void createTestTask(String name, String desc, String environments, int javaVersi
 	}
 	tasks.register(name, JavaExec) {
 		description = desc
-		dependsOn licenseTest
 		if (junit) {
 			dependsOn testJar
 		} else if (releaseDocs) {
@@ -307,7 +296,7 @@ task githubResources(type: ProcessResources) {
 		include '**'
 		version = project.property('version')
 		def channel = 'stable'
-		if (version.contains('pre'))
+		if (version.contains('-'))
 			channel = 'prerelease'
 		filter ReplaceTokens, tokens: [
 			'version'         : version,
@@ -340,7 +329,7 @@ task spigotResources(type: ProcessResources) {
 		include '**'
 		version = project.property('version')
 		def channel = 'stable'
-		if (version.contains('pre'))
+		if (version.contains('-'))
 			channel = 'prerelease'
 		filter ReplaceTokens, tokens: [
 			'version'         : version,
@@ -388,7 +377,7 @@ task nightlyResources(type: ProcessResources) {
 
 task nightlyRelease(type: ShadowJar) {
 	from sourceSets.main.output
-	dependsOn nightlyResources, licenseMain
+	dependsOn nightlyResources
 	archiveFileName = 'Skript-nightly.jar'
 	manifest {
 		attributes(
diff --git a/code-conventions.md b/code-conventions.md
index f571429ddb7..25c6d5c4417 100644
--- a/code-conventions.md
+++ b/code-conventions.md
@@ -66,6 +66,9 @@ With the exception of contacting our own resources (e.g. to check for updates) c
 Code contributed must be licensed under GPLv3, by **you**.
 We expect that any code you contribute is either owned by you or you have explicit permission to provide and license it to us.
 
+Licenses do not need to be printed in individual files (or packages) unless the licence applying to the code in
+that file (or package) deviates from the licence scope of its containing package.
+
 Third party code (under a compatible licence) _may_ be accepted in the following cases:
  - It is part of a public, freely-available library or resource.
  - It is somehow necessary to your contribution, and you have been given permission to include it.
@@ -75,34 +78,61 @@ If we receive complaints regarding the licensing of a contribution we will forwa
 
 If you have questions or complaints regarding the licensing or reproduction of a contribution you may contact us (the organisation) or the contributor of that code directly.
 
-If, in the future, we need to relicense contributed code, we will contact all contributors involved.
+If, in the future, we need to re-license contributed code, we will contact all contributors involved.
 If we need to remove or alter contributed code due to a licensing issue we will attempt to notify its contributor.
 
 
 ## Code Style
 
 ### Formatting
+* Imports should be grouped together by type (e.g. all `java.lang...` imports together)
+  * Following the style of existing imports in a class is encouraged, but not required
+  * Wildcard `*` imports are permitted (as long as they do not interfere with existing imports), e.g. `java.lang.*`.
 * Tabs, no spaces (unless in code imported from other projects)
-** No tabs/spaces in empty lines
+	- No tabs/spaces in empty lines
 * No trailing whitespace
 * At most 120 characters per line
-  - In Javadoc/multiline comments, at most 80 characters per line
-* When statements consume multiple lines, all lines but first have two tabs of additional indentation
+  	- In Javadoc/multiline comments, at most 80 characters per line
+* When statements consume multiple lines, all lines but the first have two tabs of additional indentation
+	- The exception to this is breaking up conditional statements (e.g. `if (x || y)`) where the
+    condition starts may be aligned
 * Each class begins with an empty line
 * No squeezing of multiple lines of code on a single line
 * Separate method declarations with empty lines
-  - Empty line after last method in a class is *not* required
-  - Otherwise, empty line before and after method is a good rule of thumb
+  	- Empty line after last method in a class is *not* required
+  	- Otherwise, empty line before and after method is a good rule of thumb
 * If fields have Javadoc, separate them with empty lines
 * Use empty lines liberally inside methods to improve readability
 * Use curly brackets to start and end most blocks
-  - Only when a conditional block (if or else) contains a single statement, they may be omitted
-  - When omitting brackets, still indent as if the code had brackets
-  - Avoid omitting brackets if it produces hard-to-read code
+  	- When a block contains a single statement, they may be omitted
+	    - Brackets may not be omitted in a chain of other blocks that require brackets, e.g `if ... else {}`
+  	- When omitting brackets, still indent as if the code had brackets
+  	- Avoid omitting brackets if it produces hard-to-read or ambiguous code
+* Ternaries should be avoided where it makes the code complex or difficult to read
 * Annotations for methods and classes are placed in lines before their declarations, one per line
-* When there are multiple annotations, place them in order:
-  - @Override -> @Nullable -> @SuppressWarnings
-  - For other annotations, doesn't matter; let your IDE decide
+  - Annotations for a structure go on the line before that structure
+      ```java 
+      @Override
+      @SuppressWarnings("xyz")
+      public void myMethod() {
+            // Override goes above method because method is overriding
+      }
+      ```
+    
+  - Annotations for the _value_ of a thing go before that value's type declaration
+      ```java 
+      @Override
+      public @Nullable Object myMethod() {
+          // Nullable goes before Object because Object is Nullable
+      }
+      ```
+* When there are multiple annotations, it looks nicer to place them in length order (longest last) 
+but this is not strictly required:
+	```java 
+	@Override
+	@Deprecated
+	@SuppressWarnings("xyz")
+	```
 * When splitting Strings into multiple lines the last part of the string must be (space character included) " " +
   ```java
   String string = "example string " +
@@ -111,6 +141,7 @@ If we need to remove or alter contributed code due to a licensing issue we will
   
 * When extending one of following classes: SimpleExpression, SimplePropertyExpression, Effect, Condition...
   - Put overridden methods in order
+  - Put static registration before all methods
   - SimpleExpression: init -> get/getAll -> acceptChange -> change -> setTime -> getTime -> isSingle -> getReturnType -> toString
   - SimplePropertyExpression: -> init -> convert -> acceptChange -> change -> setTime -> getTime -> getReturnType -> getPropertyName
   - Effect: init ->  execute  -> toString
@@ -130,8 +161,8 @@ If we need to remove or alter contributed code due to a licensing issue we will
 * Use prefixes only where their use has been already established (such as `ExprSomeRandomThing`)
   - Otherwise, use postfixes where necessary
   - Common occurrences include: Struct (Structure), Sec (Section), EffSec (EffectSection), Eff (Effect), Cond (Condition), Expr (Expression)
-* Ensure variable/field names are descriptive. Avoid using shorthand names like `e`, or `c`.
-  - e.g. Event should be `event`, not `e`. `e` is ambiguous and could mean a number of things.
+* Ensure variable/field names are descriptive. Avoid using shorthand names like `e`, or `c`
+  - e.g. Event should be `event`, not `e`. `e` is ambiguous and could mean a number of things
   
 ### Comments
 * Prefer to comment *why* you're doing things instead of how you're doing them
@@ -163,33 +194,79 @@ Your comments should look something like these:
 ## Language Features
 
 ### Compatibility
-* Contributions should maintain Java 8 source/binary compatibility, even though compiling Skript requires Java 21
-  - Users must not need JRE newer than version 8
+[//]: # (To be updated after feature/2.9 for Java 17)
+* Contributions should maintain Java 11 source/binary compatibility, even though compiling Skript requires Java 21
+  - Users must not need JRE newer than version 11
 * Versions up to and including Java 21 should work too
   - Please avoid using unsafe reflection
 * It is recommended to make fields final, if they are effectively final
-* Local variables and method parameters should not be declared final
+* Local variables and method parameters should not be declared final unless used in anonymous classes, lambdas
+or try-with-resources sections where their immutability is necessary
 * Methods should be declared final only where necessary
 * Use `@Override` whenever applicable
-
-### Nullness
+  - They may be omitted to prevent compilation errors when something overrides only
+  on a version-dependent basis (e.g. in Library XYZ version 2 we override `getX()` but in version 3 it's
+  gone, and we call it ourselves)
+
+### null-ness
+* We use **JetBrains** Annotations for specifying null-ness and method contracts.
+  * If editing a file using a different annotation set (e.g. Javax, Eclipse Sisu, Bukkit)
+  these should be replaced with their JetBrains equivalent.
+  * The semantics for JetBrains Annotations are strict _and should be observed!_
+    * Many IDEs have built-in compiler-level support for these, and can even be set to produce strict
+    errors when an annotation is misused; do not misuse them.
+  * **`@NotNull`**
+    * > An element annotated with NotNull claims null value is forbidden to return (for methods), 
+    pass to (parameters) and hold (local variables and fields).
+	* Something is `@NotNull` iff it is never null from its inception (new X) to its garbage collection, 
+    i.e. there is no point in time at which the value could ever be null.
+  * **`@Nullable`**
+    * > An element annotated with Nullable claims null value is perfectly valid to return (for methods), 
+	  > pass to (parameters) or hold in (local variables and fields). 
+	  > 
+	  > By convention, this annotation applied only when the value should always be checked 
+	  > against null because the developer could do nothing to prevent null from happening.
+	* Something is `@Nullable` iff there is _absolutely no way of determining_ (other than checking its 
+    value `!= null`) whether it is null.
+    * In other words, if there is another way of knowing (e.g. you set it yourself, an `isPresent` method, etc.)
+    then it should not be marked nullable.
+  * **`@Contract`**
+    * The contract annotation should be used to express other behaviour (e.g. null depending on parameters).
 * All fields, method parameters and their return values are non-null by default
-  - Exceptions: Github API JSON mappings, Metrics
-* When something is nullable, mark it as so
-* Only ignore nullness errors when a variable is effectively non-null - if in doubt: check
-  - Most common example is syntax elements, which are not initialised using a constructor
+  - Exceptions: GitHub API JSON mappings, Metrics
+* When ignoring warnings, use the no-inspection comment rather than a blanket suppression annotation
 * Use assertions liberally: if you're sure something is not null, assert so to the compiler
   - Makes finding bugs easier for developers
-* Assertions must **not** have side-effects - they may be skipped in real environments
+* Assertions must **not** have side-effects in non-test packages - they may be skipped in real environments
 * Avoid checking non-null values for nullability
   - Unless working around buggy addons, it is rarely necessary
-  - This is why ignoring nullness errors is particularly dangerous
+  - This is why ignoring null-ness errors is particularly dangerous
+* Annotations on array types **must** be placed properly:
+  * Annotations on the array itself go before the array brackets
+	```java
+	@Nullable Object @NotNull []
+	// a not-null array of nullable objects
+	```
+  * Annotations on values inside the array go before the value declaration
+	```java
+	@NotNull Object @Nullable []
+	// a nullable array of not-null objects
+	```
+  * If this is not adhered to, an IDE may provide incorrect feedback.
 
 ### Assertions
 
 Skript must run with assertations enabled; use them in your development environment. \
 The JVM flag <code>-ea</code> is used to enable them.
 
+## Code Complexity
+
+Dense, highly-complex code should be avoided to preserve readability and to help with future maintenance, 
+especially within a single method body.
+
+There are many available metrics for measuring code complexity (for different purposes); [we have our own](https://stable.skriptlang.org/Radical_Complexity.pdf).
+There are no strict limits for code complexity, but you may be encouraged (or required) to reformat or break up methods
+into smaller, more manageable chunks. If in doubt, keep things simple.
 
 ## Minecraft Features
 
diff --git a/gradle.properties b/gradle.properties
index 7753116b0ea..0b5b23f30d5 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -5,7 +5,7 @@ org.gradle.parallel=true
 
 groupid=ch.njol
 name=skript
-version=2.8.5
+version=2.8.6
 jarName=Skript.jar
 testEnv=java21/paper-1.20.6
 testEnvJavaVersion=21
diff --git a/licenseheader.txt b/licenseheader.txt
deleted file mode 100644
index 15be760be16..00000000000
--- a/licenseheader.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-  This file is part of Skript.
-
- Skript is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Skript is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with Skript.  If not, see <http://www.gnu.org/licenses/>.
-
-Copyright Peter Güttinger, SkriptLang team and contributors
\ No newline at end of file
diff --git a/src/main/java/ch/njol/skript/SkriptCommand.java b/src/main/java/ch/njol/skript/SkriptCommand.java
index 62261d0e426..0bc25391267 100644
--- a/src/main/java/ch/njol/skript/SkriptCommand.java
+++ b/src/main/java/ch/njol/skript/SkriptCommand.java
@@ -62,19 +62,19 @@ public class SkriptCommand implements CommandExecutor {
 	// TODO /skript scripts show/list - lists all enabled and/or disabled scripts in the scripts folder and/or subfolders (maybe add a pattern [using * and **])
 	// TODO document this command on the website
 	private static final CommandHelp SKRIPT_COMMAND_HELP = new CommandHelp("<gray>/<gold>skript", SkriptColor.LIGHT_CYAN, CONFIG_NODE + ".help")
-		.add(new CommandHelp("reload", SkriptColor.DARK_RED)
+		.add(new CommandHelp("reload", SkriptColor.DARK_CYAN)
 			.add("all")
 			.add("config")
 			.add("aliases")
 			.add("scripts")
 			.add("<script>")
-		).add(new CommandHelp("enable", SkriptColor.DARK_RED)
+		).add(new CommandHelp("enable", SkriptColor.DARK_CYAN)
 			.add("all")
 			.add("<script>")
-		).add(new CommandHelp("disable", SkriptColor.DARK_RED)
+		).add(new CommandHelp("disable", SkriptColor.DARK_CYAN)
 			.add("all")
 			.add("<script>")
-		).add(new CommandHelp("update", SkriptColor.DARK_RED)
+		).add(new CommandHelp("update", SkriptColor.DARK_CYAN)
 			.add("check")
 			.add("changes")
 			.add("download")
diff --git a/src/main/java/ch/njol/skript/SkriptConfig.java b/src/main/java/ch/njol/skript/SkriptConfig.java
index 5d9f9254d44..5a3bb954cd4 100644
--- a/src/main/java/ch/njol/skript/SkriptConfig.java
+++ b/src/main/java/ch/njol/skript/SkriptConfig.java
@@ -105,7 +105,7 @@ public class SkriptConfig {
 						break;
 					case "stable":
 						// TODO a better option would be to check that it is not a pre-release through GH API
-						channel = new ReleaseChannel((name) -> !name.contains("pre"), t);
+						channel = new ReleaseChannel((name) -> !(name.contains("-")), t);
 						break;
 					case "none":
 						channel = new ReleaseChannel((name) -> false, t);
diff --git a/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java b/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java
index f7812d52f32..7dc7149ce4f 100644
--- a/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java
+++ b/src/main/java/ch/njol/skript/bukkitutil/PaperEntityUtils.java
@@ -114,8 +114,8 @@ public static void lookAt(LookAnchor entityAnchor, Object target, @Nullable Floa
 				Player player = (Player) entity;
 				if (target instanceof Vector) {
 					Vector vector = (Vector) target;
-					player.lookAt(vector.getX(), vector.getY(), vector.getZ(), LookAnchor.EYES);
-					player.lookAt(vector.getX(), vector.getY(), vector.getZ(), LookAnchor.FEET);
+					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);
@@ -159,7 +159,7 @@ public void tick() {
 			switch (type) {
 				case VECTOR:
 					Vector vector = ((Vector)target);
-					mob.lookAt(vector.getX(), vector.getY(), vector.getZ(), speed, maxPitch);
+					mob.lookAt(mob.getEyeLocation().add(vector), speed, maxPitch);
 					break;
 				case LOCATION:
 					mob.lookAt((Location) target, speed, maxPitch);
diff --git a/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java b/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
index 7123ede168d..e1001a0afa4 100644
--- a/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
+++ b/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
@@ -100,6 +100,7 @@
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.EntityDropItemEvent;
 import org.bukkit.event.entity.EntityEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.entity.EntityResurrectEvent;
@@ -799,6 +800,19 @@ public ItemStack get(final PlayerDropItemEvent e) {
 				return e.getItemDrop().getItemStack();
 			}
 		}, 0);
+		// EntityDropItemEvent
+		EventValues.registerEventValue(EntityDropItemEvent.class, Item.class, new Getter<Item, EntityDropItemEvent>() {
+			@Override
+			public Item get(EntityDropItemEvent event) {
+				return event.getItemDrop();
+			}
+		}, EventValues.TIME_NOW);
+		EventValues.registerEventValue(EntityDropItemEvent.class, ItemStack.class, new Getter<ItemStack, EntityDropItemEvent>() {
+			@Override
+			public ItemStack get(EntityDropItemEvent event) {
+				return event.getItemDrop().getItemStack();
+			}
+		}, EventValues.TIME_NOW);
 		// PlayerPickupItemEvent
 		EventValues.registerEventValue(PlayerPickupItemEvent.class, Player.class, new Getter<Player, PlayerPickupItemEvent>() {
 			@Override
diff --git a/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java b/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java
index 495ca362eab..00f419f4901 100644
--- a/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java
+++ b/src/main/java/ch/njol/skript/classes/data/DefaultConverters.java
@@ -151,6 +151,7 @@ public DefaultConverters() {}
 				return (InventoryHolder) s;
 			return null;
 		}, Converter.NO_RIGHT_CHAINING | Commands.CONVERTER_NO_COMMAND_ARGUMENTS);
+
 		Converters.registerConverter(InventoryHolder.class, Block.class, holder -> {
 			if (holder instanceof BlockState)
 				return new BlockInventoryHolder((BlockState) holder);
@@ -165,7 +166,19 @@ public DefaultConverters() {}
 				return (Entity) holder;
 			return null;
 		}, Converter.NO_CHAINING);
-		
+
+		// InventoryHolder - Location
+		// since the individual ones can't be trusted to chain.
+		Converters.registerConverter(InventoryHolder.class, Location.class, holder -> {
+			if (holder instanceof Entity)
+				return ((Entity) holder).getLocation();
+			if (holder instanceof Block)
+				return ((Block) holder).getLocation();
+			if (holder instanceof BlockState)
+				return BlockUtils.getLocation(((BlockState) holder).getBlock());
+			return null;
+		});
+
 		// Enchantment - EnchantmentType
 		Converters.registerConverter(Enchantment.class, EnchantmentType.class, e -> new EnchantmentType(e, -1));
 
diff --git a/src/main/java/ch/njol/skript/entity/DroppedItemData.java b/src/main/java/ch/njol/skript/entity/DroppedItemData.java
index 06d38d1a2fc..e9b136407c1 100644
--- a/src/main/java/ch/njol/skript/entity/DroppedItemData.java
+++ b/src/main/java/ch/njol/skript/entity/DroppedItemData.java
@@ -18,11 +18,16 @@
  */
 package ch.njol.skript.entity;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.Arrays;
+import java.util.function.Consumer;
 
+import ch.njol.skript.Skript;
+import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.entity.Item;
 import org.bukkit.inventory.ItemStack;
-import org.eclipse.jdt.annotation.Nullable;
 
 import ch.njol.skript.aliases.ItemType;
 import ch.njol.skript.lang.Literal;
@@ -32,71 +37,76 @@
 import ch.njol.skript.localization.Noun;
 import ch.njol.skript.registrations.Classes;
 import ch.njol.util.coll.CollectionUtils;
+import org.jetbrains.annotations.Nullable;
 
-/**
- * @author Peter Güttinger
- */
 public class DroppedItemData extends EntityData<Item> {
+
+	private static final boolean HAS_JAVA_CONSUMER_DROP = Skript.methodExists(World.class, "dropItem", Location.class, ItemStack.class, Consumer.class);
+	private static @Nullable Method BUKKIT_CONSUMER_DROP;
+
 	static {
 		EntityData.register(DroppedItemData.class, "dropped item", Item.class, "dropped item");
+
+		try {
+			BUKKIT_CONSUMER_DROP = World.class.getDeclaredMethod("dropItem", Location.class, ItemStack.class, org.bukkit.util.Consumer.class);
+		} catch (NoSuchMethodException | SecurityException ignored) {}
 	}
 	
 	private final static Adjective m_adjective = new Adjective("entities.dropped item.adjective");
-	
-	@Nullable
-	private ItemType[] types;
+
+	private ItemType @Nullable [] types;
 	
 	public DroppedItemData() {}
 	
-	public DroppedItemData(@Nullable ItemType[] types) {
+	public DroppedItemData(ItemType @Nullable [] types) {
 		this.types = types;
 	}
 	
 	@Override
-	protected boolean init(final Literal<?>[] exprs, final int matchedPattern, final ParseResult parseResult) {
-		if (exprs.length > 0 && exprs[0] != null)
-			types = (ItemType[]) exprs[0].getAll();
+	protected boolean init(Literal<?>[] expressions, int matchedPattern, ParseResult parseResult) {
+		if (expressions.length > 0 && expressions[0] != null)
+			types = (ItemType[]) expressions[0].getAll();
 		return true;
 	}
 	
 	@Override
-	protected boolean init(final @Nullable Class<? extends Item> c, final @Nullable Item e) {
-		if (e != null) {
-			final ItemStack i = e.getItemStack();
+	protected boolean init(@Nullable Class<? extends Item> clazz, @Nullable Item itemEntity) {
+		if (itemEntity != null) {
+			final ItemStack i = itemEntity.getItemStack();
 			types = new ItemType[] {new ItemType(i)};
 		}
 		return true;
 	}
 	
 	@Override
-	protected boolean match(final Item entity) {
+	protected boolean match(Item entity) {
 		if (types != null) {
-			for (final ItemType t : types) {
+			for (ItemType t : types) {
 				if (t.isOfType(entity.getItemStack()))
 					return true;
 			}
 			return false;
-		} else {
-			return true;
 		}
+		return true;
 	}
 	
 	@Override
 	public void set(final Item entity) {
+		if (types == null)
+			return;
 		final ItemType t = CollectionUtils.getRandom(types);
 		assert t != null;
 		ItemStack stack = t.getItem().getRandom();
-		if (stack != null)
-			entity.setItemStack(stack);
+		entity.setItemStack(stack);
 	}
 	
 	@Override
-	public boolean isSupertypeOf(final EntityData<?> e) {
-		if (!(e instanceof DroppedItemData))
+	public boolean isSupertypeOf(EntityData<?> otherData) {
+		if (!(otherData instanceof DroppedItemData))
 			return false;
-		final DroppedItemData d = (DroppedItemData) e;
+		DroppedItemData otherItemData = (DroppedItemData) otherData;
 		if (types != null)
-			return d.types != null && ItemType.isSubset(types, d.types);
+			return otherItemData.types != null && ItemType.isSubset(types, otherItemData.types);
 		return true;
 	}
 	
@@ -111,36 +121,66 @@ public EntityData getSuperType() {
 	}
 	
 	@Override
-	public String toString(final int flags) {
-		final ItemType[] types = this.types;
+	public String toString(int flags) {
 		if (types == null)
 			return super.toString(flags);
-		final StringBuilder b = new StringBuilder();
-		b.append(Noun.getArticleWithSpace(types[0].getTypes().get(0).getGender(), flags));
-		b.append(m_adjective.toString(types[0].getTypes().get(0).getGender(), flags));
-		b.append(" ");
-		b.append(Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false));
-		return "" + b.toString();
+		int gender = types[0].getTypes().get(0).getGender();
+		return Noun.getArticleWithSpace(gender, flags) +
+				m_adjective.toString(gender, flags) +
+				" " +
+				Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false);
 	}
-	
-//		return ItemType.serialize(types);
+
 	@Override
 	@Deprecated
-	protected boolean deserialize(final String s) {
+	protected boolean deserialize(String s) {
 		throw new UnsupportedOperationException("old serialization is no longer supported");
-//		if (s.isEmpty())
-//			return true;
-//		types = ItemType.deserialize(s);
-//		return types != null;
 	}
 	
 	@Override
-	protected boolean equals_i(final EntityData<?> obj) {
-		if (!(obj instanceof DroppedItemData))
+	protected boolean equals_i(EntityData<?> otherData) {
+		if (!(otherData instanceof DroppedItemData))
 			return false;
-		return Arrays.equals(types, ((DroppedItemData) obj).types);
+		return Arrays.equals(types, ((DroppedItemData) otherData).types);
 	}
-	
+
+	@Override
+	public boolean canSpawn(@Nullable World world) {
+		return types != null && types.length > 0 && world != null;
+	}
+
+	@Override
+	public @Nullable Item spawn(Location location, @Nullable Consumer<Item> consumer) {
+		World world = location.getWorld();
+		if (!canSpawn(world))
+			return null;
+		assert types != null && types.length > 0;
+
+		final ItemType itemType = CollectionUtils.getRandom(types);
+		assert itemType != null;
+		ItemStack stack = itemType.getItem().getRandom();
+
+		Item item;
+		if (consumer == null) {
+			item = world.dropItem(location, stack);
+		} else if (HAS_JAVA_CONSUMER_DROP) {
+			item = world.dropItem(location, stack, consumer);
+		} else if (BUKKIT_CONSUMER_DROP != null) {
+			try {
+				// noinspection deprecation
+				item = (Item) BUKKIT_CONSUMER_DROP.invoke(world, location, stack, (org.bukkit.util.Consumer<Item>) consumer::accept);
+			} catch (InvocationTargetException | IllegalAccessException e) {
+				if (Skript.testing())
+					Skript.exception(e, "Can't spawn " + this.getName());
+				return null;
+			}
+		} else {
+			item = world.dropItem(location, stack);
+			consumer.accept(item);
+		}
+		return item;
+	}
+
 	@Override
 	protected int hashCode_i() {
 		return Arrays.hashCode(types);
diff --git a/src/main/java/ch/njol/skript/entity/FishData.java b/src/main/java/ch/njol/skript/entity/FishData.java
deleted file mode 100644
index c3694a12f6b..00000000000
--- a/src/main/java/ch/njol/skript/entity/FishData.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/**
- *   This file is part of Skript.
- *
- *  Skript is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  Skript is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Copyright Peter Güttinger, SkriptLang team and contributors
- */
-package ch.njol.skript.entity;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ThreadLocalRandom;
-
-import org.bukkit.entity.Cod;
-import org.bukkit.entity.Fish;
-import org.bukkit.entity.PufferFish;
-import org.bukkit.entity.Salmon;
-import org.bukkit.entity.Tadpole;
-import org.bukkit.entity.TropicalFish;
-import org.eclipse.jdt.annotation.Nullable;
-
-import ch.njol.skript.Skript;
-import ch.njol.skript.lang.Literal;
-import ch.njol.skript.lang.SkriptParser.ParseResult;
-
-public class FishData extends EntityData<Fish> {
-
-	private static final boolean HAS_TADPOLE = Skript.classExists("org.bukkit.entity.Tadpole");
-	private static final List<String> PATTERNS;
-
-	static {
-		PATTERNS = new ArrayList<>(Arrays.asList("fish", "cod", "puffer fish", "salmon", "tropical fish"));
-		if (HAS_TADPOLE)
-			PATTERNS.add("tadpole");
-		register(FishData.class, "fish", Fish.class, 0, PATTERNS.toArray(new String[0]));
-	}
-	
-	private boolean init = true;
-	private boolean wildcard = false;
-	private int pattern = -1;
-	
-	public FishData() {}
-	
-	public FishData(int pattern) {
-		this.pattern = pattern;
-		super.matchedPattern = pattern;
-	}
-	
-	@Override
-	protected boolean init(Literal<?>[] exprs, int matchedPattern, ParseResult parseResult) {
-		if (matchedPattern == 0)
-			wildcard = true;
-		pattern = (matchedPattern == 0) ? ThreadLocalRandom.current().nextInt(1, PATTERNS.size()) : matchedPattern;
-		return true;
-	}
-
-	@Override
-	protected boolean init(@Nullable Class<? extends Fish> c, @Nullable Fish e) {
-		int matchedPattern = getInitPattern(e);
-		if (matchedPattern == 0)
-			wildcard = true;
-		pattern = (matchedPattern == 0) ? ThreadLocalRandom.current().nextInt(1, PATTERNS.size()) : matchedPattern;
-		return true;
-	}
-
-	@Override
-	public void set(Fish entity) {
-		// Setting of entity already handled by init() functions 
-	}
-
-	@Override
-	protected boolean match(Fish entity) {
-		return wildcard ? true : getPattern(entity) == pattern;
-	}
-
-	@Override
-	public Class<? extends Fish> getType() {
-		if (!init && wildcard)
-			return Fish.class;
-		init = false;
-		switch (pattern) {
-			case 1:
-				return Cod.class;
-			case 2:
-				return PufferFish.class;
-			case 3:
-				return Salmon.class;
-			case 4:
-				return TropicalFish.class;
-			case 5:
-				return Tadpole.class;
-		}
-		return Fish.class;
-	}
-
-	@Override
-	public EntityData getSuperType() {
-		return new FishData(pattern);
-	}
-
-	@Override
-	protected int hashCode_i() {
-		return wildcard ? 0 : pattern;
-	}
-
-	@Override
-	protected boolean equals_i(EntityData<?> entityData) {
-		return entityData instanceof Fish ? (wildcard ? true : getPattern((Fish) entityData) == pattern) : false;
-	}
-
-	@Override
-	public boolean isSupertypeOf(EntityData<?> entityData) {
-		return entityData instanceof Fish ? (wildcard ? true : getPattern((Fish) entityData) == pattern) : false;
-	}
-	
-	private static int getInitPattern(@Nullable Fish fish) {
-		if (fish == null)
-			return 0;
-		else if (fish instanceof Cod)
-			return 1;
-		else if (fish instanceof PufferFish)
-			return 2;
-		else if (fish instanceof Salmon)
-			return 3;
-		else if (fish instanceof TropicalFish)
-			return 4;
-		else if (HAS_TADPOLE && fish instanceof Tadpole)
-			return 5;
-		return 0;
-	}
-	
-	private int getPattern(@Nullable Fish fish) {
-		int p = getInitPattern(fish);
-		return p == 0 ? pattern : p;
-	}
-	
-}
diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java
index 93c690d6926..6cad5ec1a2c 100644
--- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java
+++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java
@@ -336,6 +336,7 @@ private static void addSuperEntity(String codeName, Class<? extends Entity> enti
 		addSuperEntity("mob", Mob.class);
 		addSuperEntity("creature", Creature.class);
 		addSuperEntity("animal", Animals.class);
+		addSuperEntity("fish", Fish.class);
 		addSuperEntity("golem", Golem.class);
 		addSuperEntity("projectile", Projectile.class);
 		addSuperEntity("living entity", LivingEntity.class);
diff --git a/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java b/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java
index d08200c7e1a..1e0f9ec0d50 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprExplodedBlocks.java
@@ -20,6 +20,8 @@
 
 import java.util.List;
 
+import ch.njol.skript.classes.Changer.ChangeMode;
+import ch.njol.util.coll.CollectionUtils;
 import org.bukkit.block.Block;
 import org.bukkit.event.Event;
 import org.bukkit.event.entity.EntityExplodeEvent;
@@ -38,12 +40,27 @@
 import ch.njol.util.Kleenean;
 
 @Name("Exploded Blocks")
-@Description("Get all the blocks that were destroyed in an explode event")
-@Examples({"on explode:",
-	"\tloop exploded blocks:",
-	"\t\tadd loop-block to {exploded::blocks::*}"})
+@Description("Get all the blocks that were destroyed in an explode event. Supports add/remove/set/clear/delete blocks.")
+@Examples({
+	"on explode:",
+		"\tloop exploded blocks:",
+			"\t\tadd loop-block to {exploded::blocks::*}",
+	"",
+	"on explode:",
+		"\tloop exploded blocks:",
+			"\t\tif loop-block is grass:",
+				"\t\t\tremove loop-block from exploded blocks",
+	"",
+	"on explode:",
+		"\tclear exploded blocks",
+	"",
+	"on explode:",
+		"\tset exploded blocks to blocks in radius 10 around event-entity",
+	"",
+	"on explode:",
+		"\tadd blocks above event-entity to exploded blocks"})
 @Events("explode")
-@Since("2.5")
+@Since("2.5, 2.8.6 (modify blocks)")
 public class ExprExplodedBlocks extends SimpleExpression<Block> {
 
 	static {
@@ -68,6 +85,47 @@ protected Block[] get(Event e) {
 		List<Block> blockList = ((EntityExplodeEvent) e).blockList();
 		return blockList.toArray(new Block[blockList.size()]);
 	}
+
+	@Override
+	public @Nullable Class<?>[] acceptChange(ChangeMode mode) {
+		switch (mode) {
+			case ADD:
+			case REMOVE:
+			case SET:
+			case DELETE:
+				return CollectionUtils.array(Block[].class);
+			default:
+				return null;
+		}
+	}
+
+	@Override
+	public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
+		if (!(event instanceof EntityExplodeEvent))
+			return;
+
+		List<Block> blocks = ((EntityExplodeEvent) event).blockList();
+		switch (mode) {
+			case DELETE:
+				blocks.clear();
+				break;
+			case SET:
+				blocks.clear();
+				// Fallthrough intended
+			case ADD:
+				for (Object object : delta) {
+					if (object instanceof Block)
+						blocks.add((Block) object);
+				}
+				break;
+			case REMOVE:
+				for (Object object : delta) {
+					if (object instanceof Block)
+						blocks.remove((Block) object);
+				}
+				break;
+		}
+	}
 	
 	@Override
 	public boolean isSingle() {
diff --git a/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java b/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
index 62f2a695e85..3b1ff35b6d9 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprVectorLength.java
@@ -18,6 +18,7 @@
  */
 package ch.njol.skript.expressions;
 
+import ch.njol.util.VectorMath;
 import org.bukkit.event.Event;
 import org.bukkit.util.Vector;
 import org.eclipse.jdt.annotation.Nullable;
@@ -70,7 +71,7 @@ public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
 				//$FALL-THROUGH$
 			case ADD:
 				for (Vector vector : vectors) {
-					if (deltaLength < 0 && vector.lengthSquared() < deltaLength * deltaLength) {
+					if (VectorMath.isZero(vector) || (deltaLength < 0 && vector.lengthSquared() < deltaLength * deltaLength)) {
 						vector.zero();
 					} else {
 						double newLength = deltaLength + vector.length();
@@ -82,7 +83,7 @@ public void change(Event event, @Nullable Object[] delta, ChangeMode mode) {
 				break;
 			case SET:
 				for (Vector vector : vectors) {
-					if (deltaLength < 0) {
+					if (deltaLength < 0 || VectorMath.isZero(vector)) {
 						vector.zero();
 					} else {
 						if (!vector.isNormalized())
diff --git a/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java b/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java
index db136199bbb..94dca461a5a 100644
--- a/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java
+++ b/src/main/java/ch/njol/skript/expressions/ExprVectorNormalize.java
@@ -18,6 +18,7 @@
  */
 package ch.njol.skript.expressions;
 
+import ch.njol.util.VectorMath;
 import org.bukkit.event.Event;
 import org.bukkit.util.Vector;
 import org.eclipse.jdt.annotation.Nullable;
@@ -63,7 +64,7 @@ protected Vector[] get(Event event) {
 		if (vector == null)
 			return null;
 		vector = vector.clone();
-		if (!vector.isNormalized())
+		if (!VectorMath.isZero(vector) && !vector.isNormalized())
 			vector.normalize();
 		return CollectionUtils.array(vector);
 	}
diff --git a/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java b/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java
index 0f72b2cb87e..4e928b285ec 100644
--- a/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java
+++ b/src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java
@@ -43,7 +43,9 @@
 
 import java.lang.reflect.Array;
 import java.util.ArrayList;
+import java.util.Set;
 import java.util.List;
+import java.util.Collection;
 
 @Name("Arithmetic")
 @Description("Arithmetic expressions, e.g. 1 + 2, (health of player - 2) / 3, etc.")
@@ -108,6 +110,7 @@ public PatternInfo(Operator operator, boolean leftGrouped, boolean rightGrouped)
 	private Operator operator;
 
 	private Class<? extends T> returnType;
+	private Collection<Class<?>> knownReturnTypes;
 
 	// A chain of expressions and operators, alternating between the two. Always starts and ends with an expression.
 	private final List<Object> chain = new ArrayList<>();
@@ -250,10 +253,12 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			}
 			if (returnTypes == null) { // both are object; can't determine anything
 				returnType = (Class<? extends T>) Object.class;
+				knownReturnTypes = Arithmetics.getAllReturnTypes(operator);
 			} else if (returnTypes.length == 0) { // one of the classes is known but doesn't have any operations
 				return error(firstClass, secondClass);
 			} else {
 				returnType = (Class<? extends T>) Classes.getSuperClassInfo(returnTypes).getC();
+				knownReturnTypes = Set.of(returnTypes);
 			}
 		} else if (returnType == null) { // lookup
 			OperationInfo<L, R, T> operationInfo = (OperationInfo<L, R, T>) Arithmetics.lookupOperationInfo(operator, firstClass, secondClass);
@@ -328,6 +333,21 @@ public Class<? extends T> getReturnType() {
 		return returnType;
 	}
 
+	@Override
+	public Class<? extends T>[] possibleReturnTypes() {
+		if (returnType == Object.class)
+			//noinspection unchecked
+			return knownReturnTypes.toArray(new Class[0]);
+		return super.possibleReturnTypes();
+	}
+
+	@Override
+	public boolean canReturn(Class<?> returnType) {
+		if (this.returnType == Object.class && knownReturnTypes.contains(returnType))
+			return true;
+		return super.canReturn(returnType);
+	}
+
 	@Override
 	public boolean isSingle() {
 		return true;
diff --git a/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java b/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java
index fdec45e23b1..4274e4aef3a 100644
--- a/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java
+++ b/src/main/java/ch/njol/skript/expressions/base/WrapperExpression.java
@@ -146,5 +146,15 @@ public Expression<? extends T> simplify() {
 	public Object[] beforeChange(Expression<?> changed, @Nullable Object[] delta) {
 		return expr.beforeChange(changed, delta); // Forward to what we're wrapping
 	}
-	
+
+	@Override
+	public Class<? extends T>[] possibleReturnTypes() {
+		return expr.possibleReturnTypes();
+	}
+
+	@Override
+	public boolean canReturn(Class<?> returnType) {
+		return expr.canReturn(returnType);
+	}
+
 }
diff --git a/src/main/java/ch/njol/skript/lang/Expression.java b/src/main/java/ch/njol/skript/lang/Expression.java
index ebde53ee479..9c7439f7585 100644
--- a/src/main/java/ch/njol/skript/lang/Expression.java
+++ b/src/main/java/ch/njol/skript/lang/Expression.java
@@ -189,6 +189,31 @@ default boolean canBeSingle() {
 	 */
 	Class<? extends T> getReturnType();
 
+	/**
+	 * For expressions that might return multiple (incalculable at parse time) types,
+	 * this provides a list of all possible types.
+	 * Use cases include: expressions that depend on the return type of their input.
+	 *
+	 * @return A list of all possible types this might return
+	 */
+	default Class<? extends T>[] possibleReturnTypes() {
+		//noinspection unchecked
+		return new Class[] {this.getReturnType()};
+	}
+
+	/**
+	 * Whether this expression <b>might</b> return the following type.
+	 * @param returnType The type to test
+	 * @return true if the argument is within the bounds of the return types
+	 */
+	default boolean canReturn(Class<?> returnType) {
+		for (Class<?> type : this.possibleReturnTypes()) {
+			if (returnType.isAssignableFrom(type))
+				return true;
+		}
+		return false;
+	}
+
 	/**
 	 * Returns true if this expression returns all possible values, false if it only returns some of them.
 	 * <p>
diff --git a/src/main/java/ch/njol/skript/lang/ExpressionList.java b/src/main/java/ch/njol/skript/lang/ExpressionList.java
index 1440a84bd2e..fa6612b3422 100644
--- a/src/main/java/ch/njol/skript/lang/ExpressionList.java
+++ b/src/main/java/ch/njol/skript/lang/ExpressionList.java
@@ -43,6 +43,7 @@ public class ExpressionList<T> implements Expression<T> {
 
 	protected final Expression<? extends T>[] expressions;
 	private final Class<T> returnType;
+	private final Class<?>[] possibleReturnTypes;
 	protected boolean and;
 	private final boolean single;
 
@@ -53,10 +54,19 @@ public ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType
 		this(expressions, returnType, and, null);
 	}
 
+	public ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and) {
+		this(expressions, returnType, possibleReturnTypes, and, null);
+	}
+
 	protected ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, boolean and, @Nullable ExpressionList<?> source) {
+		this(expressions, returnType, new Class[]{returnType}, and, source);
+	}
+
+	protected ExpressionList(Expression<? extends T>[] expressions, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and, @Nullable ExpressionList<?> source) {
 		assert expressions != null;
 		this.expressions = expressions;
 		this.returnType = returnType;
+		this.possibleReturnTypes = possibleReturnTypes;
 		this.and = and;
 		if (and) {
 			single = false;
@@ -178,7 +188,7 @@ public <R> Expression<? extends R> getConvertedExpression(Class<R>... to) {
 				return null;
 			returnTypes[i] = exprs[i].getReturnType();
 		}
-		return new ExpressionList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), and, this);
+		return new ExpressionList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), returnTypes, and, this);
 	}
 
 	@Override
@@ -186,6 +196,12 @@ public Class<T> getReturnType() {
 		return returnType;
 	}
 
+	@Override
+	public Class<? extends T>[] possibleReturnTypes() {
+		//noinspection unchecked
+		return (Class<? extends T>[]) possibleReturnTypes;
+	}
+
 	@Override
 	public boolean getAnd() {
 		return and;
diff --git a/src/main/java/ch/njol/skript/lang/LiteralList.java b/src/main/java/ch/njol/skript/lang/LiteralList.java
index 4c5cec551dd..f432bd1c095 100644
--- a/src/main/java/ch/njol/skript/lang/LiteralList.java
+++ b/src/main/java/ch/njol/skript/lang/LiteralList.java
@@ -26,7 +26,7 @@
 
 /**
  * A list of literals. Can contain {@link UnparsedLiteral}s.
- * 
+ *
  * @author Peter Güttinger
  */
 public class LiteralList<T> extends ExpressionList<T> implements Literal<T> {
@@ -35,10 +35,18 @@ public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, boolean
 		super(literals, returnType, and);
 	}
 
+	public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and) {
+		super(literals, returnType, possibleReturnTypes, and);
+	}
+
 	public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, boolean and, LiteralList<?> source) {
 		super(literals, returnType, and, source);
 	}
 
+	public LiteralList(Literal<? extends T>[] literals, Class<T> returnType, Class<?>[] possibleReturnTypes, boolean and, LiteralList<?> source) {
+		super(literals, returnType, possibleReturnTypes, and, source);
+	}
+
 	@Override
 	public T[] getArray() {
 		return getArray(null);
@@ -64,7 +72,7 @@ public <R> Literal<? extends R> getConvertedExpression(final Class<R>... to) {
 				return null;
 			returnTypes[i] = exprs[i].getReturnType();
 		}
-		return new LiteralList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), and, this);
+		return new LiteralList<>(exprs, (Class<R>) Classes.getSuperClassInfo(returnTypes).getC(), returnTypes, and, this);
 	}
 
 	@Override
diff --git a/src/main/java/ch/njol/skript/lang/SkriptParser.java b/src/main/java/ch/njol/skript/lang/SkriptParser.java
index 743f1abee09..3318bdb07cc 100644
--- a/src/main/java/ch/njol/skript/lang/SkriptParser.java
+++ b/src/main/java/ch/njol/skript/lang/SkriptParser.java
@@ -57,7 +57,6 @@
 
 import java.util.ArrayList;
 import java.util.Deque;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
@@ -76,7 +75,7 @@
  * Used for parsing my custom patterns.<br>
  * <br>
  * Note: All parse methods print one error at most xor any amount of warnings and lower level log messages. If the given string doesn't match any pattern then nothing is printed.
- * 
+ *
  * @author Peter Güttinger
  */
 public class SkriptParser {
@@ -102,7 +101,7 @@ public SkriptParser(String expr, int flags) {
 	 * Constructs a new SkriptParser object that can be used to parse the given expression.
 	 * <p>
 	 * A SkriptParser can be re-used indefinitely for the given expression, but to parse a new expression a new SkriptParser has to be created.
-	 * 
+	 *
 	 * @param expr The expression to parse
 	 * @param flags Some parse flags ({@link #PARSE_EXPRESSIONS}, {@link #PARSE_LITERALS})
 	 * @param context The parse context
@@ -371,7 +370,7 @@ private <T> Expression<? extends T> parseSingleExpr(boolean allowUnparsedLiteral
 				if (parsedExpression != null) { // Expression/VariableString parsing success
 					for (Class<? extends T> type : types) {
 						// Check return type against everything that expression accepts
-						if (type.isAssignableFrom(parsedExpression.getReturnType())) {
+						if (parsedExpression.canReturn(type)) {
 							log.printLog();
 							return (Expression<? extends T>) parsedExpression;
 						}
@@ -541,17 +540,13 @@ private Expression<?> parseSingleExpr(boolean allowUnparsedLiteral, @Nullable Lo
 			if ((flags & PARSE_EXPRESSIONS) != 0) {
 				Expression<?> parsedExpression = parseExpression(types, expr);
 				if (parsedExpression != null) { // Expression/VariableString parsing success
-					Class<?> returnType = parsedExpression.getReturnType(); // Sometimes getReturnType does non-trivial costly operations
-					if (returnType == null)
-						throw new SkriptAPIException("Expression '" + expr + "' returned null for method Expression#getReturnType. Null is not a valid return.");
-
 					for (int i = 0; i < types.length; i++) {
 						Class<?> type = types[i];
 						if (type == null) // Ignore invalid (null) types
 							continue;
 
 						// Check return type against everything that expression accepts
-						if (type.isAssignableFrom(returnType)) {
+						if (parsedExpression.canReturn(type)) {
 							if (!exprInfo.isPlural[i] && !parsedExpression.isSingle()) { // Wrong number of arguments
 								if (context == ParseContext.COMMAND) {
 									Skript.error(Commands.m_too_many_arguments.toString(exprInfo.classes[i].getName().getIndefiniteArticle(), exprInfo.classes[i].getName().toString()), ErrorQuality.SEMANTIC_ERROR);
@@ -752,11 +747,15 @@ private <T> Expression<? extends T> parseExpressionList(ParseLogHandler log, Cla
 			exprReturnTypes[i] = parsedExpressions.get(i).getReturnType();
 
 		if (isLiteralList) {
-			Literal<T>[] literals = parsedExpressions.toArray(new Literal[parsedExpressions.size()]);
-			return new LiteralList<>(literals, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+			//noinspection unchecked,SuspiciousToArrayCall
+			Literal<T>[] literals = parsedExpressions.toArray(new Literal[0]);
+			//noinspection unchecked
+			return new LiteralList<>(literals, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 		} else {
-			Expression<T>[] expressions = parsedExpressions.toArray(new Expression[parsedExpressions.size()]);
-			return new ExpressionList<>(expressions, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+			//noinspection unchecked
+			Expression<T>[] expressions = parsedExpressions.toArray(new Expression[0]);
+			//noinspection unchecked
+			return new ExpressionList<>(expressions, (Class<T>) Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 		}
 	}
 
@@ -885,10 +884,10 @@ public Expression<?> parseExpression(ExprInfo exprInfo) {
 
 			if (isLiteralList) {
 				Literal<?>[] literals = parsedExpressions.toArray(new Literal[parsedExpressions.size()]);
-				return new LiteralList(literals, Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+				return new LiteralList(literals, Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 			} else {
 				Expression<?>[] expressions = parsedExpressions.toArray(new Expression[parsedExpressions.size()]);
-				return new ExpressionList(expressions, Classes.getSuperClassInfo(exprReturnTypes).getC(), !and.isFalse());
+				return new ExpressionList(expressions, Classes.getSuperClassInfo(exprReturnTypes).getC(), exprReturnTypes, !and.isFalse());
 
 			}
 		} finally {
@@ -1044,7 +1043,7 @@ public static ParseResult parse(String text, SkriptPattern pattern, int parseFla
 
 	/**
 	 * Finds the closing bracket of the group at <tt>start</tt> (i.e. <tt>start</tt> has to be <i>in</i> a group).
-	 * 
+	 *
 	 * @param pattern The string to search in
 	 * @param closingBracket The bracket to look for, e.g. ')'
 	 * @param openingBracket A bracket that opens another group, e.g. '('
@@ -1095,7 +1094,7 @@ private static int nextUnescaped(String pattern, char character, int from) {
 
 	/**
 	 * Counts how often the given character occurs in the given string, ignoring any escaped occurrences of the character.
-	 * 
+	 *
 	 * @param haystack The string to search in
 	 * @param needle The character to search for
 	 * @return The number of unescaped occurrences of the given character
@@ -1130,7 +1129,7 @@ static int countUnescaped(String haystack, char needle, int start, int end) {
 
 	/**
 	 * Find the next unescaped (i.e. single) double quote in the string.
-	 * 
+	 *
 	 * @param string The string to search in
 	 * @param start Index after the starting quote
 	 * @return Index of the end quote
@@ -1201,7 +1200,7 @@ public static String notOfType(ClassInfo<?>... types) {
 	 * Returns the next character in the expression, skipping strings,
 	 * variables and parentheses
 	 * (unless {@code context} is {@link ParseContext#COMMAND} or {@link ParseContext#PARSE}).
-	 * 
+	 *
 	 * @param expr The expression to traverse.
 	 * @param startIndex The index to start at.
 	 * @return The next index (can be expr.length()), or -1 if
@@ -1319,7 +1318,7 @@ private ParseResult parse_i(String pattern) {
 
 	/**
 	 * Validates a user-defined pattern (used in {@link ExprParse}).
-	 * 
+	 *
 	 * @param pattern The pattern string to validate
 	 * @return The pattern with %codenames% and a boolean array that contains whether the expressions are plural or not
 	 */
diff --git a/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java b/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java
index 74733cb9f2b..5fff6740da5 100644
--- a/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java
+++ b/src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java
@@ -33,8 +33,13 @@
 import org.skriptlang.skript.lang.converter.ConverterInfo;
 import org.skriptlang.skript.lang.converter.Converters;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
 
 /**
  * Represents a expression converted to another type. This, and not Expression, is the required return type of {@link SimpleExpression#getConvertedExpr(Class...)} because this
@@ -43,7 +48,7 @@
  * <li>automatically lets the source expression handle everything apart from the get() methods</li>
  * <li>will never convert itself to another type, but rather request a new converted expression from the source expression.</li>
  * </ol>
- * 
+ *
  * @author Peter Güttinger
  */
 public class ConvertedExpression<F, T> implements Expression<T> {
@@ -55,28 +60,59 @@ public class ConvertedExpression<F, T> implements Expression<T> {
 	/**
 	 * Converter information.
 	 */
-	private final ConverterInfo<? super F, ? extends T> converterInfo;
+	private final Collection<ConverterInfo<? super F, ? extends T>> converterInfos;
 
 	public ConvertedExpression(Expression<? extends F> source, Class<T> to, ConverterInfo<? super F, ? extends T> info) {
 		this.source = source;
 		this.to = to;
 		this.converter = info.getConverter();
-		this.converterInfo = info;
+		this.converterInfos = Collections.singleton(info);
+	}
+
+	/**
+	 * @param source The expression to use for obtaining values
+	 * @param to The type we are converting to
+	 * @param infos A collection of converters to attempt
+	 * @param performFromCheck Whether a safety check should be performed to ensure that objects being converted
+	 *  are valid for the converter being attempted
+	 */
+	public ConvertedExpression(Expression<? extends F> source, Class<T> to, Collection<ConverterInfo<? super F, ? extends T>> infos, boolean performFromCheck) {
+		this.source = source;
+		this.to = to;
+		this.converterInfos = infos;
+		this.converter = fromObject -> {
+			for (ConverterInfo<? super F, ? extends T> info : converterInfos) {
+				if (!performFromCheck || info.getFrom().isInstance(fromObject)) { // the converter is safe to attempt
+					T converted = info.getConverter().convert(fromObject);
+					if (converted != null)
+						return converted;
+				}
+			}
+			return null;
+		};
 	}
 
 	@SafeVarargs
 	@Nullable
 	public static <F, T> ConvertedExpression<F, T> newInstance(Expression<F> from, Class<T>... to) {
 		assert !CollectionUtils.containsSuperclass(to, from.getReturnType());
+		// we track a list of converters that may work
+		List<ConverterInfo<? super F, ? extends T>> converters = new ArrayList<>();
 		for (Class<T> type : to) { // REMIND try more converters? -> also change WrapperExpression (and maybe ExprLoopValue)
 			assert type != null;
 			// casting <? super ? extends F> to <? super F> is wrong, but since the converter is only used for values returned by the expression
 			// (which are instances of "<? extends F>") this won't result in any ClassCastExceptions.
-			@SuppressWarnings("unchecked")
-			ConverterInfo<? super F, ? extends T> conv = (ConverterInfo<? super F, ? extends T>) Converters.getConverterInfo(from.getReturnType(), type);
-			if (conv == null)
-				continue;
-			return new ConvertedExpression<>(from, type, conv);
+			for (Class<? extends F> checking : from.possibleReturnTypes()) {
+				//noinspection unchecked
+				ConverterInfo<? super F, ? extends T> converter = (ConverterInfo<? super F, ? extends T>) Converters.getConverterInfo(checking, type);
+				if (converter != null)
+					converters.add(converter);
+			}
+			int size = converters.size();
+			if (size == 1) // if there is only one info, there is no need to wrap it in a list
+				return new ConvertedExpression<>(from, type, converters.get(0));
+			if (size > 1)
+				return new ConvertedExpression<>(from, type, converters, true);
 		}
 		return null;
 	}
@@ -90,7 +126,7 @@ public final boolean init(Expression<?>[] vars, int matchedPattern, Kleenean isD
 	public String toString(@Nullable Event event, boolean debug) {
 		if (debug && event == null)
 			return "(" + source.toString(event, debug) + " >> " + converter + ": "
-				+ converterInfo + ")";
+				+ converterInfos.stream().map(Object::toString).collect(Collectors.joining(", ")) + ")";
 		return source.toString(event, debug);
 	}
 
diff --git a/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java b/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java
index 9e5af263ef4..daa44c7f9f8 100644
--- a/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java
+++ b/src/main/java/ch/njol/skript/lang/util/SimpleExpression.java
@@ -35,10 +35,13 @@
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.skriptlang.skript.lang.converter.Converter;
+import org.skriptlang.skript.lang.converter.ConverterInfo;
 
 import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
+import java.util.List;
 
 /**
  * An implementation of the {@link Expression} interface. You should usually extend this class to make a new expression.
@@ -200,8 +203,36 @@ public static <T> boolean check(@Nullable T[] values, Checker<? super T> checker
 	@Nullable
 	@SuppressWarnings("unchecked")
 	public <R> Expression<? extends R> getConvertedExpression(Class<R>... to) {
+		// check whether this expression is already of type R
 		if (CollectionUtils.containsSuperclass(to, getReturnType()))
 			return (Expression<? extends R>) this;
+
+		// we might be to cast some of the possible return types to R
+		List<ConverterInfo<? extends T, R>> infos = new ArrayList<>();
+		for (Class<? extends T> type : this.possibleReturnTypes()) {
+			if (CollectionUtils.containsSuperclass(to, type)) { // this type is of R
+				// build a converter that for casting to R
+				// safety check is present in the event that we do not get this type at runtime
+				final Class<R> toType = (Class<R>) type;
+				infos.add(new ConverterInfo<>(getReturnType(), toType, fromObject -> {
+					if (toType.isInstance(fromObject))
+						return (R) fromObject;
+					return null;
+				}, 0));
+			}
+		}
+		int size = infos.size();
+		if (size == 1) { // if there is only one info, there is no need to wrap it in a list
+			ConverterInfo<? extends T, R> info = infos.get(0);
+			//noinspection rawtypes
+			return new ConvertedExpression(this, info.getTo(), info);
+		}
+		if (size > 1) {
+			//noinspection rawtypes
+			return new ConvertedExpression(this, Utils.getSuperType(infos.stream().map(ConverterInfo::getTo).toArray(Class[]::new)), infos, false);
+		}
+
+		// attempt traditional conversion with proper converters
 		return this.getConvertedExpr(to);
 	}
 
diff --git a/src/main/java/ch/njol/skript/sections/EffSecSpawn.java b/src/main/java/ch/njol/skript/sections/EffSecSpawn.java
index 320b4d63c39..552bfb151b1 100644
--- a/src/main/java/ch/njol/skript/sections/EffSecSpawn.java
+++ b/src/main/java/ch/njol/skript/sections/EffSecSpawn.java
@@ -22,6 +22,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
+import ch.njol.skript.doc.RequiredPlugins;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.event.Event;
@@ -58,9 +59,9 @@
 	"spawn 3 creepers at the targeted block",
 	"spawn a ghast 5 meters above the player",
 	"spawn a zombie at the player:",
-	"\tset name of the zombie to \"\""
+		"\tset name of the zombie to \"\""
 })
-@Since("1.0, 2.6.1 (with section)")
+@Since("1.0, 2.6.1 (with section), 2.8.6 (dropped items)")
 public class EffSecSpawn extends EffectSection {
 
 	public static class SpawnEvent extends Event {
diff --git a/src/main/java/ch/njol/skript/test/platform/PlatformMain.java b/src/main/java/ch/njol/skript/test/platform/PlatformMain.java
index 7848180dde3..ab72df70985 100644
--- a/src/main/java/ch/njol/skript/test/platform/PlatformMain.java
+++ b/src/main/java/ch/njol/skript/test/platform/PlatformMain.java
@@ -152,9 +152,9 @@ public static void main(String... args) throws IOException, InterruptedException
 			output.append("\nFailed:");
 			for (String failed : failNames) {
 				List<NonNullPair<Environment, String>> errors = failures.get(failed);
-				output.append("  " + failed + " (on " + errors.size() + " environment" + (errors.size() == 1 ? "" : "s") + ")");
+				output.append("\n  " + failed + " (on " + errors.size() + " environment" + (errors.size() == 1 ? "" : "s") + ")");
 				for (NonNullPair<Environment, String> error : errors) {
-					output.append("    " + error.getSecond() + " (on " + error.getFirst().getName() + ")");
+					output.append("\n    " + error.getSecond() + " (on " + error.getFirst().getName() + ")");
 				}
 			}
 			output.append(String.format("%n%n%s", StringUtils.repeat("-", 60)));
diff --git a/src/main/java/ch/njol/skript/test/runner/EffObjectives.java b/src/main/java/ch/njol/skript/test/runner/EffObjectives.java
index 472abc4e7b5..0ebec184329 100644
--- a/src/main/java/ch/njol/skript/test/runner/EffObjectives.java
+++ b/src/main/java/ch/njol/skript/test/runner/EffObjectives.java
@@ -102,12 +102,13 @@ public static boolean isJUnitComplete() {
 	public static void fail() {
 		for (String test : requirements.keySet()) {
 			if (!completeness.containsKey(test)) {
-				TestTracker.JUnitTestFailed("JUnit test '" + test + "'", "didn't complete any objectives.");
+				TestTracker.JUnitTestFailed("JUnit: '" + test + "'", "didn't complete any objectives.");
 				continue;
 			}
 			List<String> failures = Lists.newArrayList(requirements.get(test));
 			failures.removeAll(completeness.get(test));
-			TestTracker.JUnitTestFailed("JUnit test '" + test + "'", "failed objectives: " + Arrays.toString(failures.toArray(new String[0])));
+			if (!failures.isEmpty())
+				TestTracker.JUnitTestFailed("JUnit: '" + test + "'", "failed objectives: " + Arrays.toString(failures.toArray(new String[0])));
 		}
 	}
 
diff --git a/src/main/java/ch/njol/skript/util/LiteralUtils.java b/src/main/java/ch/njol/skript/util/LiteralUtils.java
index 59f58b09800..e980b7bcb07 100644
--- a/src/main/java/ch/njol/skript/util/LiteralUtils.java
+++ b/src/main/java/ch/njol/skript/util/LiteralUtils.java
@@ -53,7 +53,7 @@ public static <T> Expression<T> defendExpression(Expression<?> expr) {
 				newExpressions[i] = LiteralUtils.defendExpression(oldExpressions[i]);
 				returnTypes[i] = newExpressions[i].getReturnType();
 			}
-			return new ExpressionList<>(newExpressions, (Class<T>) Classes.getSuperClassInfo(returnTypes).getC(), expr.getAnd());
+			return new ExpressionList<>(newExpressions, (Class<T>) Classes.getSuperClassInfo(returnTypes).getC(), returnTypes, expr.getAnd());
 		} else if (expr instanceof UnparsedLiteral) {
 			Literal<?> parsedLiteral = ((UnparsedLiteral) expr).getConvertedExpression(Object.class);
 			return (Expression<T>) (parsedLiteral == null ? expr : parsedLiteral);
diff --git a/src/main/java/ch/njol/util/VectorMath.java b/src/main/java/ch/njol/util/VectorMath.java
index fca9785dc6a..5db05ecc41b 100644
--- a/src/main/java/ch/njol/util/VectorMath.java
+++ b/src/main/java/ch/njol/util/VectorMath.java
@@ -198,4 +198,13 @@ public static void copyVector(Vector vector1, Vector vector2) {
 		vector1.setX(vector2.getX()).setY(vector2.getY()).setZ(vector2.getZ());
 	}
 
+	/**
+	 * Check whether or not each component of this vector is equal to 0.
+	 * <br>Replaces {@code Vector#isZero()} since that method was added in spigot 1.19.3
+	 * @return true if equal to zero, false if at least one component is non-zero
+	 */
+	public static boolean isZero(Vector vector) {
+		return (vector.getX() == 0 && vector.getY() == 0 && vector.getZ() == 0);
+	}
+
 }
diff --git a/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java b/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
index 7cc4c8b0144..27a8065e122 100644
--- a/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
+++ b/src/main/java/org/skriptlang/skript/lang/arithmetic/Arithmetics.java
@@ -29,6 +29,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Collection;
+import java.util.Set;
+import java.util.HashSet;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -266,4 +269,19 @@ private static void assertIsOperationsDoneLoading() {
 			throw new SkriptAPIException("Operations cannot be retrieved until Skript has finished registrations.");
 	}
 
+	/**
+	 * All registered types that could be returned from a calculation using this operator.
+	 * This is used to fetch potential return types when unknown (variable) arguments are used in a sum.
+	 *
+	 * @param operator The operator to test
+	 * @return Every type this could return
+	 */
+	public static Collection<Class<?>> getAllReturnTypes(Operator operator) {
+		Set<Class<?>> types = new HashSet<>();
+		for (OperationInfo<?, ?, ?> info : getOperations_i(operator)) {
+			types.add(info.getReturnType());
+		}
+		return types;
+	}
+
 }
diff --git a/src/test/skript/tests/regressions/6194-vectors + push.sk b/src/test/skript/tests/regressions/6194-vectors + push.sk
new file mode 100644
index 00000000000..258b091fba6
--- /dev/null
+++ b/src/test/skript/tests/regressions/6194-vectors + push.sk	
@@ -0,0 +1,9 @@
+test "normalize zero vector":
+	set {_vector} to vector(0,0,0)
+	add 1 to vector length of {_vector}
+	assert {_vector} is vector(0,0,0) with "add to zero vector's length failed"
+
+	set vector length of {_vector} to 1
+	assert {_vector} is vector(0,0,0) with "set zero vector's length failed"
+
+	assert normalize {_vector} is vector(0,0,0) with "normalize zero vector failed"
\ No newline at end of file
diff --git a/src/test/skript/tests/regressions/6424-inventory-holder-location.sk b/src/test/skript/tests/regressions/6424-inventory-holder-location.sk
new file mode 100644
index 00000000000..ed4d9cd64ab
--- /dev/null
+++ b/src/test/skript/tests/regressions/6424-inventory-holder-location.sk
@@ -0,0 +1,16 @@
+test "inventory holder location":
+	set {_b} to the block at spawn of world "world"
+	set {_prev} to type of block at {_b}
+	broadcast {_prev}
+
+	set block at {_b} to a chest
+	set {_inv} to inventory of {_b}
+	set {_holder} to holder of {_inv}
+
+	set {_a-loc} to location of {_holder}
+	set {_b-loc} to location of {_b}
+
+	# clean up first in case assert fails
+	set block at {_b} to {_prev}
+
+	assert {_a-loc} is {_b-loc} with "holder location differs from block location"
diff --git a/src/test/skript/tests/regressions/6623-wrong parsing order for math.sk b/src/test/skript/tests/regressions/6623-wrong parsing order for math.sk
new file mode 100644
index 00000000000..e3a8a02cd07
--- /dev/null
+++ b/src/test/skript/tests/regressions/6623-wrong parsing order for math.sk	
@@ -0,0 +1,12 @@
+test "wrong parsing order for math in object expr":
+	spawn a zombie at spawn of world "world"
+	set {_e} to the last spawned zombie
+
+	set {_result} to health of {_e} + max health of {_e}
+	assert {_result} is set with "add result not calculated"
+	delete {_result}
+
+	set {_result} to health of {_e} / max health of {_e} # used to be parsed as `health of ({_e} / max health of {_e})`
+	assert {_result} is set with "divide result not calculated"
+
+	delete the last spawned zombie
diff --git a/src/test/skript/tests/regressions/6707-spawn-fish-types.sk b/src/test/skript/tests/regressions/6707-spawn-fish-types.sk
new file mode 100644
index 00000000000..2a0d0bf8112
--- /dev/null
+++ b/src/test/skript/tests/regressions/6707-spawn-fish-types.sk
@@ -0,0 +1,26 @@
+test "spawn fish types":
+	spawn a cod at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a cod with "failed to spawn a cod"
+	delete entity within {_e}
+
+	spawn a salmon at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a salmon with "failed to spawn a salmon"
+	delete entity within {_e}
+
+	spawn a puffer fish at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a puffer fish with "failed to spawn a puffer fish"
+	delete entity within {_e}
+
+	spawn a tropical fish at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is a tropical fish with "failed to spawn a tropical fish"
+	delete entity within {_e}
+
+	parse if running minecraft "1.19":
+		spawn a tadpole at spawn of world "world":
+			set {_e} to entity
+		assert {_e} is a tadpole with "failed to spawn a tadpole"
+		delete entity within {_e}
diff --git a/src/test/skript/tests/regressions/pull-6746-spawn-dropped-item.sk b/src/test/skript/tests/regressions/pull-6746-spawn-dropped-item.sk
new file mode 100644
index 00000000000..b8910894bad
--- /dev/null
+++ b/src/test/skript/tests/regressions/pull-6746-spawn-dropped-item.sk
@@ -0,0 +1,9 @@
+test "spawn dropped item":
+	spawn dropped stone at spawn of world "world":
+		set {_e} to entity
+	assert {_e} is set with "failed to spawn dropped stone"
+	delete entity within {_e}
+
+	spawn dropped item at spawn of world "world":
+		set {_e2} to entity
+	assert {_e2} is not set with "spawned `dropped item` despite undefined item type"