From f3ad2a40ba87d88e102febf81c50e96fc28a0df2 Mon Sep 17 00:00:00 2001
From: Magnus Ulf <magnus@puj.dk>
Date: Thu, 5 Mar 2015 15:29:03 +0100
Subject: [PATCH] Update ParticleEffect library

Thanks to @DarkBlade12 for providing this awesome library.
---
 .../particleeffect/ParticleEffect.java        | 684 ++++++++++++++----
 .../particleeffect/ReflectionUtils.java       |   2 +-
 2 files changed, 538 insertions(+), 148 deletions(-)

diff --git a/src/com/massivecraft/massivecore/particleeffect/ParticleEffect.java b/src/com/massivecraft/massivecore/particleeffect/ParticleEffect.java
index e38c2d5a..b6fcd228 100644
--- a/src/com/massivecraft/massivecore/particleeffect/ParticleEffect.java
+++ b/src/com/massivecraft/massivecore/particleeffect/ParticleEffect.java
@@ -32,13 +32,14 @@ import com.massivecraft.massivecore.util.MUtil;
  * <ul>
  * <li>@microgeek (original idea, names and packet parameters)
  * <li>@ShadyPotato (1.8 names, ids and packet parameters)
- * <li>@RingOfStorms (specific particle direction)
+ * <li>@RingOfStorms (particle behavior)
+ * <li>@Cybermaxke (particle behavior)
  * </ul>
  * <p>
  * <i>It would be nice if you provide credit to me if you use this class in a published project</i>
  * 
  * @author DarkBlade12
