Restructuration des packages
This commit is contained in:
@@ -0,0 +1,793 @@
|
||||
package net.mc_pandacraft.java.util.bukkit.protocol;
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
/**
|
||||
* <b>ParticleEffect Library</b>
|
||||
* <p>
|
||||
* This library was created by @DarkBlade12 based on content related to particles of @microgeek (names and packet parameters), it allows you to display all Minecraft particle effects on a Bukkit server
|
||||
* <p>
|
||||
* You are welcome to use it, modify it and redistribute it under the following conditions:
|
||||
* <ul>
|
||||
* <li>Don't claim this class as your own
|
||||
* <li>Don't remove this disclaimer
|
||||
* </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.5
|
||||
*/
|
||||
public enum ParticleEffect {
|
||||
/**
|
||||
* A particle effect which is displayed by exploding tnt and creepers:
|
||||
* <ul>
|
||||
* <li>It looks like a crowd of gray balls which are fading away
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
HUGE_EXPLOSION("hugeexplosion"),
|
||||
/**
|
||||
* A particle effect which is displayed by exploding ghast fireballs and wither skulls:
|
||||
* <ul>
|
||||
* <li>It looks like a gray ball which is fading away
|
||||
* <li>The speed value slightly influences the size of this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
LARGE_EXPLODE("largeexplode"),
|
||||
/**
|
||||
* A particle effect which is displayed by launching fireworks:
|
||||
* <ul>
|
||||
* <li>It looks like a white star which is sparkling
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
FIREWORKS_SPARK("fireworksSpark"),
|
||||
/**
|
||||
* A particle effect which is displayed by swimming entities and arrows in water:
|
||||
* <ul>
|
||||
* <li>It looks like a bubble
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
BUBBLE("bubble", true),
|
||||
/**
|
||||
* A particle effect which is displayed by water:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny blue square
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
SUSPEND("suspend", true),
|
||||
/**
|
||||
* A particle effect which is displayed by air when close to bedrock and the in the void:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny gray square
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
DEPTH_SUSPEND("depthSuspend"),
|
||||
/**
|
||||
* A particle effect which is displayed by mycelium:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny gray square
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
TOWN_AURA("townaura"),
|
||||
/**
|
||||
* A particle effect which is displayed when landing a critical hit and by arrows:
|
||||
* <ul>
|
||||
* <li>It looks like a light brown cross
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
CRIT("crit"),
|
||||
/**
|
||||
* A particle effect which is displayed when landing a hit with an enchanted weapon:
|
||||
* <ul>
|
||||
* <li>It looks like a cyan star
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
MAGIC_CRIT("magicCrit"),
|
||||
/**
|
||||
* A particle effect which is displayed by primed tnt, torches, droppers, dispensers, end portals, brewing stands and monster spawners:
|
||||
* <ul>
|
||||
* <li>It looks like a little gray cloud
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
SMOKE("smoke"),
|
||||
/**
|
||||
* A particle effect which is displayed by entities with active potion effects:
|
||||
* <ul>
|
||||
* <li>It looks like a colored swirl
|
||||
* <li>The speed value causes the particle to be colored black when set to 0
|
||||
* </ul>
|
||||
*/
|
||||
MOB_SPELL("mobSpell"),
|
||||
/**
|
||||
* A particle effect which is displayed by entities with active potion effects applied through a beacon:
|
||||
* <ul>
|
||||
* <li>It looks like a transparent colored swirl
|
||||
* <li>The speed value causes the particle to be always colored black when set to 0
|
||||
* </ul>
|
||||
*/
|
||||
MOB_SPELL_AMBIENT("mobSpellAmbient"),
|
||||
/**
|
||||
* 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
|
||||
* </ul>
|
||||
*/
|
||||
SPELL("spell"),
|
||||
/**
|
||||
* A particle effect which is displayed when instant splash potions hit something:
|
||||
* <ul>
|
||||
* <li>It looks like a white cross
|
||||
* <li>The speed value causes the particle to only move upwards when set to 0
|
||||
* </ul>
|
||||
*/
|
||||
INSTANT_SPELL("instantSpell"),
|
||||
/**
|
||||
* 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
|
||||
* </ul>
|
||||
*/
|
||||
WITCH_MAGIC("witchMagic"),
|
||||
/**
|
||||
* A particle effect which is displayed by note blocks:
|
||||
* <ul>
|
||||
* <li>It looks like a colored note
|
||||
* <li>The speed value causes the particle to be colored green when set to 0
|
||||
* </ul>
|
||||
*/
|
||||
NOTE("note"),
|
||||
/**
|
||||
* A particle effect which is displayed by nether portals, endermen, ender pearls, eyes of ender, ender chests and dragon eggs:
|
||||
* <ul>
|
||||
* <li>It looks like a purple cloud
|
||||
* <li>The speed value influences the spread of this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
PORTAL("portal"),
|
||||
/**
|
||||
* A particle effect which is displayed by enchantment tables which are nearby bookshelves:
|
||||
* <ul>
|
||||
* <li>It looks like a cryptic white letter
|
||||
* <li>The speed value influences the spread of this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
ENCHANTMENT_TABLE("enchantmenttable"),
|
||||
/**
|
||||
* A particle effect which is displayed by exploding tnt and creepers:
|
||||
* <ul>
|
||||
* <li>It looks like a white cloud
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
EXPLODE("explode"),
|
||||
/**
|
||||
* A particle effect which is displayed by torches, active furnaces, magma cubes and monster spawners:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny flame
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
FLAME("flame"),
|
||||
/**
|
||||
* A particle effect which is displayed by lava:
|
||||
* <ul>
|
||||
* <li>It looks like a spark
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
LAVA("lava"),
|
||||
/**
|
||||
* A particle effect which is currently unused:
|
||||
* <ul>
|
||||
* <li>It looks like a transparent gray square
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
FOOTSTEP("footstep"),
|
||||
/**
|
||||
* A particle effect which is displayed by swimming entities, rain dropping on the ground and shaking wolves:
|
||||
* <ul>
|
||||
* <li>It looks like a blue drop
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
SPLASH("splash"),
|
||||
/**
|
||||
* A particle effect which is displayed on water when fishing:
|
||||
* <ul>
|
||||
* <li>It looks like a blue droplet
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
WAKE("wake"),
|
||||
/**
|
||||
* A particle effect which is displayed by fire, minecarts with furnace and blazes:
|
||||
* <ul>
|
||||
* <li>It looks like a large gray cloud
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
LARGE_SMOKE("largesmoke"),
|
||||
/**
|
||||
* A particle effect which is displayed when a mob dies:
|
||||
* <ul>
|
||||
* <li>It looks like a large white cloud
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
CLOUD("cloud"),
|
||||
/**
|
||||
* A particle effect which is displayed by redstone ore, powered redstone, redstone torches and redstone repeaters:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny colored cloud
|
||||
* <li>The speed value causes the particle to be colored red when set to 0
|
||||
* </ul>
|
||||
*/
|
||||
RED_DUST("reddust"),
|
||||
/**
|
||||
* A particle effect which is displayed when snowballs or eggs hit something:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny part of the snowball icon
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
SNOWBALL_POOF("snowballpoof"),
|
||||
/**
|
||||
* A particle effect which is displayed by blocks beneath a water source:
|
||||
* <ul>
|
||||
* <li>It looks like a blue drip
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
DRIP_WATER("dripWater"),
|
||||
/**
|
||||
* A particle effect which is displayed by blocks beneath a lava source:
|
||||
* <ul>
|
||||
* <li>It looks like an orange drip
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
DRIP_LAVA("dripLava"),
|
||||
/**
|
||||
* A particle effect which is currently unused:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny white cloud
|
||||
* <li>The speed value influences the velocity at which the particle flies off
|
||||
* </ul>
|
||||
*/
|
||||
SNOW_SHOVEL("snowshovel"),
|
||||
/**
|
||||
* A particle effect which is displayed by slimes:
|
||||
* <ul>
|
||||
* <li>It looks like a tiny part of the slimeball icon
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
SLIME("slime"),
|
||||
/**
|
||||
* A particle effect which is displayed when breeding and taming animals:
|
||||
* <ul>
|
||||
* <li>It looks like a red heart
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
HEART("heart"),
|
||||
/**
|
||||
* A particle effect which is displayed when attacking a villager in a village:
|
||||
* <ul>
|
||||
* <li>It looks like a cracked gray heart
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
ANGRY_VILLAGER("angryVillager"),
|
||||
/**
|
||||
* A particle effect which is displayed when using bone meal and trading with a villager in a village:
|
||||
* <ul>
|
||||
* <li>It looks like a green star
|
||||
* <li>The speed value has no influence on this particle effect
|
||||
* </ul>
|
||||
*/
|
||||
HAPPY_VILLAGER("happyVillager");
|
||||
|
||||
private static final Map<String, ParticleEffect> NAME_MAP = new HashMap<String, ParticleEffect>();
|
||||
private final String name;
|
||||
private final boolean requiresWater;
|
||||
|
||||
// Initialize map for quick name lookup
|
||||
static {
|
||||
for (ParticleEffect effect : values()) {
|
||||
NAME_MAP.put(effect.name, effect);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new particle effect
|
||||
*
|
||||
* @param name Name of this particle effect
|
||||
* @param requiresWater Indicates whether water is required for this particle effect to display properly
|
||||
*/
|
||||
private ParticleEffect(String name, boolean requiresWater) {
|
||||
this.name = name;
|
||||
this.requiresWater = requiresWater;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new particle effect with {@link #requiresWater} set to <code>false</code>
|
||||
*
|
||||
* @param name Name of this particle effect
|
||||
* @see #ParticleEffect(String, boolean)
|
||||
*/
|
||||
private ParticleEffect(String name) {
|
||||
this(name, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the name of this particle effect
|
||||
*
|
||||
* @return The name
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if water is required for this particle effect to display properly
|
||||
*
|
||||
* @return Whether water is required or not
|
||||
*/
|
||||
public boolean getRequiresWater() {
|
||||
return requiresWater;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the particle effect with the given name
|
||||
*
|
||||
* @param name Name of the particle effect
|
||||
* @return The particle effect
|
||||
*/
|
||||
public static ParticleEffect fromName(String name) {
|
||||
for (Entry<String, ParticleEffect> entry : NAME_MAP.entrySet()) {
|
||||
if (!entry.getKey().equalsIgnoreCase(name)) {
|
||||
continue;
|
||||
}
|
||||
return entry.getValue();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if water is at a certain location
|
||||
*
|
||||
* @param location Location to check
|
||||
* @return Whether water is at this location or not
|
||||
*/
|
||||
private static boolean isWater(Location location) {
|
||||
Material material = location.getBlock().getType();
|
||||
return material == Material.WATER || material == Material.STATIONARY_WATER;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if an id is a block id
|
||||
*
|
||||
* @param id Id to check
|
||||
* @return Whether id is a block or not
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
private static boolean isBlock(int id) {
|
||||
Material material = Material.getMaterial(id);
|
||||
return material != null && material.isBlock();
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays a particle effect which is only visible for all players within a certain range in the world of @param center
|
||||
*
|
||||
* @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 range Range of the visibility (Maximum range for particles is usually 16, but it can differ for some types)
|
||||
* @throws IllegalArgumentException If the particle effect requires water and none is at the center location
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, double)
|
||||
*/
|
||||
public void display(float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, double range) throws IllegalArgumentException {
|
||||
if (requiresWater && !isWater(center)) {
|
||||
throw new IllegalArgumentException("There is no water at the center location");
|
||||
}
|
||||
new ParticleEffectPacket(name, offsetX, offsetY, offsetZ, speed, amount).sendTo(center, range);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 IllegalArgumentException If the particle effect requires water and none is at the center location
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, List)
|
||||
*/
|
||||
public void display(float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, List<Player> players) throws IllegalArgumentException {
|
||||
if (requiresWater && !isWater(center)) {
|
||||
throw new IllegalArgumentException("There is no water at the center location");
|
||||
}
|
||||
new ParticleEffectPacket(name, offsetX, offsetY, offsetZ, speed, amount).sendTo(center, players);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays an icon crack (item break) particle effect which is only visible for all players within a certain range in the world of @param center
|
||||
*
|
||||
* @param id Id of the icon
|
||||
* @param data Data value
|
||||
* @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 range Range of the visibility (Maximum range for particles is usually 16, but it can differ for some types)
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, double)
|
||||
*/
|
||||
public static void displayIconCrack(int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, double range) {
|
||||
new ParticleEffectPacket("iconcrack_" + id + "_" + data, offsetX, offsetY, offsetZ, speed, amount).sendTo(center, range);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays an icon crack (item break) particle effect which is only visible for the specified players
|
||||
*
|
||||
* @param id Id of the icon
|
||||
* @param data Data value
|
||||
* @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
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, List)
|
||||
*/
|
||||
public static void displayIconCrack(int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, List<Player> players) {
|
||||
new ParticleEffectPacket("iconcrack_" + id + "_" + data, offsetX, offsetY, offsetZ, speed, amount).sendTo(center, players);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays a block crack (block break) particle effect which is only visible for all players within a certain range in the world of @param center
|
||||
*
|
||||
* @param id Id of the block
|
||||
* @param data Data value
|
||||
* @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 amount Amount of particles
|
||||
* @param center Center location of the effect
|
||||
* @param range Range of the visibility (Maximum range for particles is usually 16, but it can differ for some types)
|
||||
* @throws IllegalArgumentException If the specified id is not a block id
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, double)
|
||||
*/
|
||||
public static void displayBlockCrack(int id, byte data, float offsetX, float offsetY, float offsetZ, int amount, Location center, double range) throws IllegalArgumentException {
|
||||
if (!isBlock(id)) {
|
||||
throw new IllegalArgumentException("Invalid block id");
|
||||
}
|
||||
new ParticleEffectPacket("blockcrack_" + id + "_" + data, offsetX, offsetY, offsetZ, 0, amount).sendTo(center, range);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays a block crack (block break) particle effect which is only visible for the specified players
|
||||
*
|
||||
* @param id Id of the block
|
||||
* @param data Data value
|
||||
* @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 amount Amount of particles
|
||||
* @param center Center location of the effect
|
||||
* @param players Receivers of the effect
|
||||
* @throws IllegalArgumentException If the specified id is not a block id
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, List)
|
||||
*/
|
||||
public static void displayBlockCrack(int id, byte data, float offsetX, float offsetY, float offsetZ, int amount, Location center, List<Player> players) throws IllegalArgumentException {
|
||||
if (!isBlock(id)) {
|
||||
throw new IllegalArgumentException("Invalid block id");
|
||||
}
|
||||
new ParticleEffectPacket("blockcrack_" + id + "_" + data, offsetX, offsetY, offsetZ, 0, amount).sendTo(center, players);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays a block dust particle effect which is only visible for all players within a certain range in the world of @param center
|
||||
*
|
||||
* @param id Id of the block
|
||||
* @param data Data value
|
||||
* @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 range Range of the visibility (Maximum range for particles is usually 16, but it can differ for some types)
|
||||
* @throws IllegalArgumentException If the specified id is not a block id
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, double)
|
||||
*/
|
||||
public static void displayBlockDust(int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, double range) throws IllegalArgumentException {
|
||||
if (!isBlock(id)) {
|
||||
throw new IllegalArgumentException("Invalid block id");
|
||||
}
|
||||
new ParticleEffectPacket("blockdust_" + id + "_" + data, offsetX, offsetY, offsetZ, speed, amount).sendTo(center, range);
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays a block dust particle effect which is only visible for the specified players
|
||||
*
|
||||
* @param id Id of the block
|
||||
* @param data Data value
|
||||
* @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 IllegalArgumentException If the specified id is not a block id
|
||||
* @see ParticleEffectPacket
|
||||
* @see ParticleEffectPacket#sendTo(Location, List)
|
||||
*/
|
||||
public static void displayBlockDust(int id, byte data, float offsetX, float offsetY, float offsetZ, float speed, int amount, Location center, List<Player> players) throws IllegalArgumentException {
|
||||
if (!isBlock(id)) {
|
||||
throw new IllegalArgumentException("Invalid block id");
|
||||
}
|
||||
new ParticleEffectPacket("blockdust_" + id + "_" + data, offsetX, offsetY, offsetZ, speed, amount).sendTo(center, players);
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a particle effect packet with all attributes which is used for sending packets to the players
|
||||
* <p>
|
||||
* This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.5
|
||||
*/
|
||||
public static final class ParticleEffectPacket {
|
||||
private static Constructor<?> packetConstructor;
|
||||
private static Method getHandle;
|
||||
private static Field playerConnection;
|
||||
private static Method sendPacket;
|
||||
private static boolean initialized;
|
||||
private final String name;
|
||||
private final float offsetX;
|
||||
private final float offsetY;
|
||||
private final float offsetZ;
|
||||
private final float speed;
|
||||
private final int amount;
|
||||
private Object packet;
|
||||
|
||||
/**
|
||||
* Construct a new particle effect packet
|
||||
*
|
||||
* @param name Name 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
|
||||
* @throws IllegalArgumentException If the speed is lower than 0 or the amount is lower than 1
|
||||
* @see #initialize()
|
||||
*/
|
||||
public ParticleEffectPacket(String name, float offsetX, float offsetY, float offsetZ, float speed, int amount) throws IllegalArgumentException {
|
||||
initialize();
|
||||
if (speed < 0) {
|
||||
throw new IllegalArgumentException("The speed is lower than 0");
|
||||
}
|
||||
if (amount < 1) {
|
||||
throw new IllegalArgumentException("The amount is lower than 1");
|
||||
}
|
||||
this.name = name;
|
||||
this.offsetX = offsetX;
|
||||
this.offsetY = offsetY;
|
||||
this.offsetZ = offsetZ;
|
||||
this.speed = speed;
|
||||
this.amount = amount;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes {@link #packetConstructor}, {@link #getHandle}, {@link #playerConnection} and {@link #sendPacket} and sets {@link #initialized} to <code>true</code> if it succeeds
|
||||
* <p>
|
||||
* <b>Note:</b> These fields only have to be initialized once, so it will return if {@link #initialized} is already set to <code>true</code>
|
||||
*
|
||||
* @throws VersionIncompatibleException if accessed packets, fields or methods differ in your bukkit version
|
||||
*/
|
||||
public static void initialize() throws VersionIncompatibleException {
|
||||
if (initialized) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
int version = Integer.parseInt(Character.toString(ReflectionUtils.PackageType.getServerVersion().charAt(3)));
|
||||
Class<?> packetClass = ReflectionUtils.PackageType.MINECRAFT_SERVER.getClass(version < 7 ? "Packet63WorldParticles" : ReflectionUtils.PacketType.PLAY_OUT_WORLD_PARTICLES.getName());
|
||||
packetConstructor = ReflectionUtils.getConstructor(packetClass);
|
||||
getHandle = ReflectionUtils.getMethod("CraftPlayer", ReflectionUtils.PackageType.CRAFTBUKKIT_ENTITY, "getHandle");
|
||||
playerConnection = ReflectionUtils.getField("EntityPlayer", ReflectionUtils.PackageType.MINECRAFT_SERVER, false, "playerConnection");
|
||||
sendPacket = ReflectionUtils.getMethod(playerConnection.getType(), "sendPacket", ReflectionUtils.PackageType.MINECRAFT_SERVER.getClass("Packet"));
|
||||
} catch (Exception exception) {
|
||||
throw new VersionIncompatibleException("Your current bukkit version seems to be incompatible with this library", exception);
|
||||
}
|
||||
initialized = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if {@link #packetConstructor}, {@link #getHandle}, {@link #playerConnection} and {@link #sendPacket} are initialized
|
||||
*
|
||||
* @return Whether these fields are initialized or not
|
||||
* @see #initialize()
|
||||
*/
|
||||
public static boolean isInitialized() {
|
||||
return initialized;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
*/
|
||||
public void sendTo(Location center, Player player) throws PacketInstantiationException, PacketSendingException {
|
||||
if (packet == null) {
|
||||
try {
|
||||
packet = packetConstructor.newInstance();
|
||||
ReflectionUtils.setValue(packet, true, "a", name);
|
||||
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);
|
||||
}
|
||||
}
|
||||
try {
|
||||
sendPacket.invoke(playerConnection.get(getHandle.invoke(player)), packet);
|
||||
} catch (Exception exception) {
|
||||
throw new PacketSendingException("Failed to send the packet to player '" + player.getName() + "'", exception);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends the packet to all players in the list
|
||||
*
|
||||
* @param center Center location of the effect
|
||||
* @param players Receivers of the packet
|
||||
* @throws IllegalArgumentException If the player list is empty
|
||||
* @see #sendTo(Location center, Player player)
|
||||
*/
|
||||
public void sendTo(Location center, List<Player> players) throws IllegalArgumentException {
|
||||
if (players.isEmpty()) {
|
||||
throw new IllegalArgumentException("The player list is empty");
|
||||
}
|
||||
for (Player player : players) {
|
||||
sendTo(center, player);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends the packet to all players in a certain range
|
||||
*
|
||||
* @param center Center location of the effect
|
||||
* @param range Range in which players will receive the packet (Maximum range for particles is usually 16, but it can differ for some types)
|
||||
* @throws IllegalArgumentException If the range is lower than 1
|
||||
* @see #sendTo(Location center, Player player)
|
||||
*/
|
||||
public void sendTo(Location center, double range) throws IllegalArgumentException {
|
||||
if (range < 1) {
|
||||
throw new IllegalArgumentException("The range is lower than 1");
|
||||
}
|
||||
String worldName = center.getWorld().getName();
|
||||
double squared = range * range;
|
||||
for (Player player : Bukkit.getOnlinePlayers()) {
|
||||
if (!player.getWorld().getName().equals(worldName) || player.getLocation().distanceSquared(center) > squared) {
|
||||
continue;
|
||||
}
|
||||
sendTo(center, player);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a runtime exception that is thrown if a bukkit version is not compatible with this library
|
||||
* <p>
|
||||
* This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.5
|
||||
*/
|
||||
private static final class VersionIncompatibleException extends RuntimeException {
|
||||
private static final long serialVersionUID = 3203085387160737484L;
|
||||
|
||||
/**
|
||||
* Construct a new version incompatible exception
|
||||
*
|
||||
* @param message Message that will be logged
|
||||
* @param cause Cause of the exception
|
||||
*/
|
||||
public VersionIncompatibleException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a runtime exception that is thrown if packet instantiation fails
|
||||
* <p>
|
||||
* This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.4
|
||||
*/
|
||||
private static final class PacketInstantiationException extends RuntimeException {
|
||||
private static final long serialVersionUID = 3203085387160737484L;
|
||||
|
||||
/**
|
||||
* Construct a new packet instantiation exception
|
||||
*
|
||||
* @param message Message that will be logged
|
||||
* @param cause Cause of the exception
|
||||
*/
|
||||
public PacketInstantiationException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a runtime exception that is thrown if packet sending fails
|
||||
* <p>
|
||||
* This class is part of the <b>ParticleEffect Library</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.4
|
||||
*/
|
||||
private static final class PacketSendingException extends RuntimeException {
|
||||
private static final long serialVersionUID = 3203085387160737484L;
|
||||
|
||||
/**
|
||||
* Construct a new packet sending exception
|
||||
*
|
||||
* @param message Message that will be logged
|
||||
* @param cause Cause of the exception
|
||||
*/
|
||||
public PacketSendingException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,758 @@
|
||||
package net.mc_pandacraft.java.util.bukkit.protocol;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
|
||||
/**
|
||||
* <b>ReflectionUtils</b>
|
||||
* <p>
|
||||
* This class provides useful methods which makes dealing with reflection much easier, especially when working with Bukkit
|
||||
* <p>
|
||||
* You are welcome to use it, modify it and redistribute it under the following conditions:
|
||||
* <ul>
|
||||
* <li>Don't claim this class as your own
|
||||
* <li>Don't remove this disclaimer
|
||||
* </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.1
|
||||
*/
|
||||
public final class ReflectionUtils {
|
||||
// Prevent accidential construction
|
||||
private ReflectionUtils() {}
|
||||
|
||||
/**
|
||||
* Returns the constructor of a given class with the given parameter types
|
||||
*
|
||||
* @param clazz Target class
|
||||
* @param parameterTypes Parameter types of the desired constructor
|
||||
* @return The constructor of the target class with the specified parameter types
|
||||
* @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
|
||||
* @see DataType
|
||||
* @see DataType#getPrimitive(Class[])
|
||||
* @see DataType#compare(Class[], Class[])
|
||||
*/
|
||||
public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... parameterTypes) throws NoSuchMethodException {
|
||||
Class<?>[] primitiveTypes = DataType.getPrimitive(parameterTypes);
|
||||
for (Constructor<?> constructor : clazz.getConstructors()) {
|
||||
if (!DataType.compare(DataType.getPrimitive(constructor.getParameterTypes()), primitiveTypes)) {
|
||||
continue;
|
||||
}
|
||||
return constructor;
|
||||
}
|
||||
throw new NoSuchMethodException("There is no such constructor in this class with the specified parameter types");
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the constructor of a desired class with the given parameter types
|
||||
*
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param parameterTypes Parameter types of the desired constructor
|
||||
* @return The constructor of the desired target class with the specified parameter types
|
||||
* @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
|
||||
* @throws ClassNotFoundException ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #getClass(String, PackageType)
|
||||
* @see #getConstructor(Class, Class...)
|
||||
*/
|
||||
public static Constructor<?> getConstructor(String className, PackageType packageType, Class<?>... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
|
||||
return getConstructor(packageType.getClass(className), parameterTypes);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an instance of a class with the given arguments
|
||||
*
|
||||
* @param clazz Target class
|
||||
* @param arguments Arguments which are used to construct an object of the target class
|
||||
* @return The instance of the target class with the specified arguments
|
||||
* @throws InstantiationException If you cannot create an instance of the target class due to certain circumstances
|
||||
* @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
|
||||
* @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
|
||||
* @throws InvocationTargetException If the desired constructor cannot be invoked
|
||||
* @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
|
||||
*/
|
||||
public static Object instantiateObject(Class<?> clazz, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
|
||||
return getConstructor(clazz, DataType.getPrimitive(arguments)).newInstance(arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an instance of a desired class with the given arguments
|
||||
*
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param arguments Arguments which are used to construct an object of the desired target class
|
||||
* @return The instance of the desired target class with the specified arguments
|
||||
* @throws InstantiationException If you cannot create an instance of the desired target class due to certain circumstances
|
||||
* @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
|
||||
* @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
|
||||
* @throws InvocationTargetException If the desired constructor cannot be invoked
|
||||
* @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
|
||||
* @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #getClass(String, PackageType)
|
||||
* @see #instantiateObject(Class, Object...)
|
||||
*/
|
||||
public static Object instantiateObject(String className, PackageType packageType, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
|
||||
return instantiateObject(packageType.getClass(className), arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a method of a class with the given parameter types
|
||||
*
|
||||
* @param clazz Target class
|
||||
* @param methodName Name of the desired method
|
||||
* @param parameterTypes Parameter types of the desired method
|
||||
* @return The method of the target class with the specified name and parameter types
|
||||
* @throws NoSuchMethodException If the desired method of the target class with the specified name and parameter types cannot be found
|
||||
* @see DataType#getPrimitive(Class[])
|
||||
* @see DataType#compare(Class[], Class[])
|
||||
*/
|
||||
public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
|
||||
Class<?>[] primitiveTypes = DataType.getPrimitive(parameterTypes);
|
||||
for (Method method : clazz.getMethods()) {
|
||||
if (!method.getName().equals(methodName) || !DataType.compare(DataType.getPrimitive(method.getParameterTypes()), primitiveTypes)) {
|
||||
continue;
|
||||
}
|
||||
return method;
|
||||
}
|
||||
throw new NoSuchMethodException("There is no such method in this class with the specified name and parameter types");
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a method of a desired class with the given parameter types
|
||||
*
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param methodName Name of the desired method
|
||||
* @param parameterTypes Parameter types of the desired method
|
||||
* @return The method of the desired target class with the specified name and parameter types
|
||||
* @throws NoSuchMethodException If the desired method of the desired target class with the specified name and parameter types cannot be found
|
||||
* @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #getClass(String, PackageType)
|
||||
* @see #getMethod(Class, String, Class...)
|
||||
*/
|
||||
public static Method getMethod(String className, PackageType packageType, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
|
||||
return getMethod(packageType.getClass(className), methodName, parameterTypes);
|
||||
}
|
||||
|
||||
/**
|
||||
* Invokes a method on an object with the given arguments
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param methodName Name of the desired method
|
||||
* @param arguments Arguments which are used to invoke the desired method
|
||||
* @return The result of invoking the desired method on the target object
|
||||
* @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
|
||||
* @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
|
||||
* @throws InvocationTargetException If the desired method cannot be invoked on the target object
|
||||
* @throws NoSuchMethodException If the desired method of the class of the target object with the specified name and arguments cannot be found
|
||||
* @see #getMethod(Class, String, Class...)
|
||||
* @see DataType#getPrimitive(Object[])
|
||||
*/
|
||||
public static Object invokeMethod(Object instance, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
|
||||
return getMethod(instance.getClass(), methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Invokes a method of the target class on an object with the given arguments
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param clazz Target class
|
||||
* @param methodName Name of the desired method
|
||||
* @param arguments Arguments which are used to invoke the desired method
|
||||
* @return The result of invoking the desired method on the target object
|
||||
* @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
|
||||
* @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
|
||||
* @throws InvocationTargetException If the desired method cannot be invoked on the target object
|
||||
* @throws NoSuchMethodException If the desired method of the target class with the specified name and arguments cannot be found
|
||||
* @see #getMethod(Class, String, Class...)
|
||||
* @see DataType#getPrimitive(Object[])
|
||||
*/
|
||||
public static Object invokeMethod(Object instance, Class<?> clazz, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
|
||||
return getMethod(clazz, methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Invokes a method of a desired class on an object with the given arguments
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param methodName Name of the desired method
|
||||
* @param arguments Arguments which are used to invoke the desired method
|
||||
* @return The result of invoking the desired method on the target object
|
||||
* @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
|
||||
* @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
|
||||
* @throws InvocationTargetException If the desired method cannot be invoked on the target object
|
||||
* @throws NoSuchMethodException If the desired method of the desired target class with the specified name and arguments cannot be found
|
||||
* @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #getClass(String, PackageType)
|
||||
* @see #invokeMethod(Object, Class, String, Object...)
|
||||
*/
|
||||
public static Object invokeMethod(Object instance, String className, PackageType packageType, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
|
||||
return invokeMethod(instance, packageType.getClass(className), methodName, arguments);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a field of the target class with the given name
|
||||
*
|
||||
* @param clazz Target class
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @return The field of the target class with the specified name
|
||||
* @throws NoSuchFieldException If the desired field of the given class cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
*/
|
||||
public static Field getField(Class<?> clazz, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException {
|
||||
Field field = declared ? clazz.getDeclaredField(fieldName) : clazz.getField(fieldName);
|
||||
field.setAccessible(true);
|
||||
return field;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a field of a desired class with the given name
|
||||
*
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @return The field of the desired target class with the specified name
|
||||
* @throws NoSuchFieldException If the desired field of the desired class cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #getField(Class, boolean, String)
|
||||
*/
|
||||
public static Field getField(String className, PackageType packageType, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException, ClassNotFoundException {
|
||||
return getField(packageType.getClass(className), declared, fieldName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value of a field of the given class of an object
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param clazz Target class
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @return The value of field of the target object
|
||||
* @throws IllegalArgumentException If the target object does not feature the desired field
|
||||
* @throws IllegalAccessException If the desired field cannot be accessed
|
||||
* @throws NoSuchFieldException If the desired field of the target class cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @see #getField(Class, boolean, String)
|
||||
*/
|
||||
public static Object getValue(Object instance, Class<?> clazz, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
|
||||
return getField(clazz, declared, fieldName).get(instance);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value of a field of a desired class of an object
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @return The value of field of the target object
|
||||
* @throws IllegalArgumentException If the target object does not feature the desired field
|
||||
* @throws IllegalAccessException If the desired field cannot be accessed
|
||||
* @throws NoSuchFieldException If the desired field of the desired class cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #getValue(Object, Class, boolean, String)
|
||||
*/
|
||||
public static Object getValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
|
||||
return getValue(instance, packageType.getClass(className), declared, fieldName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value of a field with the given name of an object
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @return The value of field of the target object
|
||||
* @throws IllegalArgumentException If the target object does not feature the desired field (should not occur since it searches for a field with the given name in the class of the object)
|
||||
* @throws IllegalAccessException If the desired field cannot be accessed
|
||||
* @throws NoSuchFieldException If the desired field of the target object cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @see #getValue(Object, Class, boolean, String)
|
||||
*/
|
||||
public static Object getValue(Object instance, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
|
||||
return getValue(instance, instance.getClass(), declared, fieldName);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the value of a field of the given class of an object
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param clazz Target class
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @param value New value
|
||||
* @throws IllegalArgumentException If the type of the value does not match the type of the desired field
|
||||
* @throws IllegalAccessException If the desired field cannot be accessed
|
||||
* @throws NoSuchFieldException If the desired field of the target class cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @see #getField(Class, boolean, String)
|
||||
*/
|
||||
public static void setValue(Object instance, Class<?> clazz, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
|
||||
getField(clazz, declared, fieldName).set(instance, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the value of a field of a desired class of an object
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param className Name of the desired target class
|
||||
* @param packageType Package where the desired target class is located
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @param value New value
|
||||
* @throws IllegalArgumentException If the type of the value does not match the type of the desired field
|
||||
* @throws IllegalAccessException If the desired field cannot be accessed
|
||||
* @throws NoSuchFieldException If the desired field of the desired class cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
|
||||
* @see #setValue(Object, Class, boolean, String, Object)
|
||||
*/
|
||||
public static void setValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
|
||||
setValue(instance, packageType.getClass(className), declared, fieldName, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the value of a field with the given name of an object
|
||||
*
|
||||
* @param instance Target object
|
||||
* @param declared Whether the desired field is declared or not
|
||||
* @param fieldName Name of the desired field
|
||||
* @param value New value
|
||||
* @throws IllegalArgumentException If the type of the value does not match the type of the desired field
|
||||
* @throws IllegalAccessException If the desired field cannot be accessed
|
||||
* @throws NoSuchFieldException If the desired field of the target object cannot be found
|
||||
* @throws SecurityException If the desired field cannot be made accessible
|
||||
* @see #setValue(Object, Class, boolean, String, Object)
|
||||
*/
|
||||
public static void setValue(Object instance, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
|
||||
setValue(instance, instance.getClass(), declared, fieldName, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents an enumeration of dynamic packages of NMS and CraftBukkit
|
||||
* <p>
|
||||
* This class is part of the <b>ReflectionUtils</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.0
|
||||
*/
|
||||
public enum PackageType {
|
||||
MINECRAFT_SERVER("net.minecraft.server." + getServerVersion()),
|
||||
CRAFTBUKKIT("org.bukkit.craftbukkit." + getServerVersion()),
|
||||
CRAFTBUKKIT_BLOCK(CRAFTBUKKIT, "block"),
|
||||
CRAFTBUKKIT_CHUNKIO(CRAFTBUKKIT, "chunkio"),
|
||||
CRAFTBUKKIT_COMMAND(CRAFTBUKKIT, "command"),
|
||||
CRAFTBUKKIT_CONVERSATIONS(CRAFTBUKKIT, "conversations"),
|
||||
CRAFTBUKKIT_ENCHANTMENS(CRAFTBUKKIT, "enchantments"),
|
||||
CRAFTBUKKIT_ENTITY(CRAFTBUKKIT, "entity"),
|
||||
CRAFTBUKKIT_EVENT(CRAFTBUKKIT, "event"),
|
||||
CRAFTBUKKIT_GENERATOR(CRAFTBUKKIT, "generator"),
|
||||
CRAFTBUKKIT_HELP(CRAFTBUKKIT, "help"),
|
||||
CRAFTBUKKIT_INVENTORY(CRAFTBUKKIT, "inventory"),
|
||||
CRAFTBUKKIT_MAP(CRAFTBUKKIT, "map"),
|
||||
CRAFTBUKKIT_METADATA(CRAFTBUKKIT, "metadata"),
|
||||
CRAFTBUKKIT_POTION(CRAFTBUKKIT, "potion"),
|
||||
CRAFTBUKKIT_PROJECTILES(CRAFTBUKKIT, "projectiles"),
|
||||
CRAFTBUKKIT_SCHEDULER(CRAFTBUKKIT, "scheduler"),
|
||||
CRAFTBUKKIT_SCOREBOARD(CRAFTBUKKIT, "scoreboard"),
|
||||
CRAFTBUKKIT_UPDATER(CRAFTBUKKIT, "updater"),
|
||||
CRAFTBUKKIT_UTIL(CRAFTBUKKIT, "util");
|
||||
|
||||
private final String path;
|
||||
|
||||
/**
|
||||
* Construct a new package type
|
||||
*
|
||||
* @param path Path of the package
|
||||
*/
|
||||
private PackageType(String path) {
|
||||
this.path = path;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new package type
|
||||
*
|
||||
* @param parent Parent package of the package
|
||||
* @param path Path of the package
|
||||
*/
|
||||
private PackageType(PackageType parent, String path) {
|
||||
this(parent + "." + path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the path of this package type
|
||||
*
|
||||
* @return The path
|
||||
*/
|
||||
public String getPath() {
|
||||
return path;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the class with the given name
|
||||
*
|
||||
* @param className Name of the desired class
|
||||
* @return The class with the specified name
|
||||
* @throws ClassNotFoundException If the desired class with the specified name and package cannot be found
|
||||
*/
|
||||
public Class<?> getClass(String className) throws ClassNotFoundException {
|
||||
return Class.forName(this + "." + className);
|
||||
}
|
||||
|
||||
// Override for convenience
|
||||
@Override
|
||||
public String toString() {
|
||||
return path;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the version of your server
|
||||
*
|
||||
* @return The server version
|
||||
*/
|
||||
public static String getServerVersion() {
|
||||
return Bukkit.getServer().getClass().getPackage().getName().substring(23);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents an enumeration of Java data types with corresponding classes
|
||||
* <p>
|
||||
* This class is part of the <b>ReflectionUtils</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.0
|
||||
*/
|
||||
public enum DataType {
|
||||
BYTE(byte.class, Byte.class),
|
||||
SHORT(short.class, Short.class),
|
||||
INTEGER(int.class, Integer.class),
|
||||
LONG(long.class, Long.class),
|
||||
CHARACTER(char.class, Character.class),
|
||||
FLOAT(float.class, Float.class),
|
||||
DOUBLE(double.class, Double.class),
|
||||
BOOLEAN(boolean.class, Boolean.class);
|
||||
|
||||
private static final Map<Class<?>, DataType> CLASS_MAP = new HashMap<Class<?>, DataType>();
|
||||
private final Class<?> primitive;
|
||||
private final Class<?> reference;
|
||||
|
||||
// Initialize map for quick class lookup
|
||||
static {
|
||||
for (DataType type : values()) {
|
||||
CLASS_MAP.put(type.primitive, type);
|
||||
CLASS_MAP.put(type.reference, type);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new data type
|
||||
*
|
||||
* @param primitive Primitive class of this data type
|
||||
* @param reference Reference class of this data type
|
||||
*/
|
||||
private DataType(Class<?> primitive, Class<?> reference) {
|
||||
this.primitive = primitive;
|
||||
this.reference = reference;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the primitive class of this data type
|
||||
*
|
||||
* @return The primitive class
|
||||
*/
|
||||
public Class<?> getPrimitive() {
|
||||
return primitive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the reference class of this data type
|
||||
*
|
||||
* @return The reference class
|
||||
*/
|
||||
public Class<?> getReference() {
|
||||
return reference;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the data type with the given primitive/reference class
|
||||
*
|
||||
* @param clazz Primitive/Reference class of the data type
|
||||
* @return The data type
|
||||
*/
|
||||
public static DataType fromClass(Class<?> clazz) {
|
||||
return CLASS_MAP.get(clazz);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the primitive class of the data type with the given reference class
|
||||
*
|
||||
* @param clazz Reference class of the data type
|
||||
* @return The primitive class
|
||||
*/
|
||||
public static Class<?> getPrimitive(Class<?> clazz) {
|
||||
DataType type = fromClass(clazz);
|
||||
return type == null ? clazz : type.getPrimitive();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the reference class of the data type with the given primitive class
|
||||
*
|
||||
* @param clazz Primitive class of the data type
|
||||
* @return The reference class
|
||||
*/
|
||||
public static Class<?> getReference(Class<?> clazz) {
|
||||
DataType type = fromClass(clazz);
|
||||
return type == null ? clazz : type.getReference();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the primitive class array of the given class array
|
||||
*
|
||||
* @param classes Given class array
|
||||
* @return The primitive class array
|
||||
*/
|
||||
public static Class<?>[] getPrimitive(Class<?>[] classes) {
|
||||
int length = classes == null ? 0 : classes.length;
|
||||
Class<?>[] types = new Class<?>[length];
|
||||
for (int index = 0; index < length; index++) {
|
||||
types[index] = getPrimitive(classes[index]);
|
||||
}
|
||||
return types;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the reference class array of the given class array
|
||||
*
|
||||
* @param classes Given class array
|
||||
* @return The reference class array
|
||||
*/
|
||||
public static Class<?>[] getReference(Class<?>[] classes) {
|
||||
int length = classes == null ? 0 : classes.length;
|
||||
Class<?>[] types = new Class<?>[length];
|
||||
for (int index = 0; index < length; index++) {
|
||||
types[index] = getReference(classes[index]);
|
||||
}
|
||||
return types;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the primitive class array of the given object array
|
||||
*
|
||||
* @param object Given object array
|
||||
* @return The primitive class array
|
||||
*/
|
||||
public static Class<?>[] getPrimitive(Object[] objects) {
|
||||
int length = objects == null ? 0 : objects.length;
|
||||
Class<?>[] types = new Class<?>[length];
|
||||
for (int index = 0; index < length; index++) {
|
||||
types[index] = getPrimitive(objects[index].getClass());
|
||||
}
|
||||
return types;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the reference class array of the given object array
|
||||
*
|
||||
* @param object Given object array
|
||||
* @return The reference class array
|
||||
*/
|
||||
public static Class<?>[] getReference(Object[] objects) {
|
||||
int length = objects == null ? 0 : objects.length;
|
||||
Class<?>[] types = new Class<?>[length];
|
||||
for (int index = 0; index < length; index++) {
|
||||
types[index] = getReference(objects[index].getClass());
|
||||
}
|
||||
return types;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares two class arrays on equivalence
|
||||
*
|
||||
* @param primary Primary class array
|
||||
* @param secondary Class array which is compared to the primary array
|
||||
* @return Whether these arrays are equal or not
|
||||
*/
|
||||
public static boolean compare(Class<?>[] primary, Class<?>[] secondary) {
|
||||
if (primary == null || secondary == null || primary.length != secondary.length) {
|
||||
return false;
|
||||
}
|
||||
for (int index = 0; index < primary.length; index++) {
|
||||
Class<?> primaryClass = primary[index];
|
||||
Class<?> secondaryClass = secondary[index];
|
||||
if (primaryClass.equals(secondaryClass) || primaryClass.isAssignableFrom(secondaryClass)) {
|
||||
continue;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents an enumeration of all packet types that are featured in <b>Minecraft 1.7.10</b>
|
||||
* <p>
|
||||
* If this enumeration is no longer up-to-date, please let me know in my <a href="http://forums.bukkit.org/threads/lib-1-7-particleeffect-v1-4.154406">forum post</a>
|
||||
* <p>
|
||||
* This class is part of the <b>ReflectionUtils</b> and follows the same usage conditions
|
||||
*
|
||||
* @author DarkBlade12
|
||||
* @since 1.0
|
||||
*/
|
||||
public enum PacketType {
|
||||
HANDSHAKING_IN_SET_PROTOCOL("PacketHandshakingInSetProtocol"),
|
||||
LOGIN_IN_ENCRYPTION_BEGIN("PacketLoginInEncryptionBegin"),
|
||||
LOGIN_IN_START("PacketLoginInStart"),
|
||||
LOGIN_OUT_DISCONNECT("PacketLoginOutDisconnect"),
|
||||
LOGIN_OUT_ENCRYPTION_BEGIN("PacketLoginOutEncryptionBegin"),
|
||||
LOGIN_OUT_SUCCESS("PacketLoginOutSuccess"),
|
||||
PLAY_IN_ABILITIES("PacketPlayInAbilities"),
|
||||
PLAY_IN_ARM_ANIMATION("PacketPlayInArmAnimation"),
|
||||
PLAY_IN_BLOCK_DIG("PacketPlayInBlockDig"),
|
||||
PLAY_IN_BLOCK_PLACE("PacketPlayInBlockPlace"),
|
||||
PLAY_IN_CHAT("PacketPlayInChat"),
|
||||
PLAY_IN_CLIENT_COMMAND("PacketPlayInClientCommand"),
|
||||
PLAY_IN_CLOSE_WINDOW("PacketPlayInCloseWindow"),
|
||||
PLAY_IN_CUSTOM_PAYLOAD("PacketPlayInCustomPayload"),
|
||||
PLAY_IN_ENCHANT_ITEM("PacketPlayInEnchantItem"),
|
||||
PLAY_IN_ENTITY_ACTION("PacketPlayInEntityAction"),
|
||||
PLAY_IN_FLYING("PacketPlayInFlying"),
|
||||
PLAY_IN_HELD_ITEM_SLOT("PacketPlayInHeldItemSlot"),
|
||||
PLAY_IN_KEEP_ALIVE("PacketPlayInKeepAlive"),
|
||||
PLAY_IN_LOOK("PacketPlayInLook"),
|
||||
PLAY_IN_POSITION("PacketPlayInPosition"),
|
||||
PLAY_IN_POSITION_LOOK("PacketPlayInPositionLook"),
|
||||
PLAY_IN_SET_CREATIVE_SLOT("PacketPlayInSetCreativeSlot "),
|
||||
PLAY_IN_SETTINGS("PacketPlayInSettings"),
|
||||
PLAY_IN_STEER_VEHICLE("PacketPlayInSteerVehicle"),
|
||||
PLAY_IN_TAB_COMPLETE("PacketPlayInTabComplete"),
|
||||
PLAY_IN_TRANSACTION("PacketPlayInTransaction"),
|
||||
PLAY_IN_UPDATE_SIGN("PacketPlayInUpdateSign"),
|
||||
PLAY_IN_USE_ENTITY("PacketPlayInUseEntity"),
|
||||
PLAY_IN_WINDOW_CLICK("PacketPlayInWindowClick"),
|
||||
PLAY_OUT_ABILITIES("PacketPlayOutAbilities"),
|
||||
PLAY_OUT_ANIMATION("PacketPlayOutAnimation"),
|
||||
PLAY_OUT_ATTACH_ENTITY("PacketPlayOutAttachEntity"),
|
||||
PLAY_OUT_BED("PacketPlayOutBed"),
|
||||
PLAY_OUT_BLOCK_ACTION("PacketPlayOutBlockAction"),
|
||||
PLAY_OUT_BLOCK_BREAK_ANIMATION("PacketPlayOutBlockBreakAnimation"),
|
||||
PLAY_OUT_BLOCK_CHANGE("PacketPlayOutBlockChange"),
|
||||
PLAY_OUT_CHAT("PacketPlayOutChat"),
|
||||
PLAY_OUT_CLOSE_WINDOW("PacketPlayOutCloseWindow"),
|
||||
PLAY_OUT_COLLECT("PacketPlayOutCollect"),
|
||||
PLAY_OUT_CRAFT_PROGRESS_BAR("PacketPlayOutCraftProgressBar"),
|
||||
PLAY_OUT_CUSTOM_PAYLOAD("PacketPlayOutCustomPayload"),
|
||||
PLAY_OUT_ENTITY("PacketPlayOutEntity"),
|
||||
PLAY_OUT_ENTITY_DESTROY("PacketPlayOutEntityDestroy"),
|
||||
PLAY_OUT_ENTITY_EFFECT("PacketPlayOutEntityEffect"),
|
||||
PLAY_OUT_ENTITY_EQUIPMENT("PacketPlayOutEntityEquipment"),
|
||||
PLAY_OUT_ENTITY_HEAD_ROTATION("PacketPlayOutEntityHeadRotation"),
|
||||
PLAY_OUT_ENTITY_LOOK("PacketPlayOutEntityLook"),
|
||||
PLAY_OUT_ENTITY_METADATA("PacketPlayOutEntityMetadata"),
|
||||
PLAY_OUT_ENTITY_STATUS("PacketPlayOutEntityStatus"),
|
||||
PLAY_OUT_ENTITY_TELEPORT("PacketPlayOutEntityTeleport"),
|
||||
PLAY_OUT_ENTITY_VELOCITY("PacketPlayOutEntityVelocity"),
|
||||
PLAY_OUT_EXPERIENCE("PacketPlayOutExperience"),
|
||||
PLAY_OUT_EXPLOSION("PacketPlayOutExplosion"),
|
||||
PLAY_OUT_GAME_STATE_CHANGE("PacketPlayOutGameStateChange"),
|
||||
PLAY_OUT_HELD_ITEM_SLOT("PacketPlayOutHeldItemSlot"),
|
||||
PLAY_OUT_KEEP_ALIVE("PacketPlayOutKeepAlive"),
|
||||
PLAY_OUT_KICK_DISCONNECT("PacketPlayOutKickDisconnect"),
|
||||
PLAY_OUT_LOGIN("PacketPlayOutLogin"),
|
||||
PLAY_OUT_MAP("PacketPlayOutMap"),
|
||||
PLAY_OUT_MAP_CHUNK("PacketPlayOutMapChunk"),
|
||||
PLAY_OUT_MAP_CHUNK_BULK("PacketPlayOutMapChunkBulk"),
|
||||
PLAY_OUT_MULTI_BLOCK_CHANGE("PacketPlayOutMultiBlockChange"),
|
||||
PLAY_OUT_NAMED_ENTITY_SPAWN("PacketPlayOutNamedEntitySpawn"),
|
||||
PLAY_OUT_NAMED_SOUND_EFFECT("PacketPlayOutNamedSoundEffect"),
|
||||
PLAY_OUT_OPEN_SIGN_EDITOR("PacketPlayOutOpenSignEditor"),
|
||||
PLAY_OUT_OPEN_WINDOW("PacketPlayOutOpenWindow"),
|
||||
PLAY_OUT_PLAYER_INFO("PacketPlayOutPlayerInfo"),
|
||||
PLAY_OUT_POSITION("PacketPlayOutPosition"),
|
||||
PLAY_OUT_REL_ENTITY_MOVE("PacketPlayOutRelEntityMove"),
|
||||
PLAY_OUT_REL_ENTITY_MOVE_LOOK("PacketPlayOutRelEntityMoveLook"),
|
||||
PLAY_OUT_REMOVE_ENTITY_EFFECT("PacketPlayOutRemoveEntityEffect"),
|
||||
PLAY_OUT_RESPAWN("PacketPlayOutRespawn"),
|
||||
PLAY_OUT_SCOREBOARD_DISPLAY_OBJECTIVE("PacketPlayOutScoreboardDisplayObjective"),
|
||||
PLAY_OUT_SCOREBOARD_OBJECTIVE("PacketPlayOutScoreboardObjective"),
|
||||
PLAY_OUT_SCOREBOARD_SCORE("PacketPlayOutScoreboardScore"),
|
||||
PLAY_OUT_SCOREBOARD_TEAM("PacketPlayOutScoreboardTeam"),
|
||||
PLAY_OUT_SET_SLOT("PacketPlayOutSetSlot"),
|
||||
PLAY_OUT_SPAWN_ENTITY("PacketPlayOutSpawnEntity"),
|
||||
PLAY_OUT_SPAWN_ENTITY_EXPERIENCE_ORB("PacketPlayOutSpawnEntityExperienceOrb"),
|
||||
PLAY_OUT_SPAWN_ENTITY_LIVING("PacketPlayOutSpawnEntityLiving"),
|
||||
PLAY_OUT_SPAWN_ENTITY_PAINTING("PacketPlayOutSpawnEntityPainting"),
|
||||
PLAY_OUT_SPAWN_ENTITY_WEATHER("PacketPlayOutSpawnEntityWeather"),
|
||||
PLAY_OUT_SPAWN_POSITION("PacketPlayOutSpawnPosition"),
|
||||
PLAY_OUT_STATISTIC("PacketPlayOutStatistic"),
|
||||
PLAY_OUT_TAB_COMPLETE("PacketPlayOutTabComplete"),
|
||||
PLAY_OUT_TILE_ENTITY_DATA("PacketPlayOutTileEntityData"),
|
||||
PLAY_OUT_TRANSACTION("PacketPlayOutTransaction"),
|
||||
PLAY_OUT_UPDATE_ATTRIBUTES("PacketPlayOutUpdateAttributes"),
|
||||
PLAY_OUT_UPDATE_HEALTH("PacketPlayOutUpdateHealth"),
|
||||
PLAY_OUT_UPDATE_SIGN("PacketPlayOutUpdateSign"),
|
||||
PLAY_OUT_UPDATE_TIME("PacketPlayOutUpdateTime"),
|
||||
PLAY_OUT_WINDOW_ITEMS("PacketPlayOutWindowItems"),
|
||||
PLAY_OUT_WORLD_EVENT("PacketPlayOutWorldEvent"),
|
||||
PLAY_OUT_WORLD_PARTICLES("PacketPlayOutWorldParticles"),
|
||||
STATUS_IN_PING("PacketStatusInPing"),
|
||||
STATUS_IN_START("PacketStatusInStart"),
|
||||
STATUS_OUT_PONG("PacketStatusOutPong"),
|
||||
STATUS_OUT_SERVER_INFO("PacketStatusOutServerInfo");
|
||||
|
||||
private static final Map<String, PacketType> NAME_MAP = new HashMap<String, PacketType>();
|
||||
private final String name;
|
||||
private Class<?> packet;
|
||||
|
||||
// Initialize map for quick name lookup
|
||||
static {
|
||||
for (PacketType type : values()) {
|
||||
NAME_MAP.put(type.name, type);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new packet type
|
||||
*
|
||||
* @param name Name of this packet
|
||||
*/
|
||||
private PacketType(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the name of this packet type
|
||||
*
|
||||
* @return The name
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the class of this packet
|
||||
*
|
||||
* @return The packet class
|
||||
* @throws ClassNotFoundException If the packet class cannot be found (the name differs in your Bukkit version)
|
||||
*
|
||||
*/
|
||||
public Class<?> getPacket() throws ClassNotFoundException {
|
||||
return packet == null ? (packet = PackageType.MINECRAFT_SERVER.getClass(name)) : packet;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user