- * @version 1.6
+ * @version 1.7
  */
 public enum ParticleEffect {
 	/**
@@ -48,7 +49,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	EXPLOSION_NORMAL("explode", 0, -1),
+	EXPLOSION_NORMAL("explode", 0, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by exploding ghast fireballs and wither skulls:
 	 * <ul>
@@ -72,7 +73,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	FIREWORKS_SPARK("fireworksSpark", 3, -1),
+	FIREWORKS_SPARK("fireworksSpark", 3, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by swimming entities and arrows in water:
 	 * <ul>
@@ -80,7 +81,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	WATER_BUBBLE("bubble", 4, -1, false, true),
+	WATER_BUBBLE("bubble", 4, -1, ParticleProperty.DIRECTIONAL, ParticleProperty.REQUIRES_WATER),
 	/**
 	 * A particle effect which is displayed by swimming entities and shaking wolves:
 	 * <ul>
@@ -88,7 +89,7 @@ public enum ParticleEffect {
 	 * <li>The speed value has no influence on this particle effect
 	 * </ul>
 	 */
-	WATER_SPLASH("splash", 5, -1),
+	WATER_SPLASH("splash", 5, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed on water when fishing:
 	 * <ul>
@@ -96,7 +97,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	WATER_WAKE("wake", 6, 7),
+	WATER_WAKE("wake", 6, 7, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by water:
 	 * <ul>
@@ -104,7 +105,7 @@ public enum ParticleEffect {
 	 * <li>The speed value has no influence on this particle effect
 	 * </ul>
 	 */
-	SUSPENDED("suspended", 7, -1, false, true),
+	SUSPENDED("suspended", 7, -1, ParticleProperty.REQUIRES_WATER),
 	/**
 	 * A particle effect which is displayed by air when close to bedrock and the in the void:
 	 * <ul>
@@ -112,7 +113,7 @@ public enum ParticleEffect {
 	 * <li>The speed value has no influence on this particle effect
 	 * </ul>
 	 */
-	SUSPENDED_DEPTH("depthSuspend", 8, -1),
+	SUSPENDED_DEPTH("depthSuspend", 8, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed when landing a critical hit and by arrows:
 	 * <ul>
@@ -120,7 +121,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	CRIT("crit", 9, -1),
+	CRIT("crit", 9, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed when landing a hit with an enchanted weapon:
 	 * <ul>
@@ -128,7 +129,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	CRIT_MAGIC("magicCrit", 10, -1),
+	CRIT_MAGIC("magicCrit", 10, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by primed tnt, torches, droppers, dispensers, end portals, brewing stands and monster spawners:
 	 * <ul>
@@ -136,7 +137,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	SMOKE_NORMAL("smoke", 11, -1),
+	SMOKE_NORMAL("smoke", 11, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by fire, minecarts with furnace and blazes:
 	 * <ul>
@@ -144,12 +145,13 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	SMOKE_LARGE("largesmoke", 12, -1),
+	SMOKE_LARGE("largesmoke", 12, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed when splash potions or bottles o' enchanting hit something:
 	 * <ul>
 	 * <li>It looks like a white swirl
 	 * <li>The speed value causes the particle to only move upwards when set to 0
+	 * <li>Only the motion on the y-axis can be controlled, the motion on the x- and z-axis are multiplied by 0.1 when setting the values to 0
 	 * </ul>
 	 */
 	SPELL("spell", 13, -1),
@@ -158,6 +160,7 @@ public enum ParticleEffect {
 	 * <ul>
 	 * <li>It looks like a white cross
 	 * <li>The speed value causes the particle to only move upwards when set to 0
+	 * <li>Only the motion on the y-axis can be controlled, the motion on the x- and z-axis are multiplied by 0.1 when setting the values to 0
 	 * </ul>
 	 */
 	SPELL_INSTANT("instantSpell", 14, -1),
@@ -169,7 +172,7 @@ public enum ParticleEffect {
 	 * <li>The particle color gets lighter when increasing the speed and darker when decreasing the speed
 	 * </ul>
 	 */
-	SPELL_MOB("mobSpell", 15, -1),
+	SPELL_MOB("mobSpell", 15, -1, ParticleProperty.COLORABLE),
 	/**
 	 * A particle effect which is displayed by entities with active potion effects applied through a beacon:
 	 * <ul>
@@ -178,12 +181,13 @@ public enum ParticleEffect {
 	 * <li>The particle color gets lighter when increasing the speed and darker when decreasing the speed
 	 * </ul>
 	 */
-	SPELL_MOB_AMBIENT("mobSpellAmbient", 16, -1),
+	SPELL_MOB_AMBIENT("mobSpellAmbient", 16, -1, ParticleProperty.COLORABLE),
 	/**
 	 * A particle effect which is displayed by witches:
 	 * <ul>
 	 * <li>It looks like a purple cross
 	 * <li>The speed value causes the particle to only move upwards when set to 0
+	 * <li>Only the motion on the y-axis can be controlled, the motion on the x- and z-axis are multiplied by 0.1 when setting the values to 0
 	 * </ul>
 	 */
 	SPELL_WITCH("witchMagic", 17, -1),
@@ -218,7 +222,7 @@ public enum ParticleEffect {
 	 * <li>The speed value has no influence on this particle effect
 	 * </ul>
 	 */
-	VILLAGER_HAPPY("happyVillager", 21, -1),
+	VILLAGER_HAPPY("happyVillager", 21, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by mycelium:
 	 * <ul>
@@ -226,7 +230,7 @@ public enum ParticleEffect {
 	 * <li>The speed value has no influence on this particle effect
 	 * </ul>
 	 */
-	TOWN_AURA("townaura", 22, -1),
+	TOWN_AURA("townaura", 22, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by note blocks:
 	 * <ul>
@@ -234,7 +238,7 @@ public enum ParticleEffect {
 	 * <li>The speed value causes the particle to be colored green when set to 0
 	 * </ul>
 	 */
-	NOTE("note", 23, -1),
+	NOTE("note", 23, -1, ParticleProperty.COLORABLE),
 	/**
 	 * A particle effect which is displayed by nether portals, endermen, ender pearls, eyes of ender, ender chests and dragon eggs:
 	 * <ul>
@@ -242,7 +246,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the spread of this particle effect
 	 * </ul>
 	 */
-	PORTAL("portal", 24, -1),
+	PORTAL("portal", 24, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by enchantment tables which are nearby bookshelves:
 	 * <ul>
@@ -250,7 +254,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the spread of this particle effect
 	 * </ul>
 	 */
-	ENCHANTMENT_TABLE("enchantmenttable", 25, -1),
+	ENCHANTMENT_TABLE("enchantmenttable", 25, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by torches, active furnaces, magma cubes and monster spawners:
 	 * <ul>
@@ -258,7 +262,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	FLAME("flame", 26, -1),
+	FLAME("flame", 26, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by lava:
 	 * <ul>
@@ -282,7 +286,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	CLOUD("cloud", 29, -1),
+	CLOUD("cloud", 29, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by redstone ore, powered redstone, redstone torches and redstone repeaters:
 	 * <ul>
@@ -290,7 +294,7 @@ public enum ParticleEffect {
 	 * <li>The speed value causes the particle to be colored red when set to 0
 	 * </ul>
 	 */
-	REDSTONE("reddust", 30, -1),
+	REDSTONE("reddust", 30, -1, ParticleProperty.COLORABLE),
 	/**
 	 * A particle effect which is displayed when snowballs hit a block:
 	 * <ul>
@@ -306,7 +310,7 @@ public enum ParticleEffect {
 	 * <li>The speed value influences the velocity at which the particle flies off
 	 * </ul>
 	 */
-	SNOW_SHOVEL("snowshovel", 32, -1),
+	SNOW_SHOVEL("snowshovel", 32, -1, ParticleProperty.DIRECTIONAL),
 	/**
 	 * A particle effect which is displayed by slimes:
 	 * <ul>
@@ -337,7 +341,7 @@ public enum ParticleEffect {
 	 * <li>It looks like a little piece with an item texture
 	 * </ul>
 	 */
-	ITEM_CRACK("iconcrack", 36, -1, true),
+	ITEM_CRACK("iconcrack", 36, -1, ParticleProperty.DIRECTIONAL, ParticleProperty.REQUIRES_DATA),
 	/**
 	 * A particle effect which is displayed when breaking blocks or sprinting:
 	 * <ul>
@@ -345,14 +349,14 @@ public enum ParticleEffect {
 	 * <li>The speed value has no influence on this particle effect
 	 * </ul>
 	 */
-	BLOCK_CRACK("blockcrack", 37, -1, true),
+	BLOCK_CRACK("blockcrack", 37, -1, ParticleProperty.DIRECTIONAL, ParticleProperty.REQUIRES_DATA),
 	/**
 	 * A particle effect which is displayed when falling:
 	 * <ul>
 	 * <li>It looks like a little piece with a block texture
 	 * </ul>
 	 */
-	BLOCK_DUST("blockdust", 38, 7, true),
+	BLOCK_DUST("blockdust", 38, 7, ParticleProperty.DIRECTIONAL, ParticleProperty.REQUIRES_DATA),
 	/**
 	 * A particle effect which is displayed when rain hits the ground:
 	 * <ul>
@@ -373,6 +377,7 @@ public enum ParticleEffect {
 	 * <ul>
 	 * <li>It looks like the shape of the elder guardian
 	 * <li>The speed value has no influence on this particle effect
+	 * <li>The offset values have no influence on this particle effect
 	 * </ul>
 	 */
 	MOB_APPEARANCE("mobappearance", 41, 8);
@@ -382,8 +387,7 @@ public enum ParticleEffect {
 	private final String name;
 	private final int id;
 	private final int requiredVersion;
-	private final boolean requiresData;
-	private final boolean requiresWater;
+	private final List<ParticleProperty> properties;
 
 	// Initialize map for quick name and id lookup
 	static {
@@ -399,41 +403,13 @@ public enum ParticleEffect {
 	 * @param name Name of this particle effect
 	 * @param id Id of this particle effect
 	 * @param requiredVersion Version which is required (1.x)
-	 * @param requiresData Indicates whether additional data is required for this particle effect
-	 * @param requiresWater Indicates whether water is required for this particle effect to display properly
+	 * @param properties Properties of this particle effect
 	 */
-	private ParticleEffect(String name, int id, int requiredVersion, boolean requiresData, boolean requiresWater) {
+	private ParticleEffect(String name, int id, int requiredVersion, ParticleProperty... properties) {
 		this.name = name;
 		this.id = id;
 		this.requiredVersion = requiredVersion;
-		this.requiresData = requiresData;
-		this.requiresWater = requiresWater;
-	}
-
-	/**
-	 * Construct a new particle effect with {@link #requiresWater} set to <code>false</code>
-	 * 
-	 * @param name Name of this particle effect
-	 * @param id Id of this particle effect
-	 * @param requiredVersion Version which is required (1.x)
-	 * @param requiresData Indicates whether additional data is required for this particle effect
-	 * @see #ParticleEffect(String, int, boolean, boolean)
-	 */
-	private ParticleEffect(String name, int id, int requiredVersion, boolean requiresData) {
-		this(name, id, requiredVersion, requiresData, false);
-	}
-
-	/**
-	 * Construct a new particle effect with {@link #requiresData} and {@link #requiresWater} set to <code>false</code>
-	 * 
-	 * @param name Name of this particle effect
-	 * @param id Id of this particle effect
-	 * @param requiredVersion Version which is required (1.x)
-	 * @param requiresData Indicates whether additional data is required for this particle effect
-	 * @see #ParticleEffect(String, int, boolean)
-	 */
-	private ParticleEffect(String name, int id, int requiredVersion) {
-		this(name, id, requiredVersion, false);
+		this.properties = Arrays.asList(properties);
 	}
 
 	/**
@@ -464,21 +440,12 @@ public enum ParticleEffect {
 	}
 
 	/**
-	 * Determine if additional data is required for this particle effect
+	 * Determine if this particle effect has a specific property
 	 * 
-	 * @return Whether additional data is required or not
+	 * @return Whether it has the property or not
 	 */
-	public boolean getRequiresData() {
-		return requiresData;
-	}
-
-	/**
-	 * Determine if water is required for this particle effect to display properly
-	 * 
-	 * @return Whether water is required or not
-	 */
-	public boolean getRequiresWater() {
-		return requiresWater;
+	public boolean hasProperty(ParticleProperty property) {
+		return properties.contains(property);
 	}
 
 	/**
@@ -544,7 +511,7 @@ public enum ParticleEffect {
 	 */
 	private static boolean isLongDistance(Location location, List<Player> players) {
 		for (Player player : players) {
-			if (player.getLocation().distance(location) < 256) {
+			if (player.getLocation().distanceSquared(location) < 65536) {
 				continue;
 			}
 			return true;
@@ -552,6 +519,28 @@ public enum ParticleEffect {
 		return false;
 	}
 
+	/**
+	 * Determine if the data type for a particle effect is correct
+	 * 
+	 * @param effect Particle effect
+	 * @param data Particle data
+	 * @return Whether the data type is correct or not
+	 */
+	private static boolean isDataCorrect(ParticleEffect effect, ParticleData data) {
+		return ((effect == BLOCK_CRACK || effect == BLOCK_DUST) && data instanceof BlockData) || (effect == ITEM_CRACK && data instanceof ItemData);
+	}
+
+	/**
+	 * Determine if the color type for a particle effect is correct
+	 * 
+	 * @param effect Particle effect
+	 * @param color Particle color
+	 * @return Whether the color type is correct or not
+	 */
+	private static boolean isColorCorrect(ParticleEffect effect, ParticleColor color) {
+		return ((effect == SPELL_MOB || effect == SPELL_MOB_AMBIENT || effect == REDSTONE) && color instanceof OrdinaryColor) || (effect == NOTE && color instanceof NoteColor);
+	}
+
 	/**
 	 * Displays a particle effect which is only visible for all players within a certain range in the world of @param center
 	 * 
@@ -572,10 +561,10 @@ public enum ParticleEffect {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (requiresData) {
+		if (hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect requires additional data");
 		}
-		if (requiresWater && !isWater(center)) {
+		if (hasProperty(ParticleProperty.REQUIRES_WATER) && !isWater(center)) {
 			throw new IllegalArgumentException("There is no water at the center location");
 		}
 		new ParticlePacket(this, offsetX, offsetY, offsetZ, speed, amount, range > 256, null).sendTo(center, range);
@@ -601,15 +590,34 @@ public enum ParticleEffect {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (requiresData) {
+		if (hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect requires additional data");
 		}
-		if (requiresWater && !isWater(center)) {
+		if (hasProperty(ParticleProperty.REQUIRES_WATER) && !isWater(center)) {
 			throw new IllegalArgumentException("There is no water at the center location");
 		}
 		new ParticlePacket(this, offsetX, offsetY, offsetZ, speed, amount, isLongDistance(center, players), null).sendTo(center, players);
 	}
 
+	/**
+	 * Displays a particle effect which is only visible for the specified players
+	 * 
+	 * @param offsetX Maximum distance particles can fly away from the center on the x-axis
+	 * @param offsetY Maximum distance particles can fly away from the center on the y-axis
+	 * @param offsetZ Maximum distance particles can fly away from the center on the z-axis
+	 * @param speed Display speed of the particles
+	 * @param amount Amount of particles
+	 * @param center Center location of the effect
+	 * @param players Receivers of the effect
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleDataException If the particle effect requires additional data
+	 * @throws IllegalArgumentException If the particle effect requires water and none is at the center location
+	 * @see #display(float, float, float, float, int, Location, List)
+	 */
+	public void display(float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, Player... players) throws ParticleVersionException, ParticleDataException, IllegalArgumentException {
+		display(offsetX, offsetY, offsetZ, speed, amount, center, Arrays.asList(players));
+	}
+
 	/**
 	 * Displays a single particle which flies into a determined direction and is only visible for all players within a certain range in the world of @param center
 	 * 
@@ -619,18 +627,21 @@ public enum ParticleEffect {
 	 * @param range Range of the visibility
 	 * @throws ParticleVersionException If the particle effect is not supported by the server version
 	 * @throws ParticleDataException If the particle effect requires additional data
-	 * @throws IllegalArgumentException If the particle effect requires water and none is at the center location
-	 * @see ParticlePacket
+	 * @throws IllegalArgumentException If the particle effect is not directional or if it requires water and none is at the center location
+	 * @see ParticlePacket#ParticlePacket(ParticleEffect, Vector, float, boolean, ParticleData)
 	 * @see ParticlePacket#sendTo(Location, double)
 	 */
 	public void display(Vector direction, float speed, Location center, double range) throws ParticleVersionException, ParticleDataException, IllegalArgumentException {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (requiresData) {
+		if (hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect requires additional data");
 		}
-		if (requiresWater && !isWater(center)) {
+		if (!hasProperty(ParticleProperty.DIRECTIONAL)) {
+			throw new IllegalArgumentException("This particle effect is not directional");
+		}
+		if (hasProperty(ParticleProperty.REQUIRES_WATER) && !isWater(center)) {
 			throw new IllegalArgumentException("There is no water at the center location");
 		}
 		new ParticlePacket(this, direction, speed, range > 256, null).sendTo(center, range);
@@ -645,23 +656,104 @@ public enum ParticleEffect {
 	 * @param players Receivers of the effect
 	 * @throws ParticleVersionException If the particle effect is not supported by the server version
 	 * @throws ParticleDataException If the particle effect requires additional data
-	 * @throws IllegalArgumentException If the particle effect requires water and none is at the center location
-	 * @see ParticlePacket
+	 * @throws IllegalArgumentException If the particle effect is not directional or if it requires water and none is at the center location
+	 * @see ParticlePacket#ParticlePacket(ParticleEffect, Vector, float, boolean, ParticleData)
 	 * @see ParticlePacket#sendTo(Location, List)
 	 */
 	public void display(Vector direction, float speed, Location center, List<Player> players) throws ParticleVersionException, ParticleDataException, IllegalArgumentException {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (requiresData) {
+		if (hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect requires additional data");
 		}
-		if (requiresWater && !isWater(center)) {
+		if (!hasProperty(ParticleProperty.DIRECTIONAL)) {
+			throw new IllegalArgumentException("This particle effect is not directional");
+		}
+		if (hasProperty(ParticleProperty.REQUIRES_WATER) && !isWater(center)) {
 			throw new IllegalArgumentException("There is no water at the center location");
 		}
 		new ParticlePacket(this, direction, speed, isLongDistance(center, players), null).sendTo(center, players);
 	}
 
+	/**
+	 * Displays a single particle which flies into a determined direction and is only visible for the specified players
+	 * 
+	 * @param direction Direction of the particle
+	 * @param speed Display speed of the particle
+	 * @param center Center location of the effect
+	 * @param players Receivers of the effect
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleDataException If the particle effect requires additional data
+	 * @throws IllegalArgumentException If the particle effect is not directional or if it requires water and none is at the center location
+	 * @see #display(Vector, float, Location, List)
+	 */
+	public void display(Vector direction, float speed, Location center, Player... players) throws ParticleVersionException, ParticleDataException, IllegalArgumentException {
+		display(direction, speed, center, Arrays.asList(players));
+	}
+
+	/**
+	 * Displays a single particle which is colored and only visible for all players within a certain range in the world of @param center
+	 * 
+	 * @param color Color of the particle
+	 * @param center Center location of the effect
+	 * @param range Range of the visibility
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleColorException If the particle effect is not colorable or the color type is incorrect
+	 * @see ParticlePacket#ParticlePacket(ParticleEffect, ParticleColor, boolean)
+	 * @see ParticlePacket#sendTo(Location, double)
+	 */
+	public void display(ParticleColor color, Location center, double range) throws ParticleVersionException, ParticleColorException {
+		if (!isSupported()) {
+			throw new ParticleVersionException("This particle effect is not supported by your server version");
+		}
+		if (!hasProperty(ParticleProperty.COLORABLE)) {
+			throw new ParticleColorException("This particle effect is not colorable");
+		}
+		if (!isColorCorrect(this, color)) {
+			throw new ParticleColorException("The particle color type is incorrect");
+		}
+		new ParticlePacket(this, color, range > 256).sendTo(center, range);
+	}
+
+	/**
+	 * Displays a single particle which is colored and only visible for the specified players
+	 * 
+	 * @param color Color of the particle
+	 * @param center Center location of the effect
+	 * @param players Receivers of the effect
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleColorException If the particle effect is not colorable or the color type is incorrect
+	 * @see ParticlePacket#ParticlePacket(ParticleEffect, ParticleColor, boolean)
+	 * @see ParticlePacket#sendTo(Location, List)
+	 */
+	public void display(ParticleColor color, Location center, List<Player> players) throws ParticleVersionException, ParticleColorException {
+		if (!isSupported()) {
+			throw new ParticleVersionException("This particle effect is not supported by your server version");
+		}
+		if (!hasProperty(ParticleProperty.COLORABLE)) {
+			throw new ParticleColorException("This particle effect is not colorable");
+		}
+		if (!isColorCorrect(this, color)) {
+			throw new ParticleColorException("The particle color type is incorrect");
+		}
+		new ParticlePacket(this, color, isLongDistance(center, players)).sendTo(center, players);
+	}
+
+	/**
+	 * Displays a single particle which is colored and only visible for the specified players
+	 * 
+	 * @param color Color of the particle
+	 * @param center Center location of the effect
+	 * @param players Receivers of the effect
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleColorException If the particle effect is not colorable or the color type is incorrect
+	 * @see #display(ParticleColor, Location, List)
+	 */
+	public void display(ParticleColor color, Location center, Player... players) throws ParticleVersionException, ParticleColorException {
+		display(color, center, Arrays.asList(players));
+	}
+
 	/**
 	 * Displays a particle effect which requires additional data and is only visible for all players within a certain range in the world of @param center
 	 * 
@@ -674,7 +766,7 @@ public enum ParticleEffect {
 	 * @param center Center location of the effect
 	 * @param range Range of the visibility
 	 * @throws ParticleVersionException If the particle effect is not supported by the server version
-	 * @throws ParticleDataException If the particle effect does not require additional data
+	 * @throws ParticleDataException If the particle effect does not require additional data or if the data type is incorrect
 	 * @see ParticlePacket
 	 * @see ParticlePacket#sendTo(Location, double)
 	 */
@@ -682,9 +774,12 @@ public enum ParticleEffect {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (!requiresData) {
+		if (!hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect does not require additional data");
 		}
+		if (!isDataCorrect(this, data)) {
+			throw new ParticleDataException("The particle data type is incorrect");
+		}
 		new ParticlePacket(this, offsetX, offsetY, offsetZ, speed, amount, range > 256, data).sendTo(center, range);
 	}
 
@@ -700,7 +795,7 @@ public enum ParticleEffect {
 	 * @param center Center location of the effect
 	 * @param players Receivers of the effect
 	 * @throws ParticleVersionException If the particle effect is not supported by the server version
-	 * @throws ParticleDataException If the particle effect does not require additional data
+	 * @throws ParticleDataException If the particle effect does not require additional data or if the data type is incorrect
 	 * @see ParticlePacket
 	 * @see ParticlePacket#sendTo(Location, List)
 	 */
@@ -708,12 +803,34 @@ public enum ParticleEffect {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (!requiresData) {
+		if (!hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect does not require additional data");
 		}
+		if (!isDataCorrect(this, data)) {
+			throw new ParticleDataException("The particle data type is incorrect");
+		}
 		new ParticlePacket(this, offsetX, offsetY, offsetZ, speed, amount, isLongDistance(center, players), data).sendTo(center, players);
 	}
 
+	/**
+	 * Displays a particle effect which requires additional data and is only visible for the specified players
+	 * 
+	 * @param data Data of the effect
+	 * @param offsetX Maximum distance particles can fly away from the center on the x-axis
+	 * @param offsetY Maximum distance particles can fly away from the center on the y-axis
+	 * @param offsetZ Maximum distance particles can fly away from the center on the z-axis
+	 * @param speed Display speed of the particles
+	 * @param amount Amount of particles
+	 * @param center Center location of the effect
+	 * @param players Receivers of the effect
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleDataException If the particle effect does not require additional data or if the data type is incorrect
+	 * @see #display(ParticleData, float, float, float, float, int, Location, List)
+	 */
+	public void display(ParticleData data, float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, Player... players) throws ParticleVersionException, ParticleDataException {
+		display(data, offsetX, offsetY, offsetZ, speed, amount, center, Arrays.asList(players));
+	}
+
 	/**
 	 * Displays a single particle which requires additional data that flies into a determined direction and is only visible for all players within a certain range in the world of @param center
 	 * 
@@ -723,7 +840,7 @@ public enum ParticleEffect {
 	 * @param center Center location of the effect
 	 * @param range Range of the visibility
 	 * @throws ParticleVersionException If the particle effect is not supported by the server version
-	 * @throws ParticleDataException If the particle effect does not require additional data
+	 * @throws ParticleDataException If the particle effect does not require additional data or if the data type is incorrect
 	 * @see ParticlePacket
 	 * @see ParticlePacket#sendTo(Location, double)
 	 */
@@ -731,9 +848,12 @@ public enum ParticleEffect {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (!requiresData) {
+		if (!hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect does not require additional data");
 		}
+		if (!isDataCorrect(this, data)) {
+			throw new ParticleDataException("The particle data type is incorrect");
+		}
 		new ParticlePacket(this, direction, speed, range > 256, data).sendTo(center, range);
 	}
 
@@ -746,7 +866,7 @@ public enum ParticleEffect {
 	 * @param center Center location of the effect
 	 * @param players Receivers of the effect
 	 * @throws ParticleVersionException If the particle effect is not supported by the server version
-	 * @throws ParticleDataException If the particle effect does not require additional data
+	 * @throws ParticleDataException If the particle effect does not require additional data or if the data type is incorrect
 	 * @see ParticlePacket
 	 * @see ParticlePacket#sendTo(Location, List)
 	 */
@@ -754,12 +874,58 @@ public enum ParticleEffect {
 		if (!isSupported()) {
 			throw new ParticleVersionException("This particle effect is not supported by your server version");
 		}
-		if (!requiresData) {
+		if (!hasProperty(ParticleProperty.REQUIRES_DATA)) {
 			throw new ParticleDataException("This particle effect does not require additional data");
 		}
+		if (!isDataCorrect(this, data)) {
+			throw new ParticleDataException("The particle data type is incorrect");
+		}
 		new ParticlePacket(this, direction, speed, isLongDistance(center, players), data).sendTo(center, players);
 	}
 
+	/**
+	 * Displays a single particle which requires additional data that flies into a determined direction and is only visible for the specified players
+	 * 
+	 * @param data Data of the effect
+	 * @param direction Direction of the particle
+	 * @param speed Display speed of the particles
+	 * @param center Center location of the effect
+	 * @param players Receivers of the effect
+	 * @throws ParticleVersionException If the particle effect is not supported by the server version
+	 * @throws ParticleDataException If the particle effect does not require additional data or if the data type is incorrect
+	 * @see #display(ParticleData, Vector, float, Location, List)
+	 */
+	public void display(ParticleData data, Vector direction, float speed, Location center, Player... players) throws ParticleVersionException, ParticleDataException {
+		display(data, direction, speed, center, Arrays.asList(players));
+	}
+
+	/**
+	 * Represents the property of a particle effect
+	 * <p>
+	 * This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.7
+	 */
+	public static enum ParticleProperty {
+		/**
+		 * The particle effect requires water to be displayed
+		 */
+		REQUIRES_WATER,
+		/**
+		 * The particle effect requires block or item data to be displayed
+		 */
+		REQUIRES_DATA,
+		/**
+		 * The particle effect uses the offsets as direction values
+		 */
+		DIRECTIONAL,
+		/**
+		 * The particle effect uses the offsets as color values
+		 */
+		COLORABLE;
+	}
+
 	/**
 	 * Represents the particle data for effects like {@link ParticleEffect#ITEM_CRACK}, {@link ParticleEffect#BLOCK_CRACK} and {@link ParticleEffect#BLOCK_DUST}
 	 * <p>
@@ -870,7 +1036,200 @@ public enum ParticleEffect {
 	}
 
 	/**
-	 * Represents a runtime exception that is thrown if the displayed particle effect requires data and has none or vice-versa
+	 * Represents the color for effects like {@link ParticleEffect#SPELL_MOB}, {@link ParticleEffect#SPELL_MOB_AMBIENT}, {@link ParticleEffect#REDSTONE} and {@link ParticleEffect#NOTE}
+	 * <p>
+	 * This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.7
+	 */
+	public static abstract class ParticleColor {
+		/**
+		 * Returns the value for the offsetX field
+		 * 
+		 * @return The offsetX value
+		 */
+		public abstract float getValueX();
+
+		/**
+		 * Returns the value for the offsetY field
+		 * 
+		 * @return The offsetY value
+		 */
+		public abstract float getValueY();
+
+		/**
+		 * Returns the value for the offsetZ field
+		 * 
+		 * @return The offsetZ value
+		 */
+		public abstract float getValueZ();
+	}
+
+	/**
+	 * Represents the color for effects like {@link ParticleEffect#SPELL_MOB}, {@link ParticleEffect#SPELL_MOB_AMBIENT} and {@link ParticleEffect#NOTE}
+	 * <p>
+	 * This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.7
+	 */
+	public static final class OrdinaryColor extends ParticleColor {
+		private final int red;
+		private final int green;
+		private final int blue;
+
+		/**
+		 * Construct a new ordinary color
+		 * 
+		 * @param red Red value of the RGB format
+		 * @param green Green value of the RGB format
+		 * @param blue Blue value of the RGB format
+		 * @throws IllegalArgumentException If one of the values is lower than 0 or higher than 255
+		 */
+		public OrdinaryColor(int red, int green, int blue) throws IllegalArgumentException {
+			if (red < 0) {
+				throw new IllegalArgumentException("The red value is lower than 0");
+			}
+			if (red > 255) {
+				throw new IllegalArgumentException("The red value is higher than 255");
+			}
+			this.red = red;
+			if (green < 0) {
+				throw new IllegalArgumentException("The green value is lower than 0");
+			}
+			if (green > 255) {
+				throw new IllegalArgumentException("The green value is higher than 255");
+			}
+			this.green = green;
+			if (blue < 0) {
+				throw new IllegalArgumentException("The blue value is lower than 0");
+			}
+			if (blue > 255) {
+				throw new IllegalArgumentException("The blue value is higher than 255");
+			}
+			this.blue = blue;
+		}
+
+		/**
+		 * Returns the red value of the RGB format
+		 * 
+		 * @return The red value
+		 */
+		public int getRed() {
+			return red;
+		}
+
+		/**
+		 * Returns the green value of the RGB format
+		 * 
+		 * @return The green value
+		 */
+		public int getGreen() {
+			return green;
+		}
+
+		/**
+		 * Returns the blue value of the RGB format
+		 * 
+		 * @return The blue value
+		 */
+		public int getBlue() {
+			return blue;
+		}
+
+		/**
+		 * Returns the red value divided by 255
+		 * 
+		 * @return The offsetX value
+		 */
+		@Override
+		public float getValueX() {
+			return (float) red / 255F;
+		}
+
+		/**
+		 * Returns the green value divided by 255
+		 * 
+		 * @return The offsetY value
+		 */
+		@Override
+		public float getValueY() {
+			return (float) green / 255F;
+		}
+
+		/**
+		 * Returns the blue value divided by 255
+		 * 
+		 * @return The offsetZ value
+		 */
+		@Override
+		public float getValueZ() {
+			return (float) blue / 255F;
+		}
+	}
+
+	/**
+	 * Represents the color for the {@link ParticleEffect#NOTE} effect
+	 * <p>
+	 * This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.7
+	 */
+	public static final class NoteColor extends ParticleColor {
+		private final int note;
+
+		/**
+		 * Construct a new note color
+		 * 
+		 * @param note Note id which determines color
+		 * @throws IllegalArgumentException If the note value is lower than 0 or higher than 255
+		 */
+		public NoteColor(int note) throws IllegalArgumentException {
+			if (note < 0) {
+				throw new IllegalArgumentException("The note value is lower than 0");
+			}
+			if (note > 24) {
+				throw new IllegalArgumentException("The note value is higher than 24");
+			}
+			this.note = note;
+		}
+
+		/**
+		 * Returns the note value divided by 24
+		 * 
+		 * @return The offsetX value
+		 */
+		@Override
+		public float getValueX() {
+			return (float) note / 24F;
+		}
+
+		/**
+		 * Returns zero because the offsetY value is unused
+		 * 
+		 * @return zero
+		 */
+		@Override
+		public float getValueY() {
+			return 0;
+		}
+
+		/**
+		 * Returns zero because the offsetZ value is unused
+		 * 
+		 * @return zero
+		 */
+		@Override
+		public float getValueZ() {
+			return 0;
+		}
+
+	}
+
+	/**
+	 * Represents a runtime exception that is thrown either if the displayed particle effect requires data and has none or vice-versa or if the data type is incorrect
 	 * <p>
 	 * This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
 	 * 
@@ -884,13 +1243,33 @@ public enum ParticleEffect {
 		 * Construct a new particle data exception
 		 * 
 		 * @param message Message that will be logged
-		 * @param cause Cause of the exception
 		 */
 		public ParticleDataException(String message) {
 			super(message);
 		}
 	}
 
+	/**
+	 * Represents a runtime exception that is thrown either if the displayed particle effect is not colorable or if the particle color type is incorrect
+	 * <p>
+	 * This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
+	 * 
+	 * @author DarkBlade12
+	 * @since 1.7
+	 */
+	private static final class ParticleColorException extends RuntimeException {
+		private static final long serialVersionUID = 3203085387160737484L;
+
+		/**
+		 * Construct a new particle color exception
+		 * 
+		 * @param message Message that will be logged
+		 */
+		public ParticleColorException(String message) {
+			super(message);
+		}
+	}
+
 	/**
 	 * Represents a runtime exception that is thrown if the displayed particle effect requires a newer version
 	 * <p>
@@ -906,7 +1285,6 @@ public enum ParticleEffect {
 		 * Construct a new particle version exception
 		 * 
 		 * @param message Message that will be logged
-		 * @param cause Cause of the exception
 		 */
 		public ParticleVersionException(String message) {
 			super(message);
@@ -950,7 +1328,7 @@ public enum ParticleEffect {
 		 * @param amount Amount of particles
 		 * @param longDistance Indicates whether the maximum distance is increased from 256 to 65536
 		 * @param data Data of the effect
-		 * @throws IllegalArgumentException If the speed is lower than 0 or the amount is lower than 1
+		 * @throws IllegalArgumentException If the speed or amount is lower than 0
 		 * @see #initialize()
 		 */
 		public ParticlePacket(ParticleEffect effect, float offsetX, float offsetY, float offsetZ, float speed, int amount, boolean longDistance, ParticleData data) throws IllegalArgumentException {
@@ -958,8 +1336,8 @@ public enum ParticleEffect {
 			if (speed < 0) {
 				throw new IllegalArgumentException("The speed is lower than 0");
 			}
-			if (amount < 1) {
-				throw new IllegalArgumentException("The amount is lower than 1");
+			if (amount < 0) {
+				throw new IllegalArgumentException("The amount is lower than 0");
 			}
 			this.effect = effect;
 			this.offsetX = offsetX;
@@ -980,21 +1358,22 @@ public enum ParticleEffect {
 		 * @param longDistance Indicates whether the maximum distance is increased from 256 to 65536
 		 * @param data Data of the effect
 		 * @throws IllegalArgumentException If the speed is lower than 0
-		 * @see #initialize()
+		 * @see #ParticleEffect(ParticleEffect, float, float, float, float, int, boolean, ParticleData)
 		 */
 		public ParticlePacket(ParticleEffect effect, Vector direction, float speed, boolean longDistance, ParticleData data) throws IllegalArgumentException {
-			initialize();
-			if (speed < 0) {
-				throw new IllegalArgumentException("The speed is lower than 0");
-			}
-			this.effect = effect;
-			this.offsetX = (float) direction.getX();
-			this.offsetY = (float) direction.getY();
-			this.offsetZ = (float) direction.getZ();
-			this.speed = speed;
-			this.amount = 0;
-			this.longDistance = longDistance;
-			this.data = data;
+			this(effect, (float) direction.getX(), (float) direction.getY(), (float) direction.getZ(), speed, 0, longDistance, data);
+		}
+
+		/**
+		 * Construct a new particle packet of a single colored particle
+		 * 
+		 * @param effect Particle effect
+		 * @param color Color of the particle
+		 * @param longDistance Indicates whether the maximum distance is increased from 256 to 65536
+		 * @see #ParticleEffect(ParticleEffect, float, float, float, float, int, boolean, ParticleData)
+		 */
+		public ParticlePacket(ParticleEffect effect, ParticleColor color, boolean longDistance) {
+			this(effect, color.getValueX(), color.getValueY(), color.getValueZ(), 1, 0, longDistance, null);
 		}
 
 		/**
@@ -1043,44 +1422,55 @@ public enum ParticleEffect {
 			return initialized;
 		}
 
+		/**
+		 * Initializes {@link #packet} with all set values
+		 * 
+		 * @param center Center location of the effect
+		 * @throws PacketInstantiationException If instantion fails due to an unknown error
+		 */
+		private void initializePacket(Location center) throws PacketInstantiationException {
+			if (packet != null) {
+				return;
+			}
+			try {
+				packet = packetConstructor.newInstance();
+				if (version < 8) {
+					String name = effect.getName();
+					if (data != null) {
+						name += data.getPacketDataString();
+					}
+					ReflectionUtils.setValue(packet, true, "a", name);
+				} else {
+					ReflectionUtils.setValue(packet, true, "a", enumParticle.getEnumConstants()[effect.getId()]);
+					ReflectionUtils.setValue(packet, true, "j", longDistance);
+					if (data != null) {
+						ReflectionUtils.setValue(packet, true, "k", data.getPacketData());
+					}
+				}
+				ReflectionUtils.setValue(packet, true, "b", (float) center.getX());
+				ReflectionUtils.setValue(packet, true, "c", (float) center.getY());
+				ReflectionUtils.setValue(packet, true, "d", (float) center.getZ());
+				ReflectionUtils.setValue(packet, true, "e", offsetX);
+				ReflectionUtils.setValue(packet, true, "f", offsetY);
+				ReflectionUtils.setValue(packet, true, "g", offsetZ);
+				ReflectionUtils.setValue(packet, true, "h", speed);
+				ReflectionUtils.setValue(packet, true, "i", amount);
+			} catch (Exception exception) {
+				throw new PacketInstantiationException("Packet instantiation failed", exception);
+			}
+		}
+
 		/**
 		 * Sends the packet to a single player and caches it
 		 * 
 		 * @param center Center location of the effect
 		 * @param player Receiver of the packet
-		 * @throws PacketInstantiationException if instantion fails due to an unknown error
-		 * @throws PacketSendingException if sending fails due to an unknown error
+		 * @throws PacketInstantiationException If instantion fails due to an unknown error
+		 * @throws PacketSendingException If sending fails due to an unknown error
+		 * @see #initializePacket(Location)
 		 */
 		public void sendTo(Location center, Player player) throws PacketInstantiationException, PacketSendingException {
-			if (packet == null) {
-				try {
-					packet = packetConstructor.newInstance();
-					Object id;
-					if (version < 8) {
-						id = effect.getName();
-						if (data != null) {
-							id = (String)id + data.getPacketDataString();
-						}
-					} else {
-						id = enumParticle.getEnumConstants()[effect.getId()];
-					}
-					ReflectionUtils.setValue(packet, true, "a", id);
-					ReflectionUtils.setValue(packet, true, "b", (float) center.getX());
-					ReflectionUtils.setValue(packet, true, "c", (float) center.getY());
-					ReflectionUtils.setValue(packet, true, "d", (float) center.getZ());
-					ReflectionUtils.setValue(packet, true, "e", offsetX);
-					ReflectionUtils.setValue(packet, true, "f", offsetY);
-					ReflectionUtils.setValue(packet, true, "g", offsetZ);
-					ReflectionUtils.setValue(packet, true, "h", speed);
-					ReflectionUtils.setValue(packet, true, "i", amount);
-					if (version > 7) {
-						ReflectionUtils.setValue(packet, true, "j", longDistance);
-						ReflectionUtils.setValue(packet, true, "k", data == null ? new int[0] : data.getPacketData());
-					}
-				} catch (Exception exception) {
-					throw new PacketInstantiationException("Packet instantiation failed", exception);
-				}
-			}
+			initializePacket(center);
 			try {
 				sendPacket.invoke(playerConnection.get(getHandle.invoke(player)), packet);
 			} catch (Exception exception) {
@@ -1200,9 +1590,9 @@ public enum ParticleEffect {
 		display(offsetX, offsetY, offsetZ, speed, amount, center, 32);
 	}
 	
-	public void display(float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, Player... players) throws IllegalArgumentException {
+	/*public void display(float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, Player... players) throws IllegalArgumentException {
 		display(offsetX, offsetY, offsetZ, speed, amount, center, Arrays.asList(players));
-	}
+	}*/
 	
 	// Backwards compatibility
 	
@@ -1214,4 +1604,4 @@ public enum ParticleEffect {
 		display(offsetX, offsetY, offsetZ, speed, amount, center, players);
 	}
 	
-}
\ No newline at end of file
+}
diff --git a/src/com/massivecraft/massivecore/particleeffect/ReflectionUtils.java b/src/com/massivecraft/massivecore/particleeffect/ReflectionUtils.java
index ef48a8a5..4bbddc89 100644
--- a/src/com/massivecraft/massivecore/particleeffect/ReflectionUtils.java
+++ b/src/com/massivecraft/massivecore/particleeffect/ReflectionUtils.java
@@ -603,4 +603,4 @@ public final class ReflectionUtils {
 			return true;
 		}
 	}
-}
\ No newline at end of file
+}