Convert back to maven
This commit is contained in:
BuildTools
@@ -1,399 +0,0 @@
|
||||
package me.libraryaddict.disguise;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.AnimalColor;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.MiscDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.MobDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.PlayerDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.TargetedDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.TargetedDisguise.TargetType;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.HorseWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.bukkit.DyeColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.bukkit.entity.Horse;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.EntityEquipment;
|
||||
import org.bukkit.inventory.HorseInventory;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.potion.PotionEffect;
|
||||
import org.bukkit.potion.PotionEffectType;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
public class DisguiseAPI {
|
||||
|
||||
public static Disguise constructDisguise(Entity entity) {
|
||||
return constructDisguise(entity, true, true, true);
|
||||
}
|
||||
|
||||
public static Disguise constructDisguise(Entity entity, boolean doEquipment, boolean doSneak, boolean doSprint) {
|
||||
DisguiseType disguiseType = DisguiseType.getType(entity);
|
||||
Disguise disguise;
|
||||
if (disguiseType.isMisc()) {
|
||||
disguise = new MiscDisguise(disguiseType);
|
||||
} else if (disguiseType.isMob()) {
|
||||
disguise = new MobDisguise(disguiseType);
|
||||
} else {
|
||||
disguise = new PlayerDisguise(entity.getName());
|
||||
}
|
||||
FlagWatcher watcher = disguise.getWatcher();
|
||||
if (entity instanceof LivingEntity) {
|
||||
for (PotionEffect effect : ((LivingEntity) entity).getActivePotionEffects()) {
|
||||
((LivingWatcher) watcher).addPotionEffect(effect.getType());
|
||||
if (effect.getType() == PotionEffectType.INVISIBILITY) {
|
||||
watcher.setInvisible(true);
|
||||
} else if (effect.getType() == PotionEffectType.GLOWING) {
|
||||
watcher.setGlowing(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (entity.getFireTicks() > 0) {
|
||||
watcher.setBurning(true);
|
||||
}
|
||||
if (doEquipment && entity instanceof LivingEntity) {
|
||||
EntityEquipment equip = ((LivingEntity) entity).getEquipment();
|
||||
watcher.setArmor(equip.getArmorContents());
|
||||
watcher.setItemInMainHand(equip.getItemInMainHand());
|
||||
if (disguiseType.getEntityType() == EntityType.HORSE) {
|
||||
Horse horse = (Horse) entity;
|
||||
HorseInventory horseInventory = horse.getInventory();
|
||||
ItemStack saddle = horseInventory.getSaddle();
|
||||
if (saddle != null && saddle.getType() == Material.SADDLE) {
|
||||
((HorseWatcher) watcher).setSaddled(true);
|
||||
}
|
||||
((HorseWatcher) watcher).setHorseArmor(horseInventory.getArmor());
|
||||
}
|
||||
}
|
||||
for (Method method : entity.getClass().getMethods()) {
|
||||
if ((doSneak || !method.getName().equals("setSneaking")) && (doSprint || !method.getName().equals("setSprinting"))
|
||||
&& method.getParameterTypes().length == 0 && method.getReturnType() != void.class) {
|
||||
Class methodReturn = method.getReturnType();
|
||||
if (methodReturn == float.class || methodReturn == Float.class || methodReturn == Double.class) {
|
||||
methodReturn = double.class;
|
||||
}
|
||||
int firstCapitalMethod = firstCapital(method.getName());
|
||||
if (firstCapitalMethod > 0) {
|
||||
for (Method watcherMethod : watcher.getClass().getMethods()) {
|
||||
if (!watcherMethod.getName().startsWith("get") && watcherMethod.getReturnType() == void.class
|
||||
&& watcherMethod.getParameterTypes().length == 1) {
|
||||
int firstCapitalWatcher = firstCapital(watcherMethod.getName());
|
||||
if (firstCapitalWatcher > 0
|
||||
&& method.getName().substring(firstCapitalMethod)
|
||||
.equalsIgnoreCase(watcherMethod.getName().substring(firstCapitalWatcher))) {
|
||||
Class methodParam = watcherMethod.getParameterTypes()[0];
|
||||
if (methodParam == float.class || methodParam == Float.class || methodParam == Double.class) {
|
||||
methodParam = double.class;
|
||||
} else if (methodParam == AnimalColor.class) {
|
||||
methodParam = DyeColor.class;
|
||||
}
|
||||
if (methodReturn == methodParam) {
|
||||
try {
|
||||
Object value = method.invoke(entity);
|
||||
if (value != null) {
|
||||
Class toCast = watcherMethod.getParameterTypes()[0];
|
||||
if (!(toCast.isInstance(value))) {
|
||||
if (toCast == float.class) {
|
||||
if (value instanceof Float) {
|
||||
value = value;
|
||||
} else {
|
||||
double d = (Double) value;
|
||||
value = (float) d;
|
||||
}
|
||||
} else if (toCast == double.class) {
|
||||
if (!(value instanceof Double)) {
|
||||
float d = (Float) value;
|
||||
value = (double) d;
|
||||
}
|
||||
} else if (toCast == AnimalColor.class) {
|
||||
value = AnimalColor.valueOf(((DyeColor) value).name());
|
||||
}
|
||||
}
|
||||
if (value instanceof Boolean && !(Boolean) value
|
||||
&& watcherMethod.getDeclaringClass() == FlagWatcher.class) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
watcherMethod.invoke(watcher, value);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return disguise;
|
||||
}
|
||||
|
||||
public static void disguiseEntity(Entity entity, Disguise disguise) {
|
||||
// If they are trying to disguise a null entity or use a null disguise
|
||||
// Just return.
|
||||
if (entity == null || disguise == null) {
|
||||
return;
|
||||
}
|
||||
// The event wasn't cancelled.
|
||||
// If the disguise entity isn't the same as the one we are disguising
|
||||
if (disguise.getEntity() != entity) {
|
||||
// If the disguise entity actually exists
|
||||
if (disguise.getEntity() != null) {
|
||||
// Clone the disguise
|
||||
disguise = disguise.clone();
|
||||
}
|
||||
// Set the disguise's entity
|
||||
disguise.setEntity(entity);
|
||||
}
|
||||
if (Disguise.getViewSelf().contains(disguise.getEntity().getUniqueId())) {
|
||||
disguise.setViewSelfDisguise(true);
|
||||
}
|
||||
disguise.startDisguise();
|
||||
}
|
||||
|
||||
public static void disguiseIgnorePlayers(Entity entity, Disguise disguise, Collection playersToNotSeeDisguise) {
|
||||
if (disguise.getEntity() != null) {
|
||||
disguise = disguise.clone();
|
||||
}
|
||||
((TargetedDisguise) disguise).setDisguiseTarget(TargetType.SHOW_TO_EVERYONE_BUT_THESE_PLAYERS);
|
||||
for (Object obj : playersToNotSeeDisguise) {
|
||||
if (obj instanceof String) {
|
||||
((TargetedDisguise) disguise).addPlayer((String) obj);
|
||||
} else if (obj instanceof Player) {
|
||||
((TargetedDisguise) disguise).addPlayer(((Player) obj).getName());
|
||||
}
|
||||
}
|
||||
disguiseEntity(entity, disguise);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public static void disguiseIgnorePlayers(Entity entity, Disguise disguise, List<String> playersToNotSeeDisguise) {
|
||||
disguiseIgnorePlayers(entity, disguise, (Collection) playersToNotSeeDisguise);
|
||||
}
|
||||
|
||||
public static void disguiseIgnorePlayers(Entity entity, Disguise disguise, Player... playersToNotSeeDisguise) {
|
||||
disguiseIgnorePlayers(entity, disguise, (Collection) Arrays.asList(playersToNotSeeDisguise));
|
||||
}
|
||||
|
||||
public static void disguiseIgnorePlayers(Entity entity, Disguise disguise, String... playersToNotSeeDisguise) {
|
||||
disguiseIgnorePlayers(entity, disguise, (Collection) Arrays.asList(playersToNotSeeDisguise));
|
||||
}
|
||||
|
||||
/**
|
||||
* Disguise the next entity to spawn with this disguise. This may not work however if the entity doesn't actually spawn.
|
||||
*
|
||||
* @param disguise
|
||||
* @return
|
||||
*/
|
||||
public static int disguiseNextEntity(Disguise disguise) {
|
||||
if (disguise == null) {
|
||||
return -1;
|
||||
}
|
||||
if (disguise.getEntity() != null || DisguiseUtilities.getDisguises().containsValue(disguise)) {
|
||||
disguise = disguise.clone();
|
||||
}
|
||||
try {
|
||||
int id = ReflectionManager.getNmsField("Entity", "entityCount").getInt(null);
|
||||
DisguiseUtilities.addFutureDisguise(id, (TargetedDisguise) disguise);
|
||||
return id;
|
||||
} catch (IllegalAccessException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disguise this entity with this disguise
|
||||
*
|
||||
* @param entity
|
||||
* @param disguise
|
||||
*/
|
||||
public static void disguiseToAll(Entity entity, Disguise disguise) {
|
||||
if (disguise.getEntity() != null) {
|
||||
disguise = disguise.clone();
|
||||
}
|
||||
// You called the disguiseToAll method foolish mortal! Prepare to have your custom settings wiped!!!
|
||||
((TargetedDisguise) disguise).setDisguiseTarget(TargetType.SHOW_TO_EVERYONE_BUT_THESE_PLAYERS);
|
||||
for (String observer : ((TargetedDisguise) disguise).getObservers()) {
|
||||
((TargetedDisguise) disguise).removePlayer(observer);
|
||||
}
|
||||
disguiseEntity(entity, disguise);
|
||||
}
|
||||
|
||||
public static void disguiseToPlayers(Entity entity, Disguise disguise, Collection playersToViewDisguise) {
|
||||
if (disguise.getEntity() != null) {
|
||||
disguise = disguise.clone();
|
||||
}
|
||||
((TargetedDisguise) disguise).setDisguiseTarget(TargetType.HIDE_DISGUISE_TO_EVERYONE_BUT_THESE_PLAYERS);
|
||||
for (Object obj : playersToViewDisguise) {
|
||||
if (obj instanceof String) {
|
||||
((TargetedDisguise) disguise).addPlayer((String) obj);
|
||||
} else if (obj instanceof Player) {
|
||||
((TargetedDisguise) disguise).addPlayer(((Player) obj).getName());
|
||||
}
|
||||
}
|
||||
disguiseEntity(entity, disguise);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public static void disguiseToPlayers(Entity entity, Disguise disguise, List<String> playersToViewDisguise) {
|
||||
disguiseToPlayers(entity, disguise, (Collection) playersToViewDisguise);
|
||||
}
|
||||
|
||||
public static void disguiseToPlayers(Entity entity, Disguise disguise, Player... playersToViewDisguise) {
|
||||
disguiseToPlayers(entity, disguise, (Collection) Arrays.asList(playersToViewDisguise));
|
||||
}
|
||||
|
||||
public static void disguiseToPlayers(Entity entity, Disguise disguise, String... playersToViewDisguise) {
|
||||
disguiseToPlayers(entity, disguise, (Collection) Arrays.asList(playersToViewDisguise));
|
||||
}
|
||||
|
||||
private static int firstCapital(String str) {
|
||||
for (int i = 0; i < str.length(); i++) {
|
||||
if (Character.isUpperCase(str.charAt(i))) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the disguise of a entity
|
||||
*
|
||||
* @param disguised
|
||||
* @return
|
||||
*/
|
||||
public static Disguise getDisguise(Entity disguised) {
|
||||
if (disguised == null) {
|
||||
return null;
|
||||
}
|
||||
return DisguiseUtilities.getMainDisguise(disguised.getUniqueId());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the disguise of a entity
|
||||
*
|
||||
* @param observer
|
||||
* @param disguised
|
||||
* @return
|
||||
*/
|
||||
public static Disguise getDisguise(Player observer, Entity disguised) {
|
||||
if (disguised == null || observer == null) {
|
||||
return null;
|
||||
}
|
||||
return DisguiseUtilities.getDisguise(observer, disguised);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the disguises of a entity
|
||||
*
|
||||
* @param disguised
|
||||
* @return
|
||||
*/
|
||||
public static Disguise[] getDisguises(Entity disguised) {
|
||||
if (disguised == null) {
|
||||
return null;
|
||||
}
|
||||
return DisguiseUtilities.getDisguises(disguised.getUniqueId());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the ID of a fake disguise for a entityplayer
|
||||
*
|
||||
* @param entityId
|
||||
* @return
|
||||
*/
|
||||
@Deprecated
|
||||
public static int getFakeDisguise(UUID entityId) {
|
||||
return -10;
|
||||
}
|
||||
|
||||
public static int getSelfDisguiseId() {
|
||||
return -10;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this entity disguised
|
||||
*
|
||||
* @param disguised
|
||||
* @return
|
||||
*/
|
||||
public static boolean isDisguised(Entity disguised) {
|
||||
return getDisguise(disguised) != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this entity disguised
|
||||
*
|
||||
* @param observer
|
||||
* @param disguised
|
||||
* @return
|
||||
*/
|
||||
public static boolean isDisguised(Player observer, Entity disguised) {
|
||||
return getDisguise(observer, disguised) != null;
|
||||
}
|
||||
|
||||
public static boolean isDisguiseInUse(Disguise disguise) {
|
||||
return disguise.isDisguiseInUse();
|
||||
}
|
||||
|
||||
public static boolean isSelfDisguised(Player player) {
|
||||
return DisguiseUtilities.getSelfDisguised().contains(player.getUniqueId());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the entitiy has /disguiseviewself toggled on.
|
||||
*
|
||||
* @param entity
|
||||
* @return
|
||||
*/
|
||||
public static boolean isViewSelfToggled(Entity entity) {
|
||||
return isDisguised(entity) ? getDisguise(entity).isSelfDisguiseVisible() : Disguise.getViewSelf().contains(entity.getUniqueId());
|
||||
}
|
||||
|
||||
/**
|
||||
* Undisguise the entity. This doesn't let you cancel the UndisguiseEvent if the entity is no longer valid. Aka removed from the world.
|
||||
*
|
||||
* @param entity
|
||||
*/
|
||||
public static void undisguiseToAll(Entity entity) {
|
||||
Disguise[] disguises = getDisguises(entity);
|
||||
for (Disguise disguise : disguises) {
|
||||
disguise.removeDisguise();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set whether this player can see his own disguise or not.
|
||||
*
|
||||
* @param entity
|
||||
* @param toggled
|
||||
*/
|
||||
public static void setViewDisguiseToggled(Entity entity, boolean toggled) {
|
||||
if (isDisguised(entity)) {
|
||||
Disguise disguise = getDisguise(entity);
|
||||
disguise.setViewSelfDisguise(toggled);
|
||||
}
|
||||
if (toggled) {
|
||||
if (!Disguise.getViewSelf().contains(entity.getUniqueId())) {
|
||||
Disguise.getViewSelf().add(entity.getUniqueId());
|
||||
}
|
||||
} else {
|
||||
Disguise.getViewSelf().remove(entity.getUniqueId());
|
||||
}
|
||||
}
|
||||
|
||||
private DisguiseAPI() {
|
||||
}
|
||||
}
|
||||
@@ -1,444 +0,0 @@
|
||||
package me.libraryaddict.disguise;
|
||||
|
||||
import me.libraryaddict.disguise.utilities.PacketsManager;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.configuration.ConfigurationSection;
|
||||
|
||||
public class DisguiseConfig {
|
||||
|
||||
private static boolean animationEnabled;
|
||||
private static boolean bedEnabled;
|
||||
private static boolean blowDisguisesOnAttack;
|
||||
private static boolean collectEnabled;
|
||||
private static boolean colorizeSheep;
|
||||
private static boolean colorizeWolf;
|
||||
private static String disguiseBlownMessage;
|
||||
private static int disguiseCloneExpire;
|
||||
private static int disguiseEntityExpire;
|
||||
private static boolean entityAnimationsAdded;
|
||||
private static boolean entityStatusEnabled;
|
||||
private static boolean equipmentEnabled;
|
||||
private static boolean hearSelfDisguise;
|
||||
private static boolean viewSelfDisguise;
|
||||
private static boolean hidingArmor;
|
||||
private static boolean hidingHeldItem;
|
||||
private static boolean keepDisguiseEntityDespawn;
|
||||
private static boolean keepDisguisePlayerDeath;
|
||||
private static boolean keepDisguisePlayerLogout;
|
||||
private static int maxClonedDisguises;
|
||||
private static boolean maxHealthIsDisguisedEntity;
|
||||
private static boolean miscDisguisesForLivingEnabled;
|
||||
private static boolean modifyBoundingBox;
|
||||
private static boolean movementEnabled;
|
||||
private static boolean sendsEntityMetadata;
|
||||
private static boolean sendVelocity;
|
||||
private static boolean showNameAboveHead;
|
||||
private static boolean showNameAboveHeadAlwaysVisible;
|
||||
private static boolean targetDisguises;
|
||||
private static boolean undisguiseSwitchWorlds;
|
||||
private static boolean stopShulkerDisguisesFromMoving;
|
||||
private static String updateMessage = ChatColor.RED + "[LibsDisguises] " + ChatColor.DARK_RED
|
||||
+ "There is a update ready to be downloaded! You are using " + ChatColor.RED + "v%s" + ChatColor.DARK_RED
|
||||
+ ", the new version is " + ChatColor.RED + "%s" + ChatColor.DARK_RED + "!";
|
||||
private static String updateNotificationPermission;
|
||||
private static boolean witherSkullEnabled;
|
||||
|
||||
public static String getDisguiseBlownMessage() {
|
||||
return disguiseBlownMessage;
|
||||
}
|
||||
|
||||
public static int getDisguiseCloneExpire() {
|
||||
return disguiseCloneExpire;
|
||||
}
|
||||
|
||||
public static int getDisguiseEntityExpire() {
|
||||
return disguiseEntityExpire;
|
||||
}
|
||||
|
||||
public static int getMaxClonedDisguises() {
|
||||
return maxClonedDisguises;
|
||||
}
|
||||
|
||||
public static String getUpdateMessage() {
|
||||
return updateMessage;
|
||||
}
|
||||
|
||||
public static String getUpdateNotificationPermission() {
|
||||
return updateNotificationPermission;
|
||||
}
|
||||
|
||||
public static void initConfig(ConfigurationSection config) {
|
||||
setSoundsEnabled(config.getBoolean("DisguiseSounds"));
|
||||
setVelocitySent(config.getBoolean("SendVelocity"));
|
||||
setViewDisguises(config.getBoolean("ViewSelfDisguises")); //Since we can now toggle, the view disguises listener must always be on
|
||||
PacketsManager.setViewDisguisesListener(true);
|
||||
setHearSelfDisguise(config.getBoolean("HearSelfDisguise"));
|
||||
setHideArmorFromSelf(config.getBoolean("RemoveArmor"));
|
||||
setHideHeldItemFromSelf(config.getBoolean("RemoveHeldItem"));
|
||||
setAddEntityAnimations(config.getBoolean("AddEntityAnimations"));
|
||||
setNameOfPlayerShownAboveDisguise(config.getBoolean("ShowNamesAboveDisguises"));
|
||||
setNameAboveHeadAlwaysVisible(config.getBoolean("NameAboveHeadAlwaysVisible"));
|
||||
setModifyBoundingBox(config.getBoolean("ModifyBoundingBox"));
|
||||
setMonstersIgnoreDisguises(config.getBoolean("MonstersIgnoreDisguises"));
|
||||
setDisguiseBlownOnAttack(config.getBoolean("BlowDisguises"));
|
||||
setDisguiseBlownMessage(ChatColor.translateAlternateColorCodes('&', config.getString("BlownDisguiseMessage")));
|
||||
setKeepDisguiseOnPlayerDeath(config.getBoolean("KeepDisguises.PlayerDeath"));
|
||||
setKeepDisguiseOnPlayerLogout(config.getBoolean("KeepDisguises.PlayerLogout"));
|
||||
setKeepDisguiseOnEntityDespawn(config.getBoolean("KeepDisguises.EntityDespawn"));
|
||||
setMiscDisguisesForLivingEnabled(config.getBoolean("MiscDisguisesForLiving"));
|
||||
setMovementPacketsEnabled(config.getBoolean("PacketsEnabled.Movement"));
|
||||
setWitherSkullPacketsEnabled(config.getBoolean("PacketsEnabled.WitherSkull"));
|
||||
setEquipmentPacketsEnabled(config.getBoolean("PacketsEnabled.Equipment"));
|
||||
setAnimationPacketsEnabled(config.getBoolean("PacketsEnabled.Animation"));
|
||||
setBedPacketsEnabled(config.getBoolean("PacketsEnabled.Bed"));
|
||||
setEntityStatusPacketsEnabled(config.getBoolean("PacketsEnabled.EntityStatus"));
|
||||
setCollectPacketsEnabled(config.getBoolean("PacketsEnabled.Collect"));
|
||||
setMetadataPacketsEnabled(config.getBoolean("PacketsEnabled.Metadata"));
|
||||
setMaxHealthDeterminedByDisguisedEntity(config.getBoolean("MaxHealthDeterminedByEntity"));
|
||||
setDisguiseEntityExpire(config.getInt("DisguiseEntityExpire"));
|
||||
setDisguiseCloneExpire(config.getInt("DisguiseCloneExpire"));
|
||||
setMaxClonedDisguises(config.getInt("DisguiseCloneSize"));
|
||||
setSheepDyeable(config.getBoolean("DyeableSheep"));
|
||||
setWolfDyeable(config.getBoolean("DyeableWolf"));
|
||||
setUndisguiseOnWorldChange(config.getBoolean("UndisguiseOnWorldChange"));
|
||||
setUpdateNotificationPermission(config.getString("Permission"));
|
||||
setStopShulkerDisguisesFromMoving(config.getBoolean("StopShulkerDisguisesFromMoving", true));
|
||||
}
|
||||
|
||||
public static boolean isAnimationPacketsEnabled() {
|
||||
return animationEnabled;
|
||||
}
|
||||
|
||||
public static boolean isBedPacketsEnabled() {
|
||||
return bedEnabled;
|
||||
}
|
||||
|
||||
public static boolean isCollectPacketsEnabled() {
|
||||
return collectEnabled;
|
||||
}
|
||||
|
||||
public static boolean isDisguiseBlownOnAttack() {
|
||||
return blowDisguisesOnAttack;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Spelling mistake.
|
||||
*/
|
||||
@Deprecated
|
||||
public static boolean isEnquipmentPacketsEnabled() {
|
||||
return equipmentEnabled;
|
||||
}
|
||||
|
||||
public static boolean isEntityAnimationsAdded() {
|
||||
return entityAnimationsAdded;
|
||||
}
|
||||
|
||||
public static boolean isEntityStatusPacketsEnabled() {
|
||||
return entityStatusEnabled;
|
||||
}
|
||||
|
||||
public static boolean isEquipmentPacketsEnabled() {
|
||||
return equipmentEnabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the plugin modifying the inventory packets so that players when self disguised, do not see their armor floating around
|
||||
*/
|
||||
public static boolean isHidingArmorFromSelf() {
|
||||
return hidingArmor;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does the plugin appear to remove the item they are holding, to prevent a floating sword when they are viewing self disguise
|
||||
*/
|
||||
public static boolean isHidingHeldItemFromSelf() {
|
||||
return hidingHeldItem;
|
||||
}
|
||||
|
||||
public static boolean isKeepDisguiseOnEntityDespawn() {
|
||||
return keepDisguiseEntityDespawn;
|
||||
}
|
||||
|
||||
public static boolean isKeepDisguiseOnPlayerDeath() {
|
||||
return keepDisguisePlayerDeath;
|
||||
}
|
||||
|
||||
public static boolean isKeepDisguiseOnPlayerLogout() {
|
||||
return keepDisguisePlayerLogout;
|
||||
}
|
||||
|
||||
public static boolean isMaxHealthDeterminedByDisguisedEntity() {
|
||||
return maxHealthIsDisguisedEntity;
|
||||
}
|
||||
|
||||
public static boolean isMetadataPacketsEnabled() {
|
||||
return sendsEntityMetadata;
|
||||
}
|
||||
|
||||
public static boolean isMiscDisguisesForLivingEnabled() {
|
||||
return miscDisguisesForLivingEnabled;
|
||||
}
|
||||
|
||||
public static boolean isModifyBoundingBox() {
|
||||
return modifyBoundingBox;
|
||||
}
|
||||
|
||||
public static boolean isMonstersIgnoreDisguises() {
|
||||
return targetDisguises;
|
||||
}
|
||||
|
||||
public static boolean isMovementPacketsEnabled() {
|
||||
return movementEnabled;
|
||||
}
|
||||
|
||||
public static boolean isNameAboveHeadAlwaysVisible() {
|
||||
return showNameAboveHeadAlwaysVisible;
|
||||
}
|
||||
|
||||
public static boolean isNameOfPlayerShownAboveDisguise() {
|
||||
return showNameAboveHead;
|
||||
}
|
||||
|
||||
public static boolean isSelfDisguisesSoundsReplaced() {
|
||||
return hearSelfDisguise;
|
||||
}
|
||||
|
||||
public static boolean isSheepDyeable() {
|
||||
return colorizeSheep;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the sound packets caught and modified
|
||||
*/
|
||||
public static boolean isSoundEnabled() {
|
||||
return PacketsManager.isHearDisguisesEnabled();
|
||||
}
|
||||
|
||||
public static boolean isUndisguiseOnWorldChange() {
|
||||
return undisguiseSwitchWorlds;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the velocity packets sent
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public static boolean isVelocitySent() {
|
||||
return sendVelocity;
|
||||
}
|
||||
|
||||
/**
|
||||
* The default value if a player views his own disguise
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public static boolean isViewDisguises() {
|
||||
return viewSelfDisguise;
|
||||
}
|
||||
|
||||
public static boolean isWitherSkullPacketsEnabled() {
|
||||
return witherSkullEnabled;
|
||||
}
|
||||
|
||||
public static boolean isWolfDyeable() {
|
||||
return colorizeWolf;
|
||||
}
|
||||
|
||||
public static void setAddEntityAnimations(boolean isEntityAnimationsAdded) {
|
||||
entityAnimationsAdded = isEntityAnimationsAdded;
|
||||
}
|
||||
|
||||
public static void setAnimationPacketsEnabled(boolean enabled) {
|
||||
if (enabled != isAnimationPacketsEnabled()) {
|
||||
animationEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setBedPacketsEnabled(boolean enabled) {
|
||||
if (enabled != isBedPacketsEnabled()) {
|
||||
bedEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setCollectPacketsEnabled(boolean enabled) {
|
||||
if (enabled != isCollectPacketsEnabled()) {
|
||||
collectEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setDisguiseBlownMessage(String newMessage) {
|
||||
disguiseBlownMessage = newMessage;
|
||||
}
|
||||
|
||||
public static void setDisguiseBlownOnAttack(boolean blowDisguise) {
|
||||
blowDisguisesOnAttack = blowDisguise;
|
||||
}
|
||||
|
||||
public static void setDisguiseCloneExpire(int newExpires) {
|
||||
disguiseCloneExpire = newExpires;
|
||||
}
|
||||
|
||||
public static void setDisguiseEntityExpire(int newExpires) {
|
||||
disguiseEntityExpire = newExpires;
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public static void setEnquipmentPacketsEnabled(boolean enabled) {
|
||||
setEquipmentPacketsEnabled(enabled);
|
||||
}
|
||||
|
||||
public static void setEntityStatusPacketsEnabled(boolean enabled) {
|
||||
if (enabled != isEntityStatusPacketsEnabled()) {
|
||||
entityStatusEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setEquipmentPacketsEnabled(boolean enabled) {
|
||||
if (enabled != isEquipmentPacketsEnabled()) {
|
||||
equipmentEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Can players hear their own disguises
|
||||
*/
|
||||
public static void setHearSelfDisguise(boolean replaceSound) {
|
||||
if (hearSelfDisguise != replaceSound) {
|
||||
hearSelfDisguise = replaceSound;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the plugin to hide self disguises armor from theirselves
|
||||
*/
|
||||
public static void setHideArmorFromSelf(boolean hideArmor) {
|
||||
if (hidingArmor != hideArmor) {
|
||||
hidingArmor = hideArmor;
|
||||
PacketsManager.setInventoryListenerEnabled(isHidingHeldItemFromSelf() || isHidingArmorFromSelf());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Does the plugin appear to remove the item they are holding, to prevent a floating sword when they are viewing self disguise
|
||||
*/
|
||||
public static void setHideHeldItemFromSelf(boolean hideHelditem) {
|
||||
if (hidingHeldItem != hideHelditem) {
|
||||
hidingHeldItem = hideHelditem;
|
||||
PacketsManager.setInventoryListenerEnabled(isHidingHeldItemFromSelf() || isHidingArmorFromSelf());
|
||||
}
|
||||
}
|
||||
|
||||
public static void setKeepDisguiseOnEntityDespawn(boolean keepDisguise) {
|
||||
keepDisguiseEntityDespawn = keepDisguise;
|
||||
}
|
||||
|
||||
public static void setKeepDisguiseOnPlayerDeath(boolean keepDisguise) {
|
||||
keepDisguisePlayerDeath = keepDisguise;
|
||||
}
|
||||
|
||||
public static void setKeepDisguiseOnPlayerLogout(boolean keepDisguise) {
|
||||
keepDisguisePlayerLogout = keepDisguise;
|
||||
}
|
||||
|
||||
public static void setMaxClonedDisguises(int newMax) {
|
||||
maxClonedDisguises = newMax;
|
||||
}
|
||||
|
||||
public static void setMaxHealthDeterminedByDisguisedEntity(boolean isDetermined) {
|
||||
maxHealthIsDisguisedEntity = isDetermined;
|
||||
}
|
||||
|
||||
public static void setMetadataPacketsEnabled(boolean enabled) {
|
||||
sendsEntityMetadata = enabled;
|
||||
}
|
||||
|
||||
public static void setMiscDisguisesForLivingEnabled(boolean enabled) {
|
||||
if (enabled != isMiscDisguisesForLivingEnabled()) {
|
||||
miscDisguisesForLivingEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setModifyBoundingBox(boolean modifyBounding) {
|
||||
modifyBoundingBox = modifyBounding;
|
||||
}
|
||||
|
||||
public static void setMonstersIgnoreDisguises(boolean ignore) {
|
||||
targetDisguises = ignore;
|
||||
}
|
||||
|
||||
public static void setMovementPacketsEnabled(boolean enabled) {
|
||||
if (enabled != isMovementPacketsEnabled()) {
|
||||
movementEnabled = enabled;
|
||||
PacketsManager.setupMainPacketsListener();
|
||||
}
|
||||
}
|
||||
|
||||
public static void setNameAboveHeadAlwaysVisible(boolean alwaysVisible) {
|
||||
showNameAboveHeadAlwaysVisible = alwaysVisible;
|
||||
}
|
||||
|
||||
public static void setNameOfPlayerShownAboveDisguise(boolean showNames) {
|
||||
showNameAboveHead = showNames;
|
||||
}
|
||||
|
||||
public static void setSheepDyeable(boolean color) {
|
||||
colorizeSheep = color;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set if the disguises play sounds when hurt
|
||||
*/
|
||||
public static void setSoundsEnabled(boolean isSoundsEnabled) {
|
||||
PacketsManager.setHearDisguisesListener(isSoundsEnabled);
|
||||
}
|
||||
|
||||
public static void setUndisguiseOnWorldChange(boolean isUndisguise) {
|
||||
undisguiseSwitchWorlds = isUndisguise;
|
||||
}
|
||||
|
||||
public static void setUpdateMessage(String newMessage) {
|
||||
updateMessage = newMessage;
|
||||
}
|
||||
|
||||
public static void setUpdateNotificationPermission(String newPermission) {
|
||||
updateNotificationPermission = newPermission;
|
||||
}
|
||||
|
||||
public static void setStopShulkerDisguisesFromMoving(boolean stopShulkerDisguisesFromMoving) {
|
||||
DisguiseConfig.stopShulkerDisguisesFromMoving = stopShulkerDisguisesFromMoving;
|
||||
}
|
||||
|
||||
public static boolean isStopShulkerDisguisesFromMoving() {
|
||||
return stopShulkerDisguisesFromMoving;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disable velocity packets being sent for w/e reason. Maybe you want every ounce of performance you can get?
|
||||
*
|
||||
* @param sendVelocityPackets
|
||||
*/
|
||||
public static void setVelocitySent(boolean sendVelocityPackets) {
|
||||
sendVelocity = sendVelocityPackets;
|
||||
}
|
||||
|
||||
public static void setViewDisguises(boolean seeOwnDisguise) {
|
||||
viewSelfDisguise = seeOwnDisguise;
|
||||
}
|
||||
|
||||
public static void setWitherSkullPacketsEnabled(boolean enabled) {
|
||||
witherSkullEnabled = enabled;
|
||||
}
|
||||
|
||||
public static void setWolfDyeable(boolean color) {
|
||||
colorizeWolf = color;
|
||||
}
|
||||
|
||||
private DisguiseConfig() {
|
||||
}
|
||||
}
|
||||
@@ -1,428 +0,0 @@
|
||||
package me.libraryaddict.disguise;
|
||||
|
||||
import com.comphenix.protocol.ProtocolLibrary;
|
||||
import com.comphenix.protocol.events.PacketContainer;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.PlayerDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.TargetedDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import me.libraryaddict.disguise.utilities.UpdateChecker;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.EventPriority;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.event.entity.EntityDamageByEntityEvent;
|
||||
import org.bukkit.event.entity.EntityTargetEvent;
|
||||
import org.bukkit.event.player.PlayerChangedWorldEvent;
|
||||
import org.bukkit.event.player.PlayerInteractEntityEvent;
|
||||
import org.bukkit.event.player.PlayerJoinEvent;
|
||||
import org.bukkit.event.player.PlayerMoveEvent;
|
||||
import org.bukkit.event.player.PlayerQuitEvent;
|
||||
import org.bukkit.event.player.PlayerRespawnEvent;
|
||||
import org.bukkit.event.player.PlayerTeleportEvent;
|
||||
import org.bukkit.event.vehicle.VehicleEnterEvent;
|
||||
import org.bukkit.event.vehicle.VehicleExitEvent;
|
||||
import org.bukkit.scheduler.BukkitRunnable;
|
||||
import org.bukkit.scheduler.BukkitTask;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
|
||||
public class DisguiseListener implements Listener {
|
||||
|
||||
private String currentVersion;
|
||||
private HashMap<String, Boolean[]> disguiseClone = new HashMap<>();
|
||||
private HashMap<String, Disguise> disguiseEntity = new HashMap<>();
|
||||
private HashMap<String, BukkitRunnable> disguiseRunnable = new HashMap<>();
|
||||
private String latestVersion;
|
||||
private LibsDisguises plugin;
|
||||
private BukkitTask updaterTask;
|
||||
|
||||
public DisguiseListener(LibsDisguises libsDisguises) {
|
||||
plugin = libsDisguises;
|
||||
if (plugin.getConfig().getBoolean("NotifyUpdate")) {
|
||||
currentVersion = plugin.getDescription().getVersion();
|
||||
updaterTask = Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
UpdateChecker updateChecker = new UpdateChecker();
|
||||
updateChecker.checkUpdate("v" + currentVersion);
|
||||
latestVersion = updateChecker.getLatestVersion();
|
||||
if (latestVersion != null) {
|
||||
latestVersion = "v" + latestVersion;
|
||||
Bukkit.getScheduler().runTask(plugin, new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
for (Player p : Bukkit.getOnlinePlayers()) {
|
||||
if (p.hasPermission(DisguiseConfig.getUpdateNotificationPermission())) {
|
||||
p.sendMessage(String.format(DisguiseConfig.getUpdateMessage(), currentVersion,
|
||||
latestVersion));
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
System.out.print(String.format("[LibsDisguises] Failed to check for update: %s", ex.getMessage()));
|
||||
}
|
||||
}
|
||||
}, 0, (20 * 60 * 60 * 6)); // Check every 6 hours
|
||||
// 20 ticks * 60 seconds * 60 minutes * 6 hours
|
||||
}
|
||||
}
|
||||
|
||||
public void cleanup() {
|
||||
for (BukkitRunnable r : disguiseRunnable.values()) {
|
||||
r.cancel();
|
||||
}
|
||||
for (Disguise d : disguiseEntity.values()) {
|
||||
d.removeDisguise();
|
||||
}
|
||||
disguiseClone.clear();
|
||||
updaterTask.cancel();
|
||||
}
|
||||
|
||||
private void checkPlayerCanBlowDisguise(Player entity) {
|
||||
Disguise[] disguises = DisguiseAPI.getDisguises(entity);
|
||||
if (disguises.length > 0) {
|
||||
DisguiseAPI.undisguiseToAll(entity);
|
||||
if (DisguiseConfig.getDisguiseBlownMessage().length() > 0) {
|
||||
entity.sendMessage(DisguiseConfig.getDisguiseBlownMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void chunkMove(Player player, Location newLoc, Location oldLoc) {
|
||||
try {
|
||||
for (PacketContainer packet : DisguiseUtilities.getBedChunkPacket(newLoc, oldLoc)) {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet, false);
|
||||
}
|
||||
if (newLoc != null) {
|
||||
for (HashSet<TargetedDisguise> list : DisguiseUtilities.getDisguises().values()) {
|
||||
for (TargetedDisguise disguise : list) {
|
||||
if (disguise.isPlayerDisguise() && disguise.canSee(player)
|
||||
&& ((PlayerDisguise) disguise).getWatcher().isSleeping()
|
||||
&& DisguiseUtilities.getPerverts(disguise).contains(player)) {
|
||||
PacketContainer[] packets = DisguiseUtilities.getBedPackets(player,
|
||||
disguise.getEntity() == player ? newLoc : disguise.getEntity().getLocation(), newLoc,
|
||||
(PlayerDisguise) disguise);
|
||||
if (disguise.getEntity() == player) {
|
||||
for (PacketContainer packet : packets) {
|
||||
packet.getIntegers().write(0, DisguiseAPI.getSelfDisguiseId());
|
||||
}
|
||||
}
|
||||
for (PacketContainer packet : packets) {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
||||
public void onAttack(EntityDamageByEntityEvent event) {
|
||||
if (DisguiseConfig.isDisguiseBlownOnAttack()) {
|
||||
if (event.getEntity() instanceof Player) {
|
||||
checkPlayerCanBlowDisguise((Player) event.getEntity());
|
||||
}
|
||||
if (event.getDamager() instanceof Player) {
|
||||
checkPlayerCanBlowDisguise((Player) event.getDamager());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onJoin(PlayerJoinEvent event) {
|
||||
Player p = event.getPlayer();
|
||||
if (latestVersion != null && p.hasPermission(DisguiseConfig.getUpdateNotificationPermission())) {
|
||||
p.sendMessage(String.format(DisguiseConfig.getUpdateMessage(), currentVersion, latestVersion));
|
||||
}
|
||||
if (DisguiseConfig.isBedPacketsEnabled()) {
|
||||
chunkMove(p, p.getLocation(), null);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Most likely faster if we don't bother doing checks if he sees a player disguise
|
||||
*/
|
||||
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
||||
public void onMove(PlayerMoveEvent event) {
|
||||
if (DisguiseConfig.isBedPacketsEnabled()) {
|
||||
Location to = event.getTo();
|
||||
Location from = event.getFrom();
|
||||
int x1 = (int) Math.floor(to.getX() / 16D) - 17;
|
||||
int x2 = (int) Math.floor(from.getX() / 16D) - 17;
|
||||
int z1 = (int) Math.floor(to.getZ() / 16D) - 17;
|
||||
int z2 = (int) Math.floor(from.getZ() / 16D) - 17;
|
||||
if (x1 - (x1 % 8) != x2 - (x2 % 8) || z1 - (z1 % 8) != z2 - (z2 % 8)) {
|
||||
chunkMove(event.getPlayer(), to, from);
|
||||
}
|
||||
}
|
||||
|
||||
if (DisguiseConfig.isStopShulkerDisguisesFromMoving()) {
|
||||
Disguise disguise;
|
||||
if ((disguise = DisguiseAPI.getDisguise(event.getPlayer())) != null) {
|
||||
if (disguise.getType() == DisguiseType.SHULKER) { //Stop Shulker disguises from moving their coordinates
|
||||
Location from = event.getFrom();
|
||||
Location to = event.getTo();
|
||||
to.setX(from.getX());
|
||||
to.setZ(from.getZ());
|
||||
event.setTo(to);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onQuit(PlayerQuitEvent event) {
|
||||
ReflectionManager.removePlayer(event.getPlayer());
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onRespawn(PlayerRespawnEvent event) {
|
||||
Disguise[] disguises = DisguiseAPI.getDisguises(event.getPlayer());
|
||||
for (Disguise disguise : disguises) {
|
||||
if (disguise.isRemoveDisguiseOnDeath()) {
|
||||
disguise.removeDisguise();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onRightClick(PlayerInteractEntityEvent event) {
|
||||
if (disguiseEntity.containsKey(event.getPlayer().getName()) || disguiseClone.containsKey(event.getPlayer().getName())) {
|
||||
Player p = event.getPlayer();
|
||||
event.setCancelled(true);
|
||||
disguiseRunnable.remove(p.getName()).cancel();
|
||||
Entity entity = event.getRightClicked();
|
||||
String entityName;
|
||||
if (entity instanceof Player && !disguiseClone.containsKey(p.getName())) {
|
||||
entityName = entity.getName();
|
||||
} else {
|
||||
entityName = DisguiseType.getType(entity).toReadable();
|
||||
}
|
||||
if (disguiseClone.containsKey(p.getName())) {
|
||||
Boolean[] options = disguiseClone.remove(p.getName());
|
||||
Disguise disguise = DisguiseAPI.getDisguise(p, entity);
|
||||
if (disguise == null) {
|
||||
disguise = DisguiseAPI.constructDisguise(entity, options[0], options[1], options[2]);
|
||||
} else {
|
||||
disguise = disguise.clone();
|
||||
}
|
||||
char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray();
|
||||
String reference = null;
|
||||
int referenceLength = Math.max(2, (int) Math.ceil((0.1D + DisguiseConfig.getMaxClonedDisguises()) / 26D));
|
||||
int attempts = 0;
|
||||
while (reference == null && attempts++ < 1000) {
|
||||
reference = "@";
|
||||
for (int i = 0; i < referenceLength; i++) {
|
||||
reference += alphabet[DisguiseUtilities.random.nextInt(alphabet.length)];
|
||||
}
|
||||
if (DisguiseUtilities.getClonedDisguise(reference) != null) {
|
||||
reference = null;
|
||||
}
|
||||
}
|
||||
if (reference != null && DisguiseUtilities.addClonedDisguise(reference, disguise)) {
|
||||
p.sendMessage(ChatColor.RED + "Constructed a " + entityName + " disguise! Your reference is " + reference);
|
||||
p.sendMessage(ChatColor.RED + "Example usage: /disguise " + reference);
|
||||
} else {
|
||||
p.sendMessage(ChatColor.RED
|
||||
+ "Failed to store the reference due to lack of size. Please set this in the config");
|
||||
}
|
||||
} else if (disguiseEntity.containsKey(p.getName())) {
|
||||
Disguise disguise = disguiseEntity.remove(p.getName());
|
||||
if (disguise != null) {
|
||||
if (disguise.isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled()
|
||||
&& entity instanceof LivingEntity) {
|
||||
p.sendMessage(ChatColor.RED
|
||||
+ "Can't disguise a living entity as a misc disguise. This has been disabled in the config!");
|
||||
} else {
|
||||
if (entity instanceof Player && DisguiseConfig.isNameOfPlayerShownAboveDisguise()) {
|
||||
if (disguise.getWatcher() instanceof LivingWatcher) {
|
||||
disguise.getWatcher().setCustomName(((Player) entity).getDisplayName());
|
||||
if (DisguiseConfig.isNameAboveHeadAlwaysVisible()) {
|
||||
disguise.getWatcher().setCustomNameVisible(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
DisguiseAPI.disguiseToAll(entity, disguise);
|
||||
String disguiseName = "a ";
|
||||
if (disguise instanceof PlayerDisguise) {
|
||||
disguiseName = "the player " + ((PlayerDisguise) disguise).getName();
|
||||
} else {
|
||||
disguiseName += disguise.getType().toReadable();
|
||||
}
|
||||
if (disguise.isDisguiseInUse()) {
|
||||
p.sendMessage(ChatColor.RED + "Disguised " + (entity instanceof Player ? "" : "the ") + entityName
|
||||
+ " as " + disguiseName + "!");
|
||||
} else {
|
||||
p.sendMessage(ChatColor.RED + "Failed to disguise " + (entity instanceof Player ? "" : "the ")
|
||||
+ entityName + " as " + disguiseName + "!");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (DisguiseAPI.isDisguised(entity)) {
|
||||
DisguiseAPI.undisguiseToAll(entity);
|
||||
p.sendMessage(ChatColor.RED + "Undisguised " + (entity instanceof Player ? "" : "the ") + entityName);
|
||||
} else {
|
||||
p.sendMessage(ChatColor.RED + (entity instanceof Player ? "" : "the") + entityName + " isn't disguised!");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onTarget(EntityTargetEvent event) {
|
||||
if (DisguiseConfig.isMonstersIgnoreDisguises() && event.getTarget() != null && event.getTarget() instanceof Player
|
||||
&& DisguiseAPI.isDisguised(event.getTarget())) {
|
||||
switch (event.getReason()) {
|
||||
case TARGET_ATTACKED_ENTITY:
|
||||
case TARGET_ATTACKED_OWNER:
|
||||
case OWNER_ATTACKED_TARGET:
|
||||
case CUSTOM:
|
||||
break;
|
||||
default:
|
||||
event.setCancelled(true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
||||
public void onTeleport(final PlayerTeleportEvent event) {
|
||||
if (!DisguiseAPI.isDisguised(event.getPlayer())) {
|
||||
return;
|
||||
}
|
||||
Location to = event.getTo();
|
||||
Location from = event.getFrom();
|
||||
if (DisguiseConfig.isBedPacketsEnabled()) {
|
||||
int x1 = (int) Math.floor(to.getX() / 16D) - 17;
|
||||
int x2 = (int) Math.floor(from.getX() / 16D) - 17;
|
||||
int z1 = (int) Math.floor(to.getZ() / 16D) - 17;
|
||||
int z2 = (int) Math.floor(from.getZ() / 16D) - 17;
|
||||
if (x1 - (x1 % 8) != x2 - (x2 % 8) || z1 - (z1 % 8) != z2 - (z2 % 8)) {
|
||||
chunkMove(event.getPlayer(), null, from);
|
||||
Bukkit.getScheduler().runTask(plugin, new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
if (!event.isCancelled()) {
|
||||
chunkMove(event.getPlayer(), event.getTo(), null);
|
||||
} else {
|
||||
chunkMove(event.getPlayer(), event.getPlayer().getLocation(), null);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
if (DisguiseConfig.isUndisguiseOnWorldChange() && to.getWorld() != null && from.getWorld() != null
|
||||
&& to.getWorld() != from.getWorld()) {
|
||||
for (Disguise disguise : DisguiseAPI.getDisguises(event.getPlayer())) {
|
||||
disguise.removeDisguise();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
||||
public void onVehicleEnter(VehicleEnterEvent event) {
|
||||
if (event.getEntered() instanceof Player && DisguiseAPI.isDisguised((Player) event.getEntered(), event.getEntered())) {
|
||||
DisguiseUtilities.removeSelfDisguise((Player) event.getEntered());
|
||||
((Player) event.getEntered()).updateInventory();
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
||||
public void onVehicleLeave(VehicleExitEvent event) {
|
||||
if (event.getExited() instanceof Player) {
|
||||
final Disguise disguise = DisguiseAPI.getDisguise((Player) event.getExited(), event.getExited());
|
||||
if (disguise != null) {
|
||||
Bukkit.getScheduler().runTask(plugin, new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
DisguiseUtilities.setupFakeDisguise(disguise);
|
||||
((Player) disguise.getEntity()).updateInventory();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
||||
public void onWorldSwitch(final PlayerChangedWorldEvent event) {
|
||||
if (!DisguiseAPI.isDisguised(event.getPlayer())) {
|
||||
return;
|
||||
}
|
||||
if (DisguiseConfig.isBedPacketsEnabled()) {
|
||||
chunkMove(event.getPlayer(), event.getPlayer().getLocation(), null);
|
||||
}
|
||||
if (DisguiseConfig.isUndisguiseOnWorldChange()) {
|
||||
for (Disguise disguise : DisguiseAPI.getDisguises(event.getPlayer())) {
|
||||
disguise.removeDisguise();
|
||||
}
|
||||
} else {
|
||||
//Stupid hack to fix worldswitch invisibility bug
|
||||
final boolean viewSelfToggled = DisguiseAPI.isViewSelfToggled(event.getPlayer());
|
||||
if (viewSelfToggled) {
|
||||
final Disguise disguise = DisguiseAPI.getDisguise(event.getPlayer());
|
||||
disguise.setViewSelfDisguise(false);
|
||||
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
disguise.setViewSelfDisguise(true);
|
||||
}
|
||||
}, 20L); //I wish I could use lambdas here, so badly
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void setDisguiseClone(final String player, Boolean[] options) {
|
||||
if (disguiseRunnable.containsKey(player)) {
|
||||
BukkitRunnable run = disguiseRunnable.remove(player);
|
||||
run.cancel();
|
||||
run.run();
|
||||
}
|
||||
BukkitRunnable runnable = new BukkitRunnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
disguiseClone.remove(player);
|
||||
disguiseRunnable.remove(player);
|
||||
}
|
||||
};
|
||||
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseCloneExpire());
|
||||
disguiseRunnable.put(player, runnable);
|
||||
disguiseClone.put(player, options);
|
||||
}
|
||||
|
||||
public void setDisguiseEntity(final String player, Disguise disguise) {
|
||||
if (disguiseRunnable.containsKey(player)) {
|
||||
BukkitRunnable run = disguiseRunnable.remove(player);
|
||||
run.cancel();
|
||||
run.run();
|
||||
}
|
||||
BukkitRunnable runnable = new BukkitRunnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
disguiseEntity.remove(player);
|
||||
disguiseRunnable.remove(player);
|
||||
}
|
||||
};
|
||||
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseEntityExpire());
|
||||
disguiseRunnable.put(player, runnable);
|
||||
disguiseEntity.put(player, disguise);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,303 +0,0 @@
|
||||
package me.libraryaddict.disguise;
|
||||
|
||||
import com.comphenix.protocol.reflect.FieldAccessException;
|
||||
import com.comphenix.protocol.wrappers.WrappedDataWatcher;
|
||||
import com.comphenix.protocol.wrappers.WrappedWatchableObject;
|
||||
import me.libraryaddict.disguise.commands.CloneDisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.DisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.DisguiseViewSelf;
|
||||
import me.libraryaddict.disguise.commands.EntityDisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.HelpDisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.LibsDisguisesCommand;
|
||||
import me.libraryaddict.disguise.commands.PlayerDisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.RadiusDisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.UndisguiseCommand;
|
||||
import me.libraryaddict.disguise.commands.UndisguiseEntityCommand;
|
||||
import me.libraryaddict.disguise.commands.UndisguisePlayerCommand;
|
||||
import me.libraryaddict.disguise.commands.UndisguiseRadiusCommand;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.AgeableWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.GuardianWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.HorseWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.MinecartWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.SkeletonWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.SlimeWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.TameableWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.ZombieWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseSound;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseValues;
|
||||
import me.libraryaddict.disguise.utilities.FakeBoundingBox;
|
||||
import me.libraryaddict.disguise.utilities.Metrics;
|
||||
import me.libraryaddict.disguise.utilities.PacketsManager;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Ageable;
|
||||
import org.bukkit.entity.Damageable;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Tameable;
|
||||
import org.bukkit.entity.Zombie;
|
||||
import org.bukkit.event.HandlerList;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Field;
|
||||
|
||||
|
||||
public class LibsDisguises extends JavaPlugin {
|
||||
|
||||
private static LibsDisguises instance;
|
||||
private DisguiseListener listener;
|
||||
|
||||
@Override
|
||||
public void onEnable() {
|
||||
getLogger().info("Discovered MC version: " + ReflectionManager.getBukkitVersion());
|
||||
saveDefaultConfig();
|
||||
|
||||
PacketsManager.init(this);
|
||||
DisguiseUtilities.init(this);
|
||||
DisguiseConfig.initConfig(getConfig());
|
||||
|
||||
PacketsManager.addPacketListeners();
|
||||
listener = new DisguiseListener(this);
|
||||
Bukkit.getPluginManager().registerEvents(listener, this);
|
||||
getCommand("disguise").setExecutor(new DisguiseCommand());
|
||||
getCommand("undisguise").setExecutor(new UndisguiseCommand());
|
||||
getCommand("disguiseplayer").setExecutor(new PlayerDisguiseCommand());
|
||||
getCommand("undisguiseplayer").setExecutor(new UndisguisePlayerCommand());
|
||||
getCommand("undisguiseentity").setExecutor(new UndisguiseEntityCommand());
|
||||
getCommand("disguiseentity").setExecutor(new EntityDisguiseCommand());
|
||||
getCommand("disguiseradius").setExecutor(new RadiusDisguiseCommand(getConfig().getInt("DisguiseRadiusMax")));
|
||||
getCommand("undisguiseradius").setExecutor(new UndisguiseRadiusCommand(getConfig().getInt("UndisguiseRadiusMax")));
|
||||
getCommand("disguisehelp").setExecutor(new HelpDisguiseCommand());
|
||||
getCommand("disguiseclone").setExecutor(new CloneDisguiseCommand());
|
||||
getCommand("libsdisguises").setExecutor(new LibsDisguisesCommand());
|
||||
getCommand("disguiseviewself").setExecutor(new DisguiseViewSelf());
|
||||
registerValues();
|
||||
instance = this;
|
||||
try {
|
||||
Metrics metrics = new Metrics(this);
|
||||
metrics.start();
|
||||
} catch (IOException e) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reloads the config with new config options.
|
||||
*/
|
||||
public void reload() {
|
||||
HandlerList.unregisterAll(listener);
|
||||
reloadConfig();
|
||||
DisguiseConfig.initConfig(getConfig());
|
||||
}
|
||||
|
||||
/**
|
||||
* Here we create a nms entity for each disguise. Then grab their default values in their datawatcher. Then their sound volume for mob noises. As well as setting their watcher class and entity size.
|
||||
*/
|
||||
private void registerValues() {
|
||||
for (DisguiseType disguiseType : DisguiseType.values()) {
|
||||
if (disguiseType.getEntityType() == null) {
|
||||
continue;
|
||||
}
|
||||
Class watcherClass = null;
|
||||
try {
|
||||
switch (disguiseType) {
|
||||
case ITEM_FRAME: //Not really supported...
|
||||
break;
|
||||
case MINECART_CHEST:
|
||||
case MINECART_COMMAND:
|
||||
case MINECART_FURNACE:
|
||||
case MINECART_HOPPER:
|
||||
case MINECART_MOB_SPAWNER:
|
||||
case MINECART_TNT:
|
||||
watcherClass = MinecartWatcher.class;
|
||||
break;
|
||||
case DONKEY:
|
||||
case MULE:
|
||||
case UNDEAD_HORSE:
|
||||
case SKELETON_HORSE:
|
||||
watcherClass = HorseWatcher.class;
|
||||
break;
|
||||
case ZOMBIE_VILLAGER:
|
||||
case PIG_ZOMBIE:
|
||||
watcherClass = ZombieWatcher.class;
|
||||
break;
|
||||
case MAGMA_CUBE:
|
||||
watcherClass = SlimeWatcher.class;
|
||||
break;
|
||||
case ELDER_GUARDIAN:
|
||||
watcherClass = GuardianWatcher.class;
|
||||
break;
|
||||
case ENDERMITE:
|
||||
watcherClass = LivingWatcher.class;
|
||||
break;
|
||||
case WITHER_SKELETON:
|
||||
watcherClass = SkeletonWatcher.class;
|
||||
break;
|
||||
default:
|
||||
watcherClass = Class.forName("me.libraryaddict.disguise.disguisetypes.watchers."
|
||||
+ toReadable(disguiseType.name()) + "Watcher");
|
||||
break;
|
||||
}
|
||||
} catch (ClassNotFoundException ex) {
|
||||
// There is no explicit watcher for this entity.
|
||||
Class entityClass = disguiseType.getEntityType().getEntityClass();
|
||||
if (entityClass != null) {
|
||||
if (Tameable.class.isAssignableFrom(entityClass)) {
|
||||
watcherClass = TameableWatcher.class;
|
||||
} else if (Ageable.class.isAssignableFrom(entityClass)) {
|
||||
watcherClass = AgeableWatcher.class;
|
||||
} else if (LivingEntity.class.isAssignableFrom(entityClass)) {
|
||||
watcherClass = LivingWatcher.class;
|
||||
} else {
|
||||
watcherClass = FlagWatcher.class;
|
||||
}
|
||||
} else {
|
||||
watcherClass = FlagWatcher.class; //Disguise is unknown type
|
||||
}
|
||||
}
|
||||
disguiseType.setWatcherClass(watcherClass);
|
||||
if (DisguiseValues.getDisguiseValues(disguiseType) != null) {
|
||||
continue;
|
||||
}
|
||||
String nmsEntityName = toReadable(disguiseType.name());
|
||||
switch (disguiseType) {
|
||||
case WITHER_SKELETON:
|
||||
case ZOMBIE_VILLAGER:
|
||||
case DONKEY:
|
||||
case MULE:
|
||||
case UNDEAD_HORSE:
|
||||
case SKELETON_HORSE:
|
||||
continue;
|
||||
case PRIMED_TNT:
|
||||
nmsEntityName = "TNTPrimed";
|
||||
break;
|
||||
case MINECART_TNT:
|
||||
nmsEntityName = "MinecartTNT";
|
||||
break;
|
||||
case MINECART:
|
||||
nmsEntityName = "MinecartRideable";
|
||||
break;
|
||||
case FIREWORK:
|
||||
nmsEntityName = "Fireworks";
|
||||
break;
|
||||
case SPLASH_POTION:
|
||||
nmsEntityName = "Potion";
|
||||
break;
|
||||
case GIANT:
|
||||
nmsEntityName = "GiantZombie";
|
||||
break;
|
||||
case DROPPED_ITEM:
|
||||
nmsEntityName = "Item";
|
||||
break;
|
||||
case FIREBALL:
|
||||
nmsEntityName = "LargeFireball";
|
||||
break;
|
||||
case LEASH_HITCH:
|
||||
nmsEntityName = "Leash";
|
||||
break;
|
||||
case ELDER_GUARDIAN:
|
||||
nmsEntityName = "Guardian";
|
||||
break;
|
||||
case ARROW:
|
||||
nmsEntityName = "TippedArrow";
|
||||
default:
|
||||
break;
|
||||
}
|
||||
try {
|
||||
if (nmsEntityName.equalsIgnoreCase("Unknown")) {
|
||||
DisguiseValues disguiseValues = new DisguiseValues(disguiseType, null, 0, 0);
|
||||
disguiseValues.setAdultBox(new FakeBoundingBox(0, 0, 0));
|
||||
DisguiseSound sound = DisguiseSound.getType(disguiseType.name());
|
||||
if (sound != null) {
|
||||
sound.setDamageAndIdleSoundVolume(1f);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
Object nmsEntity = ReflectionManager.createEntityInstance(nmsEntityName);
|
||||
if (nmsEntity == null) {
|
||||
getLogger().warning("Entity not found! (" + nmsEntityName + ")");
|
||||
continue;
|
||||
}
|
||||
Entity bukkitEntity = ReflectionManager.getBukkitEntity(nmsEntity);
|
||||
int entitySize = 0;
|
||||
for (Field field : ReflectionManager.getNmsClass("Entity").getFields()) {
|
||||
if (field.getType().getName().equals("EnumEntitySize")) {
|
||||
Enum enumEntitySize = (Enum) field.get(nmsEntity);
|
||||
entitySize = enumEntitySize.ordinal();
|
||||
break;
|
||||
}
|
||||
}
|
||||
DisguiseValues disguiseValues = new DisguiseValues(disguiseType, nmsEntity.getClass(), entitySize,
|
||||
bukkitEntity instanceof Damageable ? ((Damageable) bukkitEntity).getMaxHealth() : 0);
|
||||
WrappedDataWatcher watcher = WrappedDataWatcher.getEntityWatcher(bukkitEntity);
|
||||
for (WrappedWatchableObject watch : watcher.getWatchableObjects()) {
|
||||
disguiseValues.setMetaValue(watch.getIndex(), watch.getValue());
|
||||
// Uncomment when I need to find the new datawatcher values for a class..
|
||||
// int id = watch.getIndex();
|
||||
// Object val = watch.getValue();
|
||||
// Class<?> valClazz = val != null ? watch.getValue().getClass() : null;
|
||||
// try {
|
||||
// val = val.toString();
|
||||
// } catch (Exception e) {
|
||||
// val = val != null ? val.getClass() : "null";
|
||||
// }
|
||||
// System.out.println("Disguise: " + disguiseType + ", ID: " + id + ", Class: " + (val == null ? "null" : valClazz) + ", Value: " + val);
|
||||
}
|
||||
DisguiseSound sound = DisguiseSound.getType(disguiseType.name());
|
||||
if (sound != null) {
|
||||
Float soundStrength = ReflectionManager.getSoundModifier(nmsEntity);
|
||||
if (soundStrength != null) {
|
||||
sound.setDamageAndIdleSoundVolume(soundStrength);
|
||||
}
|
||||
}
|
||||
|
||||
// Get the bounding box
|
||||
disguiseValues.setAdultBox(ReflectionManager.getBoundingBox(bukkitEntity));
|
||||
if (bukkitEntity instanceof Ageable) {
|
||||
((Ageable) bukkitEntity).setBaby();
|
||||
disguiseValues.setBabyBox(ReflectionManager.getBoundingBox(bukkitEntity));
|
||||
} else if (bukkitEntity instanceof Zombie) {
|
||||
((Zombie) bukkitEntity).setBaby(true);
|
||||
disguiseValues.setBabyBox(ReflectionManager.getBoundingBox(bukkitEntity));
|
||||
}
|
||||
disguiseValues.setEntitySize(ReflectionManager.getSize(bukkitEntity));
|
||||
} catch (SecurityException | IllegalArgumentException | IllegalAccessException | FieldAccessException ex) {
|
||||
System.out.print("[LibsDisguises] Uh oh! Trouble while making values for the disguise " + disguiseType.name()
|
||||
+ "!");
|
||||
System.out.print("[LibsDisguises] Before reporting this error, "
|
||||
+ "please make sure you are using the latest version of LibsDisguises and ProtocolLib.");
|
||||
System.out
|
||||
.print("[LibsDisguises] Development builds are available at (ProtocolLib) "
|
||||
+ "http://ci.dmulloy2.net/job/ProtocolLib/ and (LibsDisguises) http://server.o2gaming.com:8080/job/LibsDisguises%201.9+/");
|
||||
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private String toReadable(String string) {
|
||||
StringBuilder builder = new StringBuilder();
|
||||
for (String s : string.split("_")) {
|
||||
builder.append(s.substring(0, 1)).append(s.substring(1).toLowerCase());
|
||||
}
|
||||
return builder.toString();
|
||||
}
|
||||
|
||||
public DisguiseListener getListener() {
|
||||
return listener;
|
||||
}
|
||||
|
||||
/**
|
||||
* External APIs shouldn't actually need this instance.
|
||||
* DisguiseAPI should be enough to handle most cases.
|
||||
*
|
||||
* @return The instance of this plugin
|
||||
*/
|
||||
public static LibsDisguises getInstance() {
|
||||
return instance;
|
||||
}
|
||||
}
|
||||
@@ -1,766 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.AnimalColor;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.MiscDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.MobDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.PlayerDisguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.RabbitType;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Ageable;
|
||||
import org.bukkit.entity.Animals;
|
||||
import org.bukkit.entity.Monster;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.permissions.PermissionAttachmentInfo;
|
||||
import org.bukkit.potion.PotionEffectType;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
|
||||
/**
|
||||
* @author libraryaddict
|
||||
*/
|
||||
public abstract class BaseDisguiseCommand implements CommandExecutor {
|
||||
|
||||
public class DisguiseParseException extends Exception {
|
||||
|
||||
private static final long serialVersionUID = 1276971370793124510L;
|
||||
|
||||
public DisguiseParseException() {
|
||||
super();
|
||||
}
|
||||
|
||||
public DisguiseParseException(String string) {
|
||||
super(string);
|
||||
}
|
||||
}
|
||||
|
||||
protected ArrayList<String> getAllowedDisguises(HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> hashMap) {
|
||||
ArrayList<String> allowedDisguises = new ArrayList<>();
|
||||
for (DisguiseType type : hashMap.keySet()) {
|
||||
allowedDisguises.add(type.toReadable().replace(" ", "_"));
|
||||
}
|
||||
Collections.sort(allowedDisguises, String.CASE_INSENSITIVE_ORDER);
|
||||
return allowedDisguises;
|
||||
}
|
||||
|
||||
protected HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> getPermissions(CommandSender sender) {
|
||||
return getPermissions(sender, "libsdisguises." + getClass().getSimpleName().replace("Command", "").toLowerCase() + ".");
|
||||
}
|
||||
|
||||
protected HashMap<String, Boolean> getDisguisePermission(CommandSender sender, DisguiseType type) {
|
||||
switch (type) {
|
||||
case PLAYER:
|
||||
case FALLING_BLOCK:
|
||||
case PAINTING:
|
||||
case SPLASH_POTION:
|
||||
case FISHING_HOOK:
|
||||
case DROPPED_ITEM:
|
||||
HashMap<String, Boolean> returns = new HashMap<>();
|
||||
String beginning = "libsdisguises.options." + getClass().getSimpleName().toLowerCase().replace("command", "") + ".";
|
||||
for (PermissionAttachmentInfo permission : sender.getEffectivePermissions()) {
|
||||
String lowerPerm = permission.getPermission().toLowerCase();
|
||||
if (lowerPerm.startsWith(beginning)) {
|
||||
String[] split = lowerPerm.substring(beginning.length()).split("\\.");
|
||||
if (split.length > 1) {
|
||||
if (split[0].replace("_", "").equals(type.name().toLowerCase().replace("_", ""))) {
|
||||
for (int i = 1; i < split.length; i++) {
|
||||
returns.put(split[i], permission.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return returns;
|
||||
default:
|
||||
return new HashMap<>();
|
||||
}
|
||||
}
|
||||
|
||||
protected Method[] getDisguiseWatcherMethods(Class<? extends FlagWatcher> watcherClass) {
|
||||
Method[] methods = watcherClass.getMethods();
|
||||
methods = Arrays.copyOf(methods, methods.length + 4);
|
||||
int i = 4;
|
||||
for (String methodName : new String[]{"setViewSelfDisguise", "setHideHeldItemFromSelf", "setHideArmorFromSelf",
|
||||
"setHearSelfDisguise"}) {
|
||||
try {
|
||||
methods[methods.length - i--] = Disguise.class.getMethod(methodName, boolean.class);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
return methods;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get perms for the node. Returns a hashmap of allowed disguisetypes and their options
|
||||
*
|
||||
* @param sender
|
||||
* @param permissionNode
|
||||
* @return
|
||||
*/
|
||||
protected HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> getPermissions(CommandSender sender, String permissionNode) {
|
||||
HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> singleDisguises = new HashMap<>();
|
||||
HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> rangeDisguises = new HashMap<>();
|
||||
HashMap<String, Boolean> perms = new HashMap<>();
|
||||
|
||||
for (PermissionAttachmentInfo permission : sender.getEffectivePermissions()) {
|
||||
String perm = permission.getPermission().toLowerCase();
|
||||
if (perm.startsWith(permissionNode) && (!perms.containsKey(perm) || !permission.getValue())) {
|
||||
perms.put(perm, permission.getValue());
|
||||
}
|
||||
}
|
||||
if (!perms.containsKey(permissionNode + "*") && sender.hasPermission(permissionNode + "*")) {
|
||||
perms.put(permissionNode + "*", true);
|
||||
}
|
||||
if (!perms.containsKey(permissionNode + "*.*") && sender.hasPermission(permissionNode + "*.*")) {
|
||||
perms.put(permissionNode + "*.*", true);
|
||||
}
|
||||
|
||||
for (String perm : perms.keySet()) {
|
||||
if (perms.get(perm)) {
|
||||
perm = perm.substring(permissionNode.length());
|
||||
String disguiseType = perm.split("\\.")[0];
|
||||
DisguiseType dType = null;
|
||||
for (DisguiseType t : DisguiseType.values()) {
|
||||
if (t.name().replace("_", "").equalsIgnoreCase(disguiseType.replace("_", ""))) {
|
||||
dType = t;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (dType != null) {
|
||||
HashMap<ArrayList<String>, Boolean> list;
|
||||
if (singleDisguises.containsKey(dType)) {
|
||||
list = singleDisguises.get(dType);
|
||||
} else {
|
||||
list = new HashMap<>();
|
||||
singleDisguises.put(dType, list);
|
||||
}
|
||||
HashMap<ArrayList<String>, Boolean> map1 = getOptions(perm);
|
||||
list.put(map1.keySet().iterator().next(), map1.values().iterator().next());
|
||||
} else {
|
||||
for (DisguiseType type : DisguiseType.values()) {
|
||||
HashMap<ArrayList<String>, Boolean> options = null;
|
||||
Class entityClass = type.getEntityClass();
|
||||
if (disguiseType.equals("mob")) {
|
||||
if (type.isMob()) {
|
||||
options = getOptions(perm);
|
||||
}
|
||||
} else if (disguiseType.equals("animal") || disguiseType.equals("animals")) {
|
||||
if (Animals.class.isAssignableFrom(entityClass)) {
|
||||
options = getOptions(perm);
|
||||
}
|
||||
} else if (disguiseType.equals("monster") || disguiseType.equals("monsters")) {
|
||||
if (Monster.class.isAssignableFrom(entityClass)) {
|
||||
options = getOptions(perm);
|
||||
}
|
||||
} else if (disguiseType.equals("misc")) {
|
||||
if (type.isMisc()) {
|
||||
options = getOptions(perm);
|
||||
}
|
||||
} else if (disguiseType.equals("ageable")) {
|
||||
if (Ageable.class.isAssignableFrom(entityClass)) {
|
||||
options = getOptions(perm);
|
||||
}
|
||||
} else if (disguiseType.equals("*")) {
|
||||
options = getOptions(perm);
|
||||
}
|
||||
if (options != null) {
|
||||
HashMap<ArrayList<String>, Boolean> list;
|
||||
if (rangeDisguises.containsKey(type)) {
|
||||
list = rangeDisguises.get(type);
|
||||
} else {
|
||||
list = new HashMap<>();
|
||||
rangeDisguises.put(type, list);
|
||||
}
|
||||
HashMap<ArrayList<String>, Boolean> map1 = getOptions(perm);
|
||||
list.put(map1.keySet().iterator().next(), map1.values().iterator().next());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (String perm : perms.keySet()) {
|
||||
if (!perms.get(perm)) {
|
||||
perm = perm.substring(permissionNode.length());
|
||||
String disguiseType = perm.split("\\.")[0];
|
||||
DisguiseType dType = null;
|
||||
for (DisguiseType t : DisguiseType.values()) {
|
||||
if (t.name().replace("_", "").equalsIgnoreCase(disguiseType.replace("_", ""))) {
|
||||
dType = t;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (dType != null) {
|
||||
singleDisguises.remove(dType);
|
||||
rangeDisguises.remove(dType);
|
||||
} else {
|
||||
for (DisguiseType type : DisguiseType.values()) {
|
||||
boolean foundHim = false;
|
||||
Class entityClass = type.getEntityClass();
|
||||
switch (disguiseType) {
|
||||
case "mob":
|
||||
if (type.isMob()) {
|
||||
foundHim = true;
|
||||
}
|
||||
break;
|
||||
case "animal":
|
||||
case "animals":
|
||||
if (Animals.class.isAssignableFrom(entityClass)) {
|
||||
foundHim = true;
|
||||
}
|
||||
break;
|
||||
case "monster":
|
||||
case "monsters":
|
||||
if (Monster.class.isAssignableFrom(entityClass)) {
|
||||
foundHim = true;
|
||||
}
|
||||
break;
|
||||
case "misc":
|
||||
if (type.isMisc()) {
|
||||
foundHim = true;
|
||||
}
|
||||
break;
|
||||
case "ageable":
|
||||
if (Ageable.class.isAssignableFrom(entityClass)) {
|
||||
foundHim = true;
|
||||
}
|
||||
break;
|
||||
case "*":
|
||||
foundHim = true;
|
||||
break;
|
||||
}
|
||||
if (foundHim) {
|
||||
rangeDisguises.remove(type);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map = new HashMap<>();
|
||||
for (DisguiseType type : DisguiseType.values()) {
|
||||
HashMap<ArrayList<String>, Boolean> temp = new HashMap<>();
|
||||
if (singleDisguises.containsKey(type)) {
|
||||
temp.putAll(singleDisguises.get(type));
|
||||
}
|
||||
if (rangeDisguises.containsKey(type)) {
|
||||
temp.putAll(rangeDisguises.get(type));
|
||||
}
|
||||
if (!temp.isEmpty()) {
|
||||
map.put(type, temp);
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
private HashMap<ArrayList<String>, Boolean> getOptions(String perm) {
|
||||
ArrayList<String> list = new ArrayList<>();
|
||||
boolean isRemove = true;
|
||||
String[] split = perm.split("\\.");
|
||||
for (int i = 1; i < split.length; i++) {
|
||||
String option = split[i];
|
||||
boolean value = option.startsWith("-");
|
||||
if (value) {
|
||||
option = option.substring(1);
|
||||
isRemove = false;
|
||||
}
|
||||
if (option.equals("baby")) {
|
||||
option = "setbaby";
|
||||
}
|
||||
list.add(option);
|
||||
}
|
||||
HashMap<ArrayList<String>, Boolean> options = new HashMap<>();
|
||||
options.put(list, isRemove);
|
||||
return options;
|
||||
}
|
||||
|
||||
protected boolean isDouble(String string) {
|
||||
try {
|
||||
Float.parseFloat(string);
|
||||
return true;
|
||||
} catch (Exception ex) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
protected boolean isNumeric(String string) {
|
||||
try {
|
||||
Integer.parseInt(string);
|
||||
return true;
|
||||
} catch (Exception ex) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the disguise if it all parsed correctly. Returns a exception with a complete message if it didn't. The commandsender is purely used for checking permissions. Would defeat the purpose otherwise. To reach this point, the disguise has been feed a proper disguisetype.
|
||||
*
|
||||
* @param sender
|
||||
* @param args
|
||||
* @param map
|
||||
* @return
|
||||
* @throws BaseDisguiseCommand.DisguiseParseException
|
||||
* @throws java.lang.IllegalAccessException
|
||||
* @throws java.lang.reflect.InvocationTargetException
|
||||
*/
|
||||
protected Disguise parseDisguise(CommandSender sender, String[] args, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) throws DisguiseParseException,
|
||||
IllegalAccessException, InvocationTargetException {
|
||||
if (map.isEmpty()) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
if (args.length == 0) {
|
||||
sendCommandUsage(sender, map);
|
||||
throw new DisguiseParseException();
|
||||
}
|
||||
// How many args to skip due to the disugise being constructed
|
||||
// Time to start constructing the disguise.
|
||||
// We will need to check between all 3 kinds of disguises
|
||||
int toSkip = 1;
|
||||
ArrayList<String> usedOptions = new ArrayList<>();
|
||||
Disguise disguise = null;
|
||||
HashMap<ArrayList<String>, Boolean> optionPermissions;
|
||||
if (args[0].startsWith("@")) {
|
||||
if (sender.hasPermission("libsdisguises.disguise.disguiseclone")) {
|
||||
disguise = DisguiseUtilities.getClonedDisguise(args[0].toLowerCase());
|
||||
if (disguise == null) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "Cannot find a disguise under the reference " + args[0]);
|
||||
}
|
||||
} else {
|
||||
throw new DisguiseParseException(ChatColor.RED + "You do not have perimssion to use disguise references!");
|
||||
}
|
||||
optionPermissions = (map.containsKey(disguise.getType()) ? map.get(disguise.getType())
|
||||
: new HashMap<ArrayList<String>, Boolean>());
|
||||
} else {
|
||||
DisguiseType disguiseType = null;
|
||||
if (args[0].equalsIgnoreCase("p")) {
|
||||
disguiseType = DisguiseType.PLAYER;
|
||||
} else {
|
||||
for (DisguiseType type : DisguiseType.values()) {
|
||||
if (args[0].equalsIgnoreCase(type.name()) || args[0].equalsIgnoreCase(type.name().replace("_", ""))) {
|
||||
disguiseType = type;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (disguiseType == null) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! The disguise " + ChatColor.GREEN + args[0]
|
||||
+ ChatColor.RED + " doesn't exist!");
|
||||
}
|
||||
if (disguiseType.isUnknown()) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! You cannot disguise as " + ChatColor.GREEN + "Unknown!");
|
||||
}
|
||||
if (disguiseType.getEntityType() == null) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! This version of minecraft does not have that disguise!");
|
||||
}
|
||||
if (!map.containsKey(disguiseType)) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "You are forbidden to use this disguise.");
|
||||
}
|
||||
optionPermissions = map.get(disguiseType);
|
||||
HashMap<String, Boolean> disguiseOptions = this.getDisguisePermission(sender, disguiseType);
|
||||
if (disguiseType.isPlayer()) {
|
||||
// If he is doing a player disguise
|
||||
if (args.length == 1) {
|
||||
// He needs to give the player name
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! You need to give a player name!");
|
||||
} else {
|
||||
if (!disguiseOptions.isEmpty()
|
||||
&& (!disguiseOptions.containsKey(args[1].toLowerCase()) || !disguiseOptions
|
||||
.get(args[1].toLowerCase()))) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! You don't have permission to use that name!");
|
||||
}
|
||||
args[1] = args[1].replace("\\_", " ");
|
||||
// Construct the player disguise
|
||||
disguise = new PlayerDisguise(ChatColor.translateAlternateColorCodes('&', args[1]));
|
||||
toSkip++;
|
||||
}
|
||||
} else {
|
||||
if (disguiseType.isMob()) { // Its a mob, use the mob constructor
|
||||
boolean adult = true;
|
||||
if (args.length > 1) {
|
||||
if (args[1].equalsIgnoreCase("baby") || args[1].equalsIgnoreCase("adult")) {
|
||||
usedOptions.add("setbaby");
|
||||
doCheck(optionPermissions, usedOptions);
|
||||
adult = args[1].equalsIgnoreCase("adult");
|
||||
toSkip++;
|
||||
}
|
||||
}
|
||||
disguise = new MobDisguise(disguiseType, adult);
|
||||
} else if (disguiseType.isMisc()) {
|
||||
// Its a misc, we are going to use the MiscDisguise constructor.
|
||||
int miscId = -1;
|
||||
int miscData = -1;
|
||||
String secondArg = null;
|
||||
if (args.length > 1) {
|
||||
// They have defined more arguments!
|
||||
// If the first arg is a number
|
||||
if (args[1].contains(":")) {
|
||||
String[] split = args[1].split(":");
|
||||
if (isNumeric(split[1])) {
|
||||
secondArg = split[1];
|
||||
}
|
||||
args[1] = split[0];
|
||||
}
|
||||
if (isNumeric(args[1])) {
|
||||
miscId = Integer.parseInt(args[1]);
|
||||
} else {
|
||||
if (disguiseType == DisguiseType.FALLING_BLOCK || disguiseType == DisguiseType.DROPPED_ITEM) {
|
||||
for (Material mat : Material.values()) {
|
||||
if (mat.name().replace("_", "").equalsIgnoreCase(args[1].replace("_", ""))) {
|
||||
miscId = mat.getId();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (miscId != -1) {
|
||||
switch (disguiseType) {
|
||||
case PAINTING:
|
||||
case FALLING_BLOCK:
|
||||
case SPLASH_POTION:
|
||||
case DROPPED_ITEM:
|
||||
case FISHING_HOOK:
|
||||
case ARROW:
|
||||
case TIPPED_ARROW:
|
||||
case SPECTRAL_ARROW:
|
||||
case SMALL_FIREBALL:
|
||||
case FIREBALL:
|
||||
case WITHER_SKULL:
|
||||
break;
|
||||
default:
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! " + disguiseType.toReadable()
|
||||
+ " doesn't know what to do with " + args[1] + "!");
|
||||
}
|
||||
toSkip++;
|
||||
// If they also defined a data value
|
||||
if (args.length > 2 && secondArg == null && isNumeric(args[2])) {
|
||||
secondArg = args[2];
|
||||
toSkip++;
|
||||
}
|
||||
if (secondArg != null) {
|
||||
if (disguiseType != DisguiseType.FALLING_BLOCK && disguiseType != DisguiseType.DROPPED_ITEM) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "Error! Only the disguises "
|
||||
+ DisguiseType.FALLING_BLOCK.toReadable() + " and "
|
||||
+ DisguiseType.DROPPED_ITEM.toReadable() + " uses a second number!");
|
||||
}
|
||||
miscData = Integer.parseInt(secondArg);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!disguiseOptions.isEmpty() && miscId != -1) {
|
||||
String toCheck = "" + miscId;
|
||||
if (miscData == 0 || miscData == -1) {
|
||||
if (!disguiseOptions.containsKey(toCheck) || !disguiseOptions.get(toCheck)) {
|
||||
toCheck += ":0";
|
||||
}
|
||||
} else {
|
||||
toCheck += ":" + miscData;
|
||||
}
|
||||
if (!disguiseOptions.containsKey(toCheck) || !disguiseOptions.get(toCheck)) {
|
||||
throw new DisguiseParseException(ChatColor.RED
|
||||
+ "Error! You do not have permission to use the parameter " + toCheck + " on the "
|
||||
+ disguiseType.toReadable() + " disguise!");
|
||||
}
|
||||
}
|
||||
if (miscId != -1) {
|
||||
if (disguiseType == DisguiseType.FALLING_BLOCK) {
|
||||
usedOptions.add("setblock");
|
||||
doCheck(optionPermissions, usedOptions);
|
||||
} else if (disguiseType == DisguiseType.PAINTING) {
|
||||
usedOptions.add("setpainting");
|
||||
doCheck(optionPermissions, usedOptions);
|
||||
} else if (disguiseType == DisguiseType.SPLASH_POTION) {
|
||||
usedOptions.add("setpotionid");
|
||||
doCheck(optionPermissions, usedOptions);
|
||||
}
|
||||
}
|
||||
// Construct the disguise
|
||||
disguise = new MiscDisguise(disguiseType, miscId, miscData);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Copy strings to their new range
|
||||
String[] newArgs = new String[args.length - toSkip];
|
||||
System.arraycopy(args, toSkip, newArgs, 0, args.length - toSkip);
|
||||
args = newArgs;
|
||||
Method[] methods = this.getDisguiseWatcherMethods(disguise.getWatcher().getClass());
|
||||
for (int i = 0; i < args.length; i += 2) {
|
||||
String methodName = args[i];
|
||||
String valueString = (args.length - 1 == i ? null : args[i + 1]);
|
||||
Method methodToUse = null;
|
||||
Object value = null;
|
||||
DisguiseParseException storedEx = null;
|
||||
int c = 0;
|
||||
while (c < methods.length) {
|
||||
try {
|
||||
Entry<Method, Integer> entry = getMethod(methods, methodName, c);
|
||||
if (entry == null) {
|
||||
break;
|
||||
}
|
||||
methodToUse = entry.getKey();
|
||||
c = entry.getValue();
|
||||
methodName = methodToUse.getName();
|
||||
Class<?>[] types = methodToUse.getParameterTypes();
|
||||
Class param = types[0];
|
||||
if (valueString != null) {
|
||||
if (int.class == param) {
|
||||
// Parse to integer
|
||||
if (isNumeric(valueString)) {
|
||||
value = Integer.parseInt(valueString);
|
||||
} else {
|
||||
throw parseToException("number", valueString, methodName);
|
||||
}
|
||||
} else if (float.class == param || double.class == param) {
|
||||
// Parse to number
|
||||
if (isDouble(valueString)) {
|
||||
float obj = Float.parseFloat(valueString);
|
||||
if (param == float.class) {
|
||||
value = obj;
|
||||
} else if (param == double.class) {
|
||||
value = (double) obj;
|
||||
}
|
||||
} else {
|
||||
throw parseToException("number.0", valueString, methodName);
|
||||
}
|
||||
} else if (param == String.class) {
|
||||
// Parse to string
|
||||
value = ChatColor.translateAlternateColorCodes('&', valueString);
|
||||
} else if (param == AnimalColor.class) {
|
||||
// Parse to animal color
|
||||
try {
|
||||
value = AnimalColor.valueOf(valueString.toUpperCase());
|
||||
} catch (Exception ex) {
|
||||
throw parseToException("animal color", valueString, methodName);
|
||||
}
|
||||
} else if (param == ItemStack.class) {
|
||||
// Parse to itemstack
|
||||
try {
|
||||
value = parseToItemstack(valueString);
|
||||
} catch (Exception ex) {
|
||||
throw new DisguiseParseException(String.format(ex.getMessage(), methodName));
|
||||
}
|
||||
} else if (param == ItemStack[].class) {
|
||||
// Parse to itemstack array
|
||||
ItemStack[] items = new ItemStack[4];
|
||||
String[] split = valueString.split(",");
|
||||
if (split.length == 4) {
|
||||
for (int a = 0; a < 4; a++) {
|
||||
try {
|
||||
items[a] = parseToItemstack(split[a]);
|
||||
} catch (Exception ex) {
|
||||
throw parseToException("item ID,ID,ID,ID" + ChatColor.RED + " or " + ChatColor.GREEN
|
||||
+ "ID:Data,ID:Data,ID:Data,ID:Data combo", valueString, methodName);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
throw parseToException("item ID,ID,ID,ID" + ChatColor.RED + " or " + ChatColor.GREEN
|
||||
+ "ID:Data,ID:Data,ID:Data,ID:Data combo", valueString, methodName);
|
||||
}
|
||||
value = items;
|
||||
} else if (param.getSimpleName().equals("Color")) {
|
||||
// Parse to horse color
|
||||
value = callValueOf(param, valueString, methodName, "a horse color");
|
||||
} else if (param.getSimpleName().equals("Style")) {
|
||||
// Parse to horse style
|
||||
value = callValueOf(param, valueString, methodName, "a horse style");
|
||||
} else if (param.getSimpleName().equals("Profession")) {
|
||||
// Parse to villager profession
|
||||
value = callValueOf(param, valueString, methodName, "a villager profession");
|
||||
} else if (param.getSimpleName().equals("Art")) {
|
||||
// Parse to art type
|
||||
value = callValueOf(param, valueString, methodName, "a painting art");
|
||||
} else if (param.getSimpleName().equals("Type")) {
|
||||
// Parse to ocelot type
|
||||
value = callValueOf(param, valueString, methodName, "a ocelot type");
|
||||
} else if (param == PotionEffectType.class) {
|
||||
// Parse to potion effect
|
||||
try {
|
||||
PotionEffectType potionType = PotionEffectType.getByName(valueString.toUpperCase());
|
||||
if (potionType == null && isNumeric(valueString)) {
|
||||
potionType = PotionEffectType.getById(Integer.parseInt(valueString));
|
||||
}
|
||||
if (potionType == null) {
|
||||
throw new DisguiseParseException();
|
||||
}
|
||||
value = potionType;
|
||||
} catch (Exception ex) {
|
||||
throw parseToException("a potioneffect type", valueString, methodName);
|
||||
}
|
||||
} else if (param == int[].class) {
|
||||
String[] split = valueString.split(",");
|
||||
int[] values = new int[split.length];
|
||||
for (int b = 0; b < values.length; b++) {
|
||||
try {
|
||||
values[b] = Integer.parseInt(split[b]);
|
||||
} catch (NumberFormatException ex) {
|
||||
throw parseToException("Number,Number,Number...", valueString, methodName);
|
||||
}
|
||||
}
|
||||
value = values;
|
||||
} else if (param == BlockFace.class) {
|
||||
try {
|
||||
BlockFace face = BlockFace.valueOf(valueString.toUpperCase());
|
||||
if (face.ordinal() > 4) {
|
||||
throw new DisguiseParseException();
|
||||
}
|
||||
value = face;
|
||||
} catch (Exception ex) {
|
||||
throw parseToException("a direction (north, east, south, west, up)", valueString, methodName);
|
||||
}
|
||||
} else if (param == RabbitType.class) {
|
||||
try {
|
||||
for (RabbitType type : RabbitType.values()) {
|
||||
if (type.name().replace("_", "")
|
||||
.equalsIgnoreCase(valueString.replace("_", "").replace(" ", ""))) {
|
||||
value = type;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (value == null) {
|
||||
throw new Exception();
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
throw parseToException("rabbit type (white, brown, patches...)", valueString, methodName);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (value == null && boolean.class == param) {
|
||||
if (valueString == null) {
|
||||
value = true;
|
||||
i--;
|
||||
} else if (valueString.equalsIgnoreCase("true")) {
|
||||
value = true;
|
||||
} else if (valueString.equalsIgnoreCase("false")) {
|
||||
value = false;
|
||||
} else {
|
||||
if (getMethod(methods, valueString, 0) == null) {
|
||||
throw parseToException("true/false", valueString, methodName);
|
||||
} else {
|
||||
value = true;
|
||||
i--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (value != null) {
|
||||
break;
|
||||
}
|
||||
} catch (DisguiseParseException ex) {
|
||||
storedEx = ex;
|
||||
methodToUse = null;
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
methodToUse = null;
|
||||
}
|
||||
}
|
||||
if (methodToUse == null) {
|
||||
if (storedEx != null) {
|
||||
throw storedEx;
|
||||
}
|
||||
throw new DisguiseParseException(ChatColor.RED + "Cannot find the option " + methodName);
|
||||
}
|
||||
if (value == null) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "No value was given for the option " + methodName);
|
||||
}
|
||||
if (!usedOptions.contains(methodName.toLowerCase())) {
|
||||
usedOptions.add(methodName.toLowerCase());
|
||||
}
|
||||
doCheck(optionPermissions, usedOptions);
|
||||
if (FlagWatcher.class.isAssignableFrom(methodToUse.getDeclaringClass())) {
|
||||
methodToUse.invoke(disguise.getWatcher(), value);
|
||||
} else {
|
||||
methodToUse.invoke(disguise, value);
|
||||
}
|
||||
}
|
||||
// Alright. We've constructed our disguise.
|
||||
return disguise;
|
||||
}
|
||||
|
||||
private Entry<Method, Integer> getMethod(Method[] methods, String methodName, int toStart) {
|
||||
for (int i = toStart; i < methods.length; i++) {
|
||||
Method method = methods[i];
|
||||
if (!method.getName().startsWith("get") && method.getName().equalsIgnoreCase(methodName)
|
||||
&& method.getAnnotation(Deprecated.class) == null && method.getParameterTypes().length == 1) {
|
||||
return new HashMap.SimpleEntry(method, ++i);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private Object callValueOf(Class<?> param, String valueString, String methodName, String description)
|
||||
throws DisguiseParseException {
|
||||
Object value;
|
||||
try {
|
||||
value = param.getMethod("valueOf", String.class).invoke(null, valueString.toUpperCase());
|
||||
} catch (Exception ex) {
|
||||
throw parseToException(description, valueString, methodName);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
private boolean passesCheck(HashMap<ArrayList<String>, Boolean> map1, ArrayList<String> usedOptions) {
|
||||
boolean hasPermission = false;
|
||||
for (ArrayList<String> list : map1.keySet()) {
|
||||
boolean myPerms = true;
|
||||
for (String option : usedOptions) {
|
||||
if (!(map1.get(list) && list.contains("*")) && (list.contains(option) != map1.get(list))) {
|
||||
myPerms = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (myPerms) {
|
||||
hasPermission = true;
|
||||
}
|
||||
}
|
||||
return hasPermission;
|
||||
}
|
||||
|
||||
private void doCheck(HashMap<ArrayList<String>, Boolean> optionPermissions, ArrayList<String> usedOptions)
|
||||
throws DisguiseParseException {
|
||||
if (!passesCheck(optionPermissions, usedOptions)) {
|
||||
throw new DisguiseParseException(ChatColor.RED + "You do not have the permission to use the option "
|
||||
+ usedOptions.get(usedOptions.size() - 1));
|
||||
}
|
||||
}
|
||||
|
||||
private DisguiseParseException parseToException(String expectedValue, String receivedInstead, String methodName) {
|
||||
return new DisguiseParseException(ChatColor.RED + "Expected " + ChatColor.GREEN + expectedValue + ChatColor.RED
|
||||
+ ", received " + ChatColor.GREEN + receivedInstead + ChatColor.RED + " instead for " + ChatColor.GREEN
|
||||
+ methodName);
|
||||
}
|
||||
|
||||
private ItemStack parseToItemstack(String string) throws Exception {
|
||||
String[] split = string.split(":", -1);
|
||||
if (isNumeric(split[0])) {
|
||||
int itemId = Integer.parseInt(split[0]);
|
||||
short itemDura = 0;
|
||||
if (split.length > 1) {
|
||||
if (isNumeric(split[1])) {
|
||||
itemDura = Short.parseShort(split[1]);
|
||||
} else {
|
||||
throw parseToException("item ID:Durability combo", string, "%s");
|
||||
}
|
||||
}
|
||||
return new ItemStack(itemId, 1, itemDura);
|
||||
} else {
|
||||
if (split.length == 1) {
|
||||
throw parseToException("item ID", string, "%s");
|
||||
} else {
|
||||
throw parseToException("item ID:Durability combo", string, "%s");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected abstract void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map);
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.LibsDisguises;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class CloneDisguiseCommand extends BaseDisguiseCommand {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
if (sender.hasPermission("libsdisguises.disguise.disguiseclone")) {
|
||||
boolean doEquipment = true;
|
||||
boolean doSneak = false;
|
||||
boolean doSprint = false;
|
||||
for (String option : args) {
|
||||
if (StringUtils.startsWithIgnoreCase(option, "ignoreEquip")
|
||||
|| StringUtils.startsWithIgnoreCase(option, "ignoreEnquip")) {
|
||||
doEquipment = false;
|
||||
} else if (option.equalsIgnoreCase("doSneakSprint")) {
|
||||
doSneak = true;
|
||||
doSprint = true;
|
||||
} else if (option.equalsIgnoreCase("doSneak")) {
|
||||
doSneak = true;
|
||||
} else if (option.equalsIgnoreCase("doSprint")) {
|
||||
doSprint = true;
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.DARK_RED + "Unknown option '" + option
|
||||
+ "' - Valid options are 'IgnoreEquipment' 'DoSneakSprint' 'DoSneak' 'DoSprint'");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
LibsDisguises.getInstance().getListener().setDisguiseClone(sender.getName(), new Boolean[]{doEquipment, doSneak, doSprint});
|
||||
sender.sendMessage(ChatColor.RED + "Right click a entity in the next " + DisguiseConfig.getDisguiseCloneExpire()
|
||||
+ " seconds to grab the disguise reference!");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player the information
|
||||
*/
|
||||
@Override
|
||||
protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN
|
||||
+ "Right click a entity to get a disguise reference you can pass to other disguise commands!");
|
||||
sender.sendMessage(ChatColor.DARK_GREEN
|
||||
+ "Security note: Any references you create will be available to all players able to use disguise references.");
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseclone IgnoreEquipment" + ChatColor.DARK_GREEN + "(" + ChatColor.GREEN
|
||||
+ "Optional" + ChatColor.DARK_GREEN + ")");
|
||||
}
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class DisguiseCommand extends BaseDisguiseCommand {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
Disguise disguise;
|
||||
try {
|
||||
disguise = parseDisguise(sender, args, getPermissions(sender));
|
||||
} catch (DisguiseParseException ex) {
|
||||
if (ex.getMessage() != null) {
|
||||
sender.sendMessage(ex.getMessage());
|
||||
}
|
||||
return true;
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
return true;
|
||||
}
|
||||
if (DisguiseConfig.isNameOfPlayerShownAboveDisguise()) {
|
||||
if (disguise.getWatcher() instanceof LivingWatcher) {
|
||||
disguise.getWatcher().setCustomName(((Player) sender).getDisplayName());
|
||||
if (DisguiseConfig.isNameAboveHeadAlwaysVisible()) {
|
||||
disguise.getWatcher().setCustomNameVisible(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
DisguiseAPI.disguiseToAll((Player) sender, disguise);
|
||||
if (disguise.isDisguiseInUse()) {
|
||||
sender.sendMessage(ChatColor.RED + "Now disguised as a " + disguise.getType().toReadable());
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "Failed to disguise as a " + disguise.getType().toReadable());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player the information
|
||||
*/
|
||||
@Override
|
||||
protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
|
||||
ArrayList<String> allowedDisguises = getAllowedDisguises(map);
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "Choose a disguise to become the disguise!");
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "You can use the disguises: " + ChatColor.GREEN
|
||||
+ StringUtils.join(allowedDisguises, ChatColor.RED + ", " + ChatColor.GREEN));
|
||||
if (allowedDisguises.contains("player")) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguise player <Name>");
|
||||
}
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguise <DisguiseType> <Baby>");
|
||||
if (allowedDisguises.contains("dropped_item") || allowedDisguises.contains("falling_block")) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseplayer <Dropped_Item/Falling_Block> <Id> <Durability>");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Navid
|
||||
*/
|
||||
public class DisguiseViewSelf implements CommandExecutor {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
Player player = (Player) sender;
|
||||
if (DisguiseAPI.isViewSelfToggled(player)) {
|
||||
DisguiseAPI.setViewDisguiseToggled(player, false);
|
||||
sender.sendMessage(ChatColor.GREEN + "Toggled viewing own disguise off!");
|
||||
} else {
|
||||
DisguiseAPI.setViewDisguiseToggled(player, true);
|
||||
sender.sendMessage(ChatColor.GREEN + "Toggled viewing own disguise on!");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.LibsDisguises;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class EntityDisguiseCommand extends BaseDisguiseCommand {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
Disguise disguise;
|
||||
try {
|
||||
disguise = parseDisguise(sender, args, getPermissions(sender));
|
||||
} catch (DisguiseParseException ex) {
|
||||
if (ex.getMessage() != null) {
|
||||
sender.sendMessage(ex.getMessage());
|
||||
}
|
||||
return true;
|
||||
} catch (IllegalAccessException | InvocationTargetException ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
return true;
|
||||
}
|
||||
LibsDisguises.getInstance().getListener().setDisguiseEntity(sender.getName(), disguise);
|
||||
sender.sendMessage(ChatColor.RED + "Right click a entity in the next " + DisguiseConfig.getDisguiseEntityExpire()
|
||||
+ " seconds to disguise it as a " + disguise.getType().toReadable() + "!");
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player the information
|
||||
*
|
||||
* @param sender
|
||||
* @param map
|
||||
*/
|
||||
@Override
|
||||
protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
|
||||
ArrayList<String> allowedDisguises = getAllowedDisguises(map);
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "Choose a disguise then right click a entity to disguise it!");
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "You can use the disguises: " + ChatColor.GREEN
|
||||
+ StringUtils.join(allowedDisguises, ChatColor.RED + ", " + ChatColor.GREEN));
|
||||
if (allowedDisguises.contains("player")) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseentity player <Name>");
|
||||
}
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseentity <DisguiseType> <Baby>");
|
||||
if (allowedDisguises.contains("dropped_item") || allowedDisguises.contains("falling_block")) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseentity <Dropped_Item/Falling_Block> <Id> <Durability>");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,282 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.AnimalColor;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.RabbitType;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.potion.PotionEffectType;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class HelpDisguiseCommand extends BaseDisguiseCommand {
|
||||
|
||||
private class EnumHelp {
|
||||
|
||||
private String enumDescription;
|
||||
private String enumName;
|
||||
private String[] enums;
|
||||
private String readableEnum;
|
||||
|
||||
public EnumHelp(String enumName, String enumReadable, String enumDescription, Enum[] enums) {
|
||||
String[] strings = new String[enums.length];
|
||||
for (int i = 0; i < strings.length; i++) {
|
||||
strings[i] = toReadable(enums[i].name());
|
||||
}
|
||||
this.enumName = enumName;
|
||||
this.enumDescription = enumDescription;
|
||||
this.enums = strings;
|
||||
this.readableEnum = enumReadable;
|
||||
}
|
||||
|
||||
public EnumHelp(String enumName, String enumReadable, String enumDescription, String[] enums) {
|
||||
this.enumName = enumName;
|
||||
this.enumDescription = enumDescription;
|
||||
this.enums = enums;
|
||||
this.readableEnum = enumReadable;
|
||||
}
|
||||
|
||||
public String getEnumDescription() {
|
||||
return enumDescription;
|
||||
}
|
||||
|
||||
public String getEnumName() {
|
||||
return enumName;
|
||||
}
|
||||
|
||||
public String[] getEnums() {
|
||||
return enums;
|
||||
}
|
||||
|
||||
public String getReadableEnum() {
|
||||
return readableEnum;
|
||||
}
|
||||
}
|
||||
|
||||
private ArrayList<EnumHelp> enumHelp = new ArrayList<>();
|
||||
|
||||
public HelpDisguiseCommand() {
|
||||
try {
|
||||
enumHelp.add(new EnumHelp("AnimalColor", "Animal colors", ChatColor.RED + "/disguisehelp AnimalColors "
|
||||
+ ChatColor.GREEN + "- View all the colors you can use for a animal color", AnimalColor.values()));
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
try {
|
||||
enumHelp.add(new EnumHelp("Art", "Arts", ChatColor.RED + "/disguisehelp Art " + ChatColor.GREEN
|
||||
+ "- View all the painting arts you can use on a painting disguise", (Enum[]) Class.forName("org.bukkit.Art")
|
||||
.getEnumConstants()));
|
||||
} catch (Exception ex) {
|
||||
}
|
||||
try {
|
||||
enumHelp.add(new EnumHelp("HorseColor", "Horse colors", ChatColor.RED + "/disguisehelp HorseColors "
|
||||
+ ChatColor.GREEN + "- View all the colors you can use for a horses color", (Enum[]) Class.forName(
|
||||
"org.bukkit.entity.Horse$Color").getEnumConstants()));
|
||||
} catch (Exception ex) {
|
||||
}
|
||||
try {
|
||||
enumHelp.add(new EnumHelp("HorseStyle", "Horse styles", ChatColor.RED + "/disguisehelp HorseStyles "
|
||||
+ ChatColor.GREEN + "- View all the styles you can use for a horses style", (Enum[]) Class.forName(
|
||||
"org.bukkit.entity.Horse$Style").getEnumConstants()));
|
||||
} catch (Exception ex) {
|
||||
}
|
||||
try {
|
||||
enumHelp.add(new EnumHelp("OcelotType", "Ocelot types", ChatColor.RED + "/disguisehelp OcelotTypes "
|
||||
+ ChatColor.GREEN + "- View all the ocelot types you can use for ocelots", (Enum[]) Class.forName(
|
||||
"org.bukkit.entity.Ocelot$Type").getEnumConstants()));
|
||||
} catch (Exception ex) {
|
||||
}
|
||||
try {
|
||||
ArrayList<String> enumReturns = new ArrayList<>();
|
||||
for (PotionEffectType potionType : PotionEffectType.values()) {
|
||||
if (potionType != null) {
|
||||
enumReturns.add(toReadable(potionType.getName()) + ChatColor.RED + "(" + ChatColor.GREEN + potionType.getId()
|
||||
+ ChatColor.RED + ")");
|
||||
}
|
||||
}
|
||||
enumHelp.add(new EnumHelp("PotionEffect", "PotionEffect", ChatColor.RED + "/disguisehelp PotionEffect "
|
||||
+ ChatColor.GREEN + "- View all the potion effects you can set", enumReturns.toArray(new String[enumReturns
|
||||
.size()])));
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
try {
|
||||
enumHelp.add(new EnumHelp("Profession", "Villager professions", ChatColor.RED + "/disguisehelp Professions "
|
||||
+ ChatColor.GREEN + "- View all the professions you can set on a villager", (Enum[]) Class.forName(
|
||||
"org.bukkit.entity.Villager$Profession").getEnumConstants()));
|
||||
} catch (Exception ex) {
|
||||
}
|
||||
enumHelp.add(new EnumHelp("Direction", "Directions", ChatColor.RED + "/disguisehelp Directions " + ChatColor.GREEN
|
||||
+ "- View the five directions usable on player setsleeping disguise", Arrays.copyOf(BlockFace.values(), 5)));
|
||||
enumHelp.add(new EnumHelp("RabbitType", "RabbitType", ChatColor.RED + "/disguisehelp RabbitType " + ChatColor.GREEN
|
||||
+ "View the kinds of rabbits you can turn into", RabbitType.values()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
for (String node : new String[]{"disguise", "disguiseradius", "disguiseentity", "disguiseplayer"}) {
|
||||
HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> permMap = getPermissions(sender, "libsdisguises." + node
|
||||
+ ".");
|
||||
if (!permMap.isEmpty()) {
|
||||
if (args.length == 0) {
|
||||
sendCommandUsage(sender, null);
|
||||
return true;
|
||||
} else {
|
||||
EnumHelp help = null;
|
||||
for (EnumHelp s : enumHelp) {
|
||||
if (args[0].equalsIgnoreCase(s.getEnumName()) || args[0].equalsIgnoreCase(s.getEnumName() + "s")) {
|
||||
help = s;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (help != null) {
|
||||
sender.sendMessage(ChatColor.RED + help.getReadableEnum() + ": " + ChatColor.GREEN
|
||||
+ StringUtils.join(help.getEnums(), ChatColor.RED + ", " + ChatColor.GREEN));
|
||||
return true;
|
||||
}
|
||||
DisguiseType type = null;
|
||||
for (DisguiseType disguiseType : DisguiseType.values()) {
|
||||
if (args[0].equalsIgnoreCase(disguiseType.name())
|
||||
|| disguiseType.name().replace("_", "").equalsIgnoreCase(args[0])) {
|
||||
type = disguiseType;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (type == null) {
|
||||
sender.sendMessage(ChatColor.RED + "Cannot find the disguise " + args[0]);
|
||||
return true;
|
||||
}
|
||||
if (!permMap.containsKey(type)) {
|
||||
sender.sendMessage(ChatColor.RED + "You do not have permission for that disguise!");
|
||||
return true;
|
||||
}
|
||||
ArrayList<String> methods = new ArrayList<>();
|
||||
HashMap<String, ChatColor> map = new HashMap<>();
|
||||
Class watcher = type.getWatcherClass();
|
||||
int ignored = 0;
|
||||
try {
|
||||
for (Method method : this.getDisguiseWatcherMethods(watcher)) {
|
||||
if (!method.getName().startsWith("get") && method.getParameterTypes().length == 1
|
||||
&& method.getAnnotation(Deprecated.class) == null) {
|
||||
if (args.length < 2 || !args[1].equalsIgnoreCase("show")) {
|
||||
boolean allowed = false;
|
||||
for (ArrayList<String> key : permMap.get(type).keySet()) {
|
||||
if (permMap.get(type).get(key)) {
|
||||
if (key.contains("*") || key.contains(method.getName().toLowerCase())) {
|
||||
allowed = true;
|
||||
break;
|
||||
}
|
||||
} else if (!key.contains(method.getName().toLowerCase())) {
|
||||
allowed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!allowed) {
|
||||
ignored++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
Class c = method.getParameterTypes()[0];
|
||||
String valueType = null;
|
||||
if (c == String.class) {
|
||||
valueType = "String";
|
||||
} else if (boolean.class == c) {
|
||||
valueType = "True/False";
|
||||
} else if (int.class == c) {
|
||||
valueType = "Number";
|
||||
} else if (float.class == c || double.class == c) {
|
||||
valueType = "Decimal";
|
||||
} else if (AnimalColor.class == c) {
|
||||
valueType = "Color";
|
||||
} else if (ItemStack.class == c) {
|
||||
valueType = "Item (id:damage)";
|
||||
} else if (ItemStack[].class == c) {
|
||||
valueType = "4 items (id:damage,id,...)";
|
||||
} else if (c.getSimpleName().equals("Style")) {
|
||||
valueType = "Horse Style";
|
||||
} else if (c.getSimpleName().equals("Color")) {
|
||||
valueType = "Horse Color";
|
||||
} else if (c.getSimpleName().equals("Type")) {
|
||||
valueType = "Ocelot type";
|
||||
} else if (c.getSimpleName().equals("Profession")) {
|
||||
valueType = "Villager Profession";
|
||||
} else if (PotionEffectType.class == c) {
|
||||
valueType = "Potion effect";
|
||||
} else if (c == int[].class) {
|
||||
valueType = "number,number,number...";
|
||||
} else if (c == BlockFace.class) {
|
||||
valueType = "direction";
|
||||
} else if (c == RabbitType.class) {
|
||||
valueType = "rabbit type";
|
||||
}
|
||||
if (valueType != null) {
|
||||
ChatColor methodColor = ChatColor.YELLOW;
|
||||
Class<?> declaring = method.getDeclaringClass();
|
||||
if (declaring == LivingWatcher.class) {
|
||||
methodColor = ChatColor.AQUA;
|
||||
} else if (!(FlagWatcher.class.isAssignableFrom(declaring)) || declaring == FlagWatcher.class) {
|
||||
methodColor = ChatColor.GRAY;
|
||||
}
|
||||
String str = method.getName() + ChatColor.DARK_RED + "(" + ChatColor.GREEN + valueType
|
||||
+ ChatColor.DARK_RED + ")";
|
||||
map.put(str, methodColor);
|
||||
methods.add(str);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
Collections.sort(methods, String.CASE_INSENSITIVE_ORDER);
|
||||
for (int i = 0; i < methods.size(); i++) {
|
||||
methods.set(i, map.get(methods.get(i)) + methods.get(i));
|
||||
}
|
||||
if (methods.isEmpty()) {
|
||||
methods.add(ChatColor.RED + "No options with permission to use");
|
||||
}
|
||||
sender.sendMessage(ChatColor.DARK_RED + type.toReadable() + " options: "
|
||||
+ StringUtils.join(methods, ChatColor.DARK_RED + ", "));
|
||||
if (ignored > 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Ignored " + ignored
|
||||
+ " options you do not have permission to view. Add 'show' to view unusable options.");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player the information
|
||||
*/
|
||||
@Override
|
||||
protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
|
||||
sender.sendMessage(ChatColor.RED
|
||||
+ "/disguisehelp <DisguiseType> "
|
||||
+ ChatColor.GREEN
|
||||
+ "- View the options you can set on a disguise. Add 'show' to reveal the options you don't have permission to use");
|
||||
for (EnumHelp s : enumHelp) {
|
||||
sender.sendMessage(s.getEnumDescription());
|
||||
}
|
||||
}
|
||||
|
||||
public String toReadable(String string) {
|
||||
String[] split = string.split("_");
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
split[i] = split[i].substring(0, 1) + split[i].substring(1).toLowerCase();
|
||||
}
|
||||
return StringUtils.join(split, "_");
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.LibsDisguises;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
public class LibsDisguisesCommand implements CommandExecutor {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (args.length == 0) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN
|
||||
+ "This server is running "
|
||||
+ "Lib's Disguises v."
|
||||
+ Bukkit.getPluginManager().getPlugin("LibsDisguises").getDescription().getVersion()
|
||||
+ " by libraryaddict, maintained by NavidK0.\n"
|
||||
+ "Use /libsdisguises reload to reload the config. All disguises will be blown by doing this.");
|
||||
} else if (args.length > 0) {
|
||||
if (sender.hasPermission("libsdisguises.reload")) {
|
||||
if (args[0].equalsIgnoreCase("reload")) {
|
||||
LibsDisguises.getInstance().reload();
|
||||
sender.sendMessage(ChatColor.GREEN + "[LibsDisguises] Reloaded config.");
|
||||
return true;
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "[LibsDisguises] That command doesn't exist!");
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,96 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class PlayerDisguiseCommand extends BaseDisguiseCommand {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map = getPermissions(sender);
|
||||
if (map.isEmpty()) {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
return true;
|
||||
}
|
||||
if (args.length == 0) {
|
||||
sendCommandUsage(sender, map);
|
||||
return true;
|
||||
}
|
||||
if (args.length == 1) {
|
||||
sender.sendMessage(ChatColor.RED + "You need to supply a disguise as well as the player");
|
||||
return true;
|
||||
}
|
||||
Player player = Bukkit.getPlayer(args[0]);
|
||||
if (player == null) {
|
||||
sender.sendMessage(ChatColor.RED + "Cannot find the player '" + args[0] + "'");
|
||||
return true;
|
||||
}
|
||||
String[] newArgs = new String[args.length - 1];
|
||||
System.arraycopy(args, 1, newArgs, 0, newArgs.length);
|
||||
Disguise disguise;
|
||||
try {
|
||||
disguise = parseDisguise(sender, newArgs, map);
|
||||
} catch (DisguiseParseException ex) {
|
||||
if (ex.getMessage() != null) {
|
||||
sender.sendMessage(ex.getMessage());
|
||||
}
|
||||
return true;
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
return true;
|
||||
}
|
||||
if (disguise.isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled()) {
|
||||
sender.sendMessage(ChatColor.RED
|
||||
+ "Can't disguise a living entity as a misc disguise. This has been disabled in the config!");
|
||||
return true;
|
||||
}
|
||||
if (DisguiseConfig.isNameOfPlayerShownAboveDisguise()) {
|
||||
if (disguise.getWatcher() instanceof LivingWatcher) {
|
||||
disguise.getWatcher().setCustomName(player.getDisplayName());
|
||||
if (DisguiseConfig.isNameAboveHeadAlwaysVisible()) {
|
||||
disguise.getWatcher().setCustomNameVisible(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
DisguiseAPI.disguiseToAll(player, disguise);
|
||||
if (disguise.isDisguiseInUse()) {
|
||||
sender.sendMessage(ChatColor.RED + "Successfully disguised " + player.getName() + " as a "
|
||||
+ disguise.getType().toReadable() + "!");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "Failed to disguise " + player.getName() + " as a "
|
||||
+ disguise.getType().toReadable() + "!");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player the information
|
||||
*/
|
||||
@Override
|
||||
protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
|
||||
ArrayList<String> allowedDisguises = getAllowedDisguises(map);
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "Disguise another player!");
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "You can use the disguises: " + ChatColor.GREEN
|
||||
+ StringUtils.join(allowedDisguises, ChatColor.RED + ", " + ChatColor.GREEN));
|
||||
if (allowedDisguises.contains("player")) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseplayer <PlayerName> player <Name>");
|
||||
}
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "/disguiseplayer <PlayerName> <DisguiseType> <Baby>");
|
||||
if (allowedDisguises.contains("dropped_item") || allowedDisguises.contains("falling_block")) {
|
||||
sender.sendMessage(ChatColor.DARK_GREEN
|
||||
+ "/disguiseplayer <PlayerName> <Dropped_Item/Falling_Block> <Id> <Durability>");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,175 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import me.libraryaddict.disguise.utilities.ClassGetter;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class RadiusDisguiseCommand extends BaseDisguiseCommand {
|
||||
|
||||
private int maxRadius = 30;
|
||||
private ArrayList<Class> validClasses = new ArrayList<>();
|
||||
|
||||
public RadiusDisguiseCommand(int maxRadius) {
|
||||
this.maxRadius = maxRadius;
|
||||
for (Class c : ClassGetter.getClassesForPackage("org.bukkit.entity")) {
|
||||
if (c != Entity.class && Entity.class.isAssignableFrom(c) && c.getAnnotation(Deprecated.class) == null) {
|
||||
validClasses.add(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map = getPermissions(sender);
|
||||
if (map.isEmpty()) {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
return true;
|
||||
}
|
||||
if (args.length == 0) {
|
||||
sendCommandUsage(sender, map);
|
||||
return true;
|
||||
}
|
||||
if (args[0].equalsIgnoreCase("entitytype") || args[0].equalsIgnoreCase("entitytypes")) {
|
||||
ArrayList<String> classes = new ArrayList<>();
|
||||
for (Class c : validClasses) {
|
||||
classes.add(c.getSimpleName());
|
||||
}
|
||||
Collections.sort(classes);
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "EntityTypes usable are: " + ChatColor.GREEN
|
||||
+ StringUtils.join(classes, ChatColor.DARK_GREEN + ", " + ChatColor.GREEN) + ChatColor.DARK_GREEN + ".");
|
||||
return true;
|
||||
}
|
||||
Class entityClass = Entity.class;
|
||||
EntityType type = null;
|
||||
int starting = 0;
|
||||
if (!isNumeric(args[0])) {
|
||||
for (Class c : validClasses) {
|
||||
if (c.getSimpleName().equalsIgnoreCase(args[0])) {
|
||||
entityClass = c;
|
||||
starting = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (starting == 0) {
|
||||
try {
|
||||
type = EntityType.valueOf(args[0].toUpperCase());
|
||||
} catch (Exception ex) {
|
||||
}
|
||||
if (type == null) {
|
||||
sender.sendMessage(ChatColor.RED + "Unrecognised EntityType " + args[0]);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (args.length == starting + 1) {
|
||||
sender.sendMessage(ChatColor.RED + "You need to supply a disguise as well as the radius"
|
||||
+ (starting != 0 ? " and EntityType" : ""));
|
||||
return true;
|
||||
}
|
||||
if (!isNumeric(args[starting])) {
|
||||
sender.sendMessage(ChatColor.RED + args[starting] + " is not a number");
|
||||
return true;
|
||||
}
|
||||
int radius = Integer.parseInt(args[starting]);
|
||||
if (radius > maxRadius) {
|
||||
sender.sendMessage(ChatColor.RED + "Limited radius to " + maxRadius + "! Don't want to make too much lag right?");
|
||||
radius = maxRadius;
|
||||
}
|
||||
String[] newArgs = new String[args.length - (starting + 1)];
|
||||
System.arraycopy(args, starting + 1, newArgs, 0, newArgs.length);
|
||||
Disguise disguise;
|
||||
try {
|
||||
disguise = parseDisguise(sender, newArgs, map);
|
||||
} catch (DisguiseParseException ex) {
|
||||
if (ex.getMessage() != null) {
|
||||
sender.sendMessage(ex.getMessage());
|
||||
}
|
||||
return true;
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
return true;
|
||||
} // Time to use it!
|
||||
int disguisedEntitys = 0;
|
||||
int miscDisguises = 0;
|
||||
for (Entity entity : ((Player) sender).getNearbyEntities(radius, radius, radius)) {
|
||||
if (entity == sender) {
|
||||
continue;
|
||||
}
|
||||
if (type != null ? entity.getType() == type : entityClass.isAssignableFrom(entity.getClass())) {
|
||||
if (disguise.isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled()
|
||||
&& entity instanceof LivingEntity) {
|
||||
miscDisguises++;
|
||||
continue;
|
||||
}
|
||||
disguise = disguise.clone();
|
||||
if (entity instanceof Player && DisguiseConfig.isNameOfPlayerShownAboveDisguise()) {
|
||||
if (disguise.getWatcher() instanceof LivingWatcher) {
|
||||
disguise.getWatcher().setCustomName(((Player) entity).getDisplayName());
|
||||
if (DisguiseConfig.isNameAboveHeadAlwaysVisible()) {
|
||||
disguise.getWatcher().setCustomNameVisible(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
DisguiseAPI.disguiseToAll(entity, disguise);
|
||||
if (disguise.isDisguiseInUse()) {
|
||||
disguisedEntitys++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (disguisedEntitys > 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Successfully disguised " + disguisedEntitys + " entities!");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "Couldn't find any entities to disguise!");
|
||||
}
|
||||
if (miscDisguises > 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Failed to disguise " + miscDisguises
|
||||
+ " entities because the option to disguise a living entity as a non-living has been disabled in the config");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player the information
|
||||
*/
|
||||
@Override
|
||||
protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
|
||||
ArrayList<String> allowedDisguises = getAllowedDisguises(map);
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "Disguise all entities in a radius! Caps at 30 blocks!");
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "You can use the disguises: " + ChatColor.GREEN
|
||||
+ StringUtils.join(allowedDisguises, ChatColor.RED + ", " + ChatColor.GREEN));
|
||||
String optional = ChatColor.DARK_GREEN + "(" + ChatColor.GREEN + "Optional" + ChatColor.DARK_GREEN + ")";
|
||||
if (allowedDisguises.contains("player")) {
|
||||
sender.sendMessage((ChatColor.DARK_GREEN + "/disguiseradius <EntityType" + optional + "> <Radius> player <Name>")
|
||||
.replace("<", "<" + ChatColor.GREEN).replace(">", ChatColor.DARK_GREEN + ">"));
|
||||
}
|
||||
sender.sendMessage((ChatColor.DARK_GREEN + "/disguiseradius <EntityType" + optional + "> <Radius> <DisguiseType> <Baby"
|
||||
+ optional + ">").replace("<", "<" + ChatColor.GREEN).replace(">", ChatColor.DARK_GREEN + ">"));
|
||||
if (allowedDisguises.contains("dropped_item") || allowedDisguises.contains("falling_block")) {
|
||||
sender.sendMessage((ChatColor.DARK_GREEN + "/disguiseradius <EntityType" + optional
|
||||
+ "> <Radius> <Dropped_Item/Falling_Block> <Id> <Durability" + optional + ">").replace("<",
|
||||
"<" + ChatColor.GREEN).replace(">", ChatColor.DARK_GREEN + ">"));
|
||||
}
|
||||
sender.sendMessage(ChatColor.DARK_GREEN + "See the EntityType's usable by " + ChatColor.GREEN
|
||||
+ "/disguiseradius EntityTypes");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class UndisguiseCommand implements CommandExecutor {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
if (sender.hasPermission("libsdisguises.undisguise")) {
|
||||
if (DisguiseAPI.isDisguised((Entity) sender)) {
|
||||
DisguiseAPI.undisguiseToAll((Player) sender);
|
||||
sender.sendMessage(ChatColor.RED + "You are no longer disguised");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are not disguised!");
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.LibsDisguises;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
public class UndisguiseEntityCommand implements CommandExecutor {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
if (sender.hasPermission("libsdisguises.undisguiseentity")) {
|
||||
LibsDisguises.getInstance().getListener().setDisguiseEntity(sender.getName(), null);
|
||||
sender.sendMessage(ChatColor.RED + "Right click a disguised entity to undisguise them!");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class UndisguisePlayerCommand implements CommandExecutor {
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.hasPermission("libsdisguises.undisguiseplayer")) {
|
||||
if (args.length > 0) {
|
||||
Player p = Bukkit.getPlayer(args[0]);
|
||||
if (p != null) {
|
||||
if (DisguiseAPI.isDisguised(p)) {
|
||||
DisguiseAPI.undisguiseToAll(p);
|
||||
sender.sendMessage(ChatColor.RED + "The player is no longer disguised");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "The player is not disguised!");
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "Player not found");
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "/undisguiseplayer <Name>");
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
package me.libraryaddict.disguise.commands;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandExecutor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class UndisguiseRadiusCommand implements CommandExecutor {
|
||||
|
||||
private int maxRadius = 30;
|
||||
|
||||
public UndisguiseRadiusCommand(int maxRadius) {
|
||||
this.maxRadius = maxRadius;
|
||||
}
|
||||
|
||||
private boolean isNumeric(String string) {
|
||||
try {
|
||||
Integer.parseInt(string);
|
||||
return true;
|
||||
} catch (Exception ex) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
||||
if (sender.getName().equals("CONSOLE")) {
|
||||
sender.sendMessage(ChatColor.RED + "You may not use this command from the console!");
|
||||
return true;
|
||||
}
|
||||
if (sender.hasPermission("libsdisguises.undisguiseradius")) {
|
||||
int radius = maxRadius;
|
||||
if (args.length > 0) {
|
||||
if (!isNumeric(args[0])) {
|
||||
sender.sendMessage(ChatColor.RED + "Error! " + ChatColor.GREEN + args[0] + ChatColor.RED
|
||||
+ " is not a number!");
|
||||
return true;
|
||||
}
|
||||
radius = Integer.parseInt(args[0]);
|
||||
if (radius > maxRadius) {
|
||||
sender.sendMessage(ChatColor.RED + "Limited radius to " + maxRadius
|
||||
+ "! Don't want to make too much lag right?");
|
||||
radius = maxRadius;
|
||||
}
|
||||
}
|
||||
int disguisedEntitys = 0;
|
||||
for (Entity entity : ((Player) sender).getNearbyEntities(radius, radius, radius)) {
|
||||
if (entity == sender) {
|
||||
continue;
|
||||
}
|
||||
if (DisguiseAPI.isDisguised(entity)) {
|
||||
DisguiseAPI.undisguiseToAll(entity);
|
||||
disguisedEntitys++;
|
||||
}
|
||||
}
|
||||
sender.sendMessage(ChatColor.RED + "Successfully undisguised " + disguisedEntitys + " entities!");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
public enum AnimalColor {
|
||||
|
||||
BLACK(15), BLUE(11), BROWN(12), CYAN(9), GRAY(7), GREEN(13), LIGHT_BLUE(3), LIME(5), MAGENTA(2), ORANGE(1), PINK(6), PURPLE(
|
||||
10), RED(14), SILVER(8), WHITE(0), YELLOW(4);
|
||||
|
||||
public static AnimalColor getColor(int nmsId) {
|
||||
for (AnimalColor color : values()) {
|
||||
if (color.getId() == nmsId) {
|
||||
return color;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private int value;
|
||||
|
||||
AnimalColor(int newValue) {
|
||||
value = newValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* The color ID as defined by nms internals.
|
||||
*/
|
||||
public int getId() {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
@@ -1,767 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import com.comphenix.protocol.PacketType.Play.Server;
|
||||
import com.comphenix.protocol.ProtocolLibrary;
|
||||
import com.comphenix.protocol.events.PacketContainer;
|
||||
import com.comphenix.protocol.reflect.StructureModifier;
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.LibsDisguises;
|
||||
import me.libraryaddict.disguise.disguisetypes.TargetedDisguise.TargetType;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.AgeableWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.BatWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.GuardianWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.HorseWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.SkeletonWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.ZombieWatcher;
|
||||
import me.libraryaddict.disguise.events.DisguiseEvent;
|
||||
import me.libraryaddict.disguise.events.UndisguiseEvent;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseValues;
|
||||
import me.libraryaddict.disguise.utilities.PacketsManager;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Horse.Variant;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.entity.Skeleton.SkeletonType;
|
||||
import org.bukkit.entity.Villager.Profession;
|
||||
import org.bukkit.scheduler.BukkitTask;
|
||||
import org.bukkit.util.Vector;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
public abstract class Disguise {
|
||||
|
||||
private boolean disguiseInUse;
|
||||
private DisguiseType disguiseType;
|
||||
private Entity entity;
|
||||
private boolean hearSelfDisguise = DisguiseConfig.isSelfDisguisesSoundsReplaced();
|
||||
private boolean hideArmorFromSelf = DisguiseConfig.isHidingArmorFromSelf();
|
||||
private boolean hideHeldItemFromSelf = DisguiseConfig.isHidingHeldItemFromSelf();
|
||||
private boolean keepDisguiseEntityDespawn = DisguiseConfig.isKeepDisguiseOnEntityDespawn();
|
||||
private boolean keepDisguisePlayerDeath = DisguiseConfig.isKeepDisguiseOnPlayerDeath();
|
||||
private boolean keepDisguisePlayerLogout = DisguiseConfig.isKeepDisguiseOnPlayerLogout();
|
||||
private boolean modifyBoundingBox = DisguiseConfig.isModifyBoundingBox();
|
||||
private boolean replaceSounds = DisguiseConfig.isSoundEnabled();
|
||||
private BukkitTask task = null;
|
||||
private Runnable velocityRunnable;
|
||||
private boolean velocitySent = DisguiseConfig.isVelocitySent();
|
||||
private boolean viewSelfDisguise = DisguiseConfig.isViewDisguises();
|
||||
private FlagWatcher watcher;
|
||||
private boolean showName = false;
|
||||
|
||||
private static List<UUID> viewSelf = new ArrayList<>();
|
||||
|
||||
@Override
|
||||
public abstract Disguise clone();
|
||||
|
||||
/**
|
||||
* Seems I do this method so I can make cleaner constructors on disguises..
|
||||
*
|
||||
* @param newType The disguise
|
||||
*/
|
||||
protected void createDisguise(DisguiseType newType) {
|
||||
if (getWatcher() != null) {
|
||||
return;
|
||||
}
|
||||
if (newType.getEntityType() == null) {
|
||||
throw new RuntimeException(
|
||||
"DisguiseType "
|
||||
+ newType
|
||||
+ " was used in a futile attempt to construct a disguise, but this version of Spigot does not have that entity");
|
||||
}
|
||||
// Set the disguise type
|
||||
disguiseType = newType;
|
||||
// Get if they are a adult now..
|
||||
boolean isAdult = true;
|
||||
if (isMobDisguise()) {
|
||||
isAdult = ((MobDisguise) this).isAdult();
|
||||
}
|
||||
try {
|
||||
// Construct the FlagWatcher from the stored class
|
||||
setWatcher((FlagWatcher) getType().getWatcherClass().getConstructor(Disguise.class).newInstance(this));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
// Set the disguise if its a baby or not
|
||||
if (!isAdult) {
|
||||
if (getWatcher() instanceof AgeableWatcher) {
|
||||
((AgeableWatcher) getWatcher()).setBaby(true);
|
||||
} else if (getWatcher() instanceof ZombieWatcher) {
|
||||
((ZombieWatcher) getWatcher()).setBaby(true);
|
||||
}
|
||||
}
|
||||
// If the disguise type is a wither, set the flagwatcher value for the skeleton to a wither skeleton
|
||||
if (getType() == DisguiseType.WITHER_SKELETON) {
|
||||
((SkeletonWatcher)getWatcher()).setType(SkeletonType.WITHER);
|
||||
} // Else if its a zombie, but the disguise type is a zombie villager. Set the value.
|
||||
else if (getType() == DisguiseType.ZOMBIE_VILLAGER) {
|
||||
((ZombieWatcher)getWatcher()).setProfession(Profession.values()[DisguiseUtilities.random.nextInt(Profession.values().length)]);
|
||||
} else if (getType() == DisguiseType.ELDER_GUARDIAN) {
|
||||
((GuardianWatcher)getWatcher()).setElder(true);
|
||||
} // Else if its a horse. Set the horse watcher type
|
||||
else if (getWatcher() instanceof HorseWatcher) {
|
||||
try {
|
||||
Variant horseType = Variant.valueOf(getType().name());
|
||||
((HorseWatcher)getWatcher()).setVariant(horseType);
|
||||
} catch (Exception ex) {
|
||||
// Ok.. So it aint a horse
|
||||
}
|
||||
}
|
||||
final boolean alwaysSendVelocity;
|
||||
switch (getType()) {
|
||||
case EGG:
|
||||
case ENDER_PEARL:
|
||||
case BAT:
|
||||
case EXPERIENCE_ORB:
|
||||
case FIREBALL:
|
||||
case SMALL_FIREBALL:
|
||||
case SNOWBALL:
|
||||
case SPLASH_POTION:
|
||||
case THROWN_EXP_BOTTLE:
|
||||
case WITHER_SKULL:
|
||||
case FIREWORK:
|
||||
alwaysSendVelocity = true;
|
||||
break;
|
||||
default:
|
||||
alwaysSendVelocity = false;
|
||||
break;
|
||||
}
|
||||
double velocitySpeed = 0.0005;
|
||||
switch (getType()) {
|
||||
case FIREWORK:
|
||||
velocitySpeed = -0.040;
|
||||
break;
|
||||
case WITHER_SKULL:
|
||||
velocitySpeed = 0.000001D;
|
||||
break;
|
||||
case ARROW:
|
||||
case TIPPED_ARROW:
|
||||
case SPECTRAL_ARROW:
|
||||
case BOAT:
|
||||
case ENDER_CRYSTAL:
|
||||
case ENDER_DRAGON:
|
||||
case GHAST:
|
||||
case ITEM_FRAME:
|
||||
case MINECART:
|
||||
case MINECART_CHEST:
|
||||
case MINECART_COMMAND:
|
||||
case MINECART_FURNACE:
|
||||
case MINECART_HOPPER:
|
||||
case MINECART_MOB_SPAWNER:
|
||||
case MINECART_TNT:
|
||||
case PAINTING:
|
||||
case PLAYER:
|
||||
case SQUID:
|
||||
velocitySpeed = 0;
|
||||
break;
|
||||
case DROPPED_ITEM:
|
||||
case PRIMED_TNT:
|
||||
case WITHER:
|
||||
case FALLING_BLOCK:
|
||||
velocitySpeed = 0.04;
|
||||
break;
|
||||
case EXPERIENCE_ORB:
|
||||
velocitySpeed = 0.0221;
|
||||
break;
|
||||
case SPIDER:
|
||||
case BAT:
|
||||
case CAVE_SPIDER:
|
||||
velocitySpeed = 0.004;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
final double vectorY = velocitySpeed;
|
||||
final TargetedDisguise disguise = (TargetedDisguise) this;
|
||||
// A scheduler to clean up any unused disguises.
|
||||
velocityRunnable = new Runnable() {
|
||||
private int blockX, blockY, blockZ, facing;
|
||||
private int deadTicks = 0;
|
||||
private int refreshDisguise = 0;
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
// If entity is no longer valid. Remove it.
|
||||
if (!getEntity().isValid()) {
|
||||
// If it has been dead for 30+ ticks
|
||||
// This is to ensure that this disguise isn't removed while clients think its the real entity
|
||||
// The delay is because if it sends the destroy entity packets straight away, then it means no death animation
|
||||
// This is probably still a problem for wither and enderdragon deaths.
|
||||
if (deadTicks++ > (getType() == DisguiseType.ENDER_DRAGON ? 200 : 20)) {
|
||||
deadTicks = 0;
|
||||
if (isRemoveDisguiseOnDeath()) {
|
||||
removeDisguise();
|
||||
} else {
|
||||
entity = null;
|
||||
watcher = getWatcher().clone(disguise);
|
||||
task.cancel();
|
||||
task = null;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
deadTicks = 0;
|
||||
// If the disguise type is tnt, we need to resend the entity packet else it will turn invisible
|
||||
if (getType() == DisguiseType.PRIMED_TNT || getType() == DisguiseType.FIREWORK) {
|
||||
refreshDisguise++;
|
||||
if (refreshDisguise % 40 == 0) {
|
||||
refreshDisguise = 0;
|
||||
DisguiseUtilities.refreshTrackers(disguise);
|
||||
}
|
||||
}
|
||||
if (getType() == DisguiseType.ITEM_FRAME) {
|
||||
Location loc = getEntity().getLocation();
|
||||
int newFacing = (((int) loc.getYaw() + 720 + 45) / 90) % 4;
|
||||
if (loc.getBlockX() != blockX || loc.getBlockY() != blockY || loc.getBlockZ() != blockZ
|
||||
|| newFacing != facing) {
|
||||
blockX = loc.getBlockX();
|
||||
blockY = loc.getBlockY();
|
||||
blockZ = loc.getBlockZ();
|
||||
facing = newFacing;
|
||||
DisguiseUtilities.refreshTrackers(disguise);
|
||||
}
|
||||
}
|
||||
if (isModifyBoundingBox()) {
|
||||
DisguiseUtilities.doBoundingBox(disguise);
|
||||
}
|
||||
if (getType() == DisguiseType.BAT && !((BatWatcher) getWatcher()).isHanging()) {
|
||||
return;
|
||||
}
|
||||
// If the vectorY isn't 0. Cos if it is. Then it doesn't want to send any vectors.
|
||||
// If this disguise has velocity sending enabled and the entity is flying.
|
||||
if (isVelocitySent() && vectorY != 0 && (alwaysSendVelocity || !getEntity().isOnGround())) {
|
||||
Vector vector = getEntity().getVelocity();
|
||||
// If the entity doesn't have velocity changes already - You know. I really can't wrap my head about the
|
||||
// if statement.
|
||||
// But it doesn't seem to do anything wrong..
|
||||
if (vector.getY() != 0 && !(vector.getY() < 0 && alwaysSendVelocity && getEntity().isOnGround())) {
|
||||
return;
|
||||
}
|
||||
// If disguise isn't a experience orb, or the entity isn't standing on the ground
|
||||
if (getType() != DisguiseType.EXPERIENCE_ORB || !getEntity().isOnGround()) {
|
||||
PacketContainer lookPacket = null;
|
||||
if (getType() == DisguiseType.WITHER_SKULL && DisguiseConfig.isWitherSkullPacketsEnabled()) {
|
||||
lookPacket = new PacketContainer(Server.ENTITY_LOOK);
|
||||
StructureModifier<Object> mods = lookPacket.getModifier();
|
||||
lookPacket.getIntegers().write(0, getEntity().getEntityId());
|
||||
Location loc = getEntity().getLocation();
|
||||
mods.write(4, PacketsManager.getYaw(getType(), getEntity().getType(), (byte) Math.floor(loc.getYaw() * 256.0F / 360.0F)));
|
||||
mods.write(5, PacketsManager.getPitch(getType(), DisguiseType.getType(getEntity().getType()), (byte) Math.floor(loc.getPitch() * 256.0F / 360.0F)));
|
||||
if (isSelfDisguiseVisible() && getEntity() instanceof Player) {
|
||||
PacketContainer selfLookPacket = lookPacket.shallowClone();
|
||||
selfLookPacket.getIntegers().write(0, DisguiseAPI.getSelfDisguiseId());
|
||||
try {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket((Player) getEntity(),
|
||||
selfLookPacket, false);
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
PacketContainer velocityPacket = new PacketContainer(Server.ENTITY_VELOCITY);
|
||||
StructureModifier<Integer> mods = velocityPacket.getIntegers();
|
||||
mods.write(1, (int) (vector.getX() * 8000));
|
||||
mods.write(3, (int) (vector.getZ() * 8000));
|
||||
for (Player player : DisguiseUtilities.getPerverts(disguise)) {
|
||||
if (getEntity() == player) {
|
||||
if (!isSelfDisguiseVisible()) {
|
||||
continue;
|
||||
}
|
||||
mods.write(0, DisguiseAPI.getSelfDisguiseId());
|
||||
} else {
|
||||
mods.write(0, getEntity().getEntityId());
|
||||
}
|
||||
mods.write(2, (int) (8000D * (vectorY * ReflectionManager.getPing(player)) * 0.069D));
|
||||
if (lookPacket != null && player != getEntity()) {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, lookPacket, false);
|
||||
}
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, velocityPacket.shallowClone(),
|
||||
false);
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
// If we need to send a packet to update the exp position as it likes to gravitate client sided to
|
||||
// players.
|
||||
}
|
||||
if (getType() == DisguiseType.EXPERIENCE_ORB) {
|
||||
PacketContainer packet = new PacketContainer(Server.REL_ENTITY_MOVE);
|
||||
packet.getIntegers().write(0, getEntity().getEntityId());
|
||||
try {
|
||||
for (Player player : DisguiseUtilities.getPerverts(disguise)) {
|
||||
if (getEntity() != player) {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet, false);
|
||||
} else if (isSelfDisguiseVisible()) {
|
||||
PacketContainer selfPacket = packet.shallowClone();
|
||||
selfPacket.getModifier().write(0, DisguiseAPI.getSelfDisguiseId());
|
||||
try {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket((Player) getEntity(), selfPacket, false);
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the disguised entity
|
||||
*
|
||||
* @return entity
|
||||
*/
|
||||
public Entity getEntity() {
|
||||
return entity;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the disguise type
|
||||
*
|
||||
* @return disguiseType
|
||||
*/
|
||||
public DisguiseType getType() {
|
||||
return disguiseType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the flag watcher
|
||||
*
|
||||
* @return flagWatcher
|
||||
*/
|
||||
public FlagWatcher getWatcher() {
|
||||
return watcher;
|
||||
}
|
||||
|
||||
/**
|
||||
* In use doesn't mean that this disguise is active. It means that Lib's Disguises still stores a reference to the disguise. getEntity() can still return null if this disguise is active after despawn, logout, etc.
|
||||
*
|
||||
* @return isDisguiseInUse
|
||||
*/
|
||||
public boolean isDisguiseInUse() {
|
||||
return disguiseInUse;
|
||||
}
|
||||
|
||||
public boolean isHidingArmorFromSelf() {
|
||||
return hideArmorFromSelf;
|
||||
}
|
||||
|
||||
public boolean isHidingHeldItemFromSelf() {
|
||||
return hideHeldItemFromSelf;
|
||||
}
|
||||
|
||||
public boolean isKeepDisguiseOnEntityDespawn() {
|
||||
return this.keepDisguiseEntityDespawn;
|
||||
}
|
||||
|
||||
public boolean isKeepDisguiseOnPlayerDeath() {
|
||||
return this.keepDisguisePlayerDeath;
|
||||
}
|
||||
|
||||
public boolean isKeepDisguiseOnPlayerLogout() {
|
||||
return this.keepDisguisePlayerLogout;
|
||||
}
|
||||
|
||||
public boolean isMiscDisguise() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isMobDisguise() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean isModifyBoundingBox() {
|
||||
return modifyBoundingBox;
|
||||
}
|
||||
|
||||
public boolean isPlayerDisguise() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Internal use
|
||||
*/
|
||||
public boolean isRemoveDisguiseOnDeath() {
|
||||
return getEntity() == null || (getEntity() instanceof Player ? (!((Player) getEntity()).isOnline() ? !isKeepDisguiseOnPlayerLogout() : !isKeepDisguiseOnPlayerDeath()) : (!isKeepDisguiseOnEntityDespawn() || getEntity().isDead()));
|
||||
}
|
||||
|
||||
public boolean isSelfDisguiseSoundsReplaced() {
|
||||
return hearSelfDisguise;
|
||||
}
|
||||
|
||||
/**
|
||||
* Can the disguised view himself as the disguise
|
||||
*
|
||||
* @return viewSelfDisguise
|
||||
*/
|
||||
public boolean isSelfDisguiseVisible() {
|
||||
return viewSelfDisguise;
|
||||
}
|
||||
|
||||
public boolean isSoundsReplaced() {
|
||||
return replaceSounds;
|
||||
}
|
||||
|
||||
public boolean isVelocitySent() {
|
||||
return velocitySent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the entity's name is showing through the disguise
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public boolean isShowName() {
|
||||
return showName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the disguise and undisguises the entity if its using this disguise.
|
||||
*
|
||||
* @return removeDiguise
|
||||
*/
|
||||
public boolean removeDisguise() {
|
||||
if (disguiseInUse) {
|
||||
UndisguiseEvent event = new UndisguiseEvent(entity, this);
|
||||
Bukkit.getPluginManager().callEvent(event);
|
||||
if (!event.isCancelled()) {
|
||||
disguiseInUse = false;
|
||||
if (task != null) {
|
||||
task.cancel();
|
||||
task = null;
|
||||
}
|
||||
HashMap<UUID, HashSet<TargetedDisguise>> disguises = DisguiseUtilities.getDisguises();
|
||||
// If this disguise has a entity set
|
||||
if (getEntity() != null) {
|
||||
// If this disguise is active
|
||||
// Remove the disguise from the current disguises.
|
||||
if (DisguiseUtilities.removeDisguise((TargetedDisguise) this)) {
|
||||
if (getEntity() instanceof Player) {
|
||||
DisguiseUtilities.removeSelfDisguise((Player) getEntity());
|
||||
}
|
||||
|
||||
// Better refresh the entity to undisguise it
|
||||
if (getEntity().isValid()) {
|
||||
DisguiseUtilities.refreshTrackers((TargetedDisguise) this);
|
||||
} else {
|
||||
DisguiseUtilities.destroyEntity((TargetedDisguise) this);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Loop through the disguises because it could be used with a unknown entity id.
|
||||
HashMap<Integer, HashSet<TargetedDisguise>> future = DisguiseUtilities.getFutureDisguises();
|
||||
Iterator<Integer> itel = DisguiseUtilities.getFutureDisguises().keySet().iterator();
|
||||
while (itel.hasNext()) {
|
||||
int id = itel.next();
|
||||
if (future.get(id).remove(this) && future.get(id).isEmpty()) {
|
||||
itel.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (isPlayerDisguise()) {
|
||||
String name = ((PlayerDisguise) this).getName();
|
||||
if (!DisguiseUtilities.getAddedByPlugins().contains(name.toLowerCase())) {
|
||||
for (HashSet<TargetedDisguise> disguise : disguises.values()) {
|
||||
for (Disguise d : disguise) {
|
||||
if (d.isPlayerDisguise() && ((PlayerDisguise) d).getName().equals(name)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
DisguiseUtilities.getGameProfiles().remove(name.toLowerCase());
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the entity of the disguise. Only used for internal things.
|
||||
*
|
||||
* @param entity
|
||||
* @return disguise
|
||||
*/
|
||||
public Disguise setEntity(Entity entity) {
|
||||
if (this.getEntity() != null) {
|
||||
if (getEntity() == entity) {
|
||||
return this;
|
||||
}
|
||||
throw new RuntimeException("This disguise is already in use! Try .clone()");
|
||||
}
|
||||
if (isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled() && entity instanceof LivingEntity) {
|
||||
throw new RuntimeException(
|
||||
"Cannot disguise a living entity with a misc disguise. Reenable MiscDisguisesForLiving in the config to do this");
|
||||
}
|
||||
this.entity = entity;
|
||||
setupWatcher();
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setShowName(boolean showName) {
|
||||
this.showName = showName;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setHearSelfDisguise(boolean hearSelfDisguise) {
|
||||
this.hearSelfDisguise = hearSelfDisguise;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setHideArmorFromSelf(boolean hideArmor) {
|
||||
this.hideArmorFromSelf = hideArmor;
|
||||
if (getEntity() instanceof Player) {
|
||||
((Player) getEntity()).updateInventory();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setHideHeldItemFromSelf(boolean hideHeldItem) {
|
||||
this.hideHeldItemFromSelf = hideHeldItem;
|
||||
if (getEntity() instanceof Player) {
|
||||
((Player) getEntity()).updateInventory();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setKeepDisguiseOnEntityDespawn(boolean keepDisguise) {
|
||||
this.keepDisguiseEntityDespawn = keepDisguise;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setKeepDisguiseOnPlayerDeath(boolean keepDisguise) {
|
||||
this.keepDisguisePlayerDeath = keepDisguise;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setKeepDisguiseOnPlayerLogout(boolean keepDisguise) {
|
||||
this.keepDisguisePlayerLogout = keepDisguise;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setModifyBoundingBox(boolean modifyBox) {
|
||||
if (((TargetedDisguise) this).getDisguiseTarget() != TargetType.SHOW_TO_EVERYONE_BUT_THESE_PLAYERS) {
|
||||
throw new RuntimeException(
|
||||
"Cannot modify the bounding box of a disguise which is not TargetType.SHOW_TO_EVERYONE_BUT_THESE_PLAYERS");
|
||||
}
|
||||
if (isModifyBoundingBox() != modifyBox) {
|
||||
this.modifyBoundingBox = modifyBox;
|
||||
if (DisguiseUtilities.isDisguiseInUse(this)) {
|
||||
DisguiseUtilities.doBoundingBox((TargetedDisguise) this);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setReplaceSounds(boolean areSoundsReplaced) {
|
||||
replaceSounds = areSoundsReplaced;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets up the FlagWatcher with the entityclass, it creates all the data it needs to prevent conflicts when sending the datawatcher.
|
||||
*/
|
||||
private void setupWatcher() {
|
||||
HashMap<Integer, Object> disguiseValues = DisguiseValues.getMetaValues(getType());
|
||||
HashMap<Integer, Object> entityValues = DisguiseValues.getMetaValues(DisguiseType.getType(getEntity().getType()));
|
||||
// Start from 2 as they ALL share 0 and 1
|
||||
for (int dataNo = 0; dataNo <= 31; dataNo++) {
|
||||
// STEP 1. Find out if the watcher has set data on it.
|
||||
// If the watcher already set a metadata on this
|
||||
if (getWatcher().hasValue(dataNo)) {
|
||||
// Better check that the value is stable.
|
||||
// To check this, I'm going to check if there exists a default value
|
||||
// Then I'm going to check if the watcher value is the same as the default value.
|
||||
if (disguiseValues.containsKey(dataNo)) {
|
||||
// Now check if they are the same class, or both null.
|
||||
if (disguiseValues.get(dataNo) == null || getWatcher().getValue(dataNo, null) == null) {
|
||||
if (disguiseValues.get(dataNo) == null && getWatcher().getValue(dataNo, null) == null) {
|
||||
// They are both null. Idk what this means really.
|
||||
continue;
|
||||
}
|
||||
} else if (getWatcher().getValue(dataNo, null).getClass() == disguiseValues.get(dataNo).getClass()) {
|
||||
// The classes are the same. The client "shouldn't" crash.
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
// STEP 2. As the watcher has not set data on it, check if I need to set the default data.
|
||||
// If neither of them touch it
|
||||
if (!entityValues.containsKey(dataNo) && !disguiseValues.containsKey(dataNo)) {
|
||||
continue;
|
||||
}
|
||||
// If the disguise has this, but not the entity. Then better set it!
|
||||
if (!entityValues.containsKey(dataNo) && disguiseValues.containsKey(dataNo)) {
|
||||
getWatcher().setBackupValue(dataNo, disguiseValues.get(dataNo));
|
||||
continue;
|
||||
}
|
||||
// Else if the disguise doesn't have it. But the entity does. Better remove it!
|
||||
if (entityValues.containsKey(dataNo) && !disguiseValues.containsKey(dataNo)) {
|
||||
getWatcher().setBackupValue(dataNo, null);
|
||||
continue;
|
||||
}
|
||||
Object eObj = entityValues.get(dataNo);
|
||||
Object dObj = disguiseValues.get(dataNo);
|
||||
if (eObj == null || dObj == null) {
|
||||
if (eObj == null && dObj == null) {
|
||||
continue;
|
||||
} else {
|
||||
getWatcher().setBackupValue(dataNo, dObj);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (eObj.getClass() != dObj.getClass()) {
|
||||
getWatcher().setBackupValue(dataNo, dObj);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Since they both share it. With the same classes. Time to check if its from something they extend.
|
||||
// Better make this clear before I compare the values because some default values are different!
|
||||
// Entity is 0 & 1 - But we aint gonna be checking that
|
||||
// EntityAgeable is 11
|
||||
// EntityInsentient is 10
|
||||
// EntityLiving is 5 & 6 & 7 & 8 & 9
|
||||
// Lets use switch
|
||||
Class baseClass = null;
|
||||
switch (dataNo) {
|
||||
case 5:
|
||||
case 6:
|
||||
case 7:
|
||||
case 8:
|
||||
case 9:
|
||||
baseClass = ReflectionManager.getNmsClass("EntityLiving");
|
||||
break;
|
||||
case 10:
|
||||
baseClass = ReflectionManager.getNmsClass("EntityInsentient");
|
||||
break;
|
||||
case 11:
|
||||
baseClass = ReflectionManager.getNmsClass("EntityAgeable");
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
Class nmsEntityClass = ReflectionManager.getNmsEntity(getEntity()).getClass();
|
||||
Class nmsDisguiseClass = DisguiseValues.getNmsEntityClass(getType());
|
||||
if (nmsDisguiseClass != null) {
|
||||
// If they both extend the same base class. They OBVIOUSLY share the same datavalue. Right..?
|
||||
if (baseClass != null && baseClass.isAssignableFrom(nmsDisguiseClass)
|
||||
&& baseClass.isAssignableFrom(nmsEntityClass)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// So they don't extend a basic class.
|
||||
// Maybe if I check that they extend each other..
|
||||
// Seeing as I only store the finished forms of entitys. This should raise no problems and allow for more shared
|
||||
// datawatchers.
|
||||
if (nmsEntityClass.isAssignableFrom(nmsDisguiseClass) || nmsDisguiseClass.isAssignableFrom(nmsEntityClass)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
// Well I can't find a reason I should leave it alone. They will probably conflict.
|
||||
// Time to set the value to the disguises value so no conflicts!
|
||||
getWatcher().setBackupValue(dataNo, disguiseValues.get(dataNo));
|
||||
}
|
||||
}
|
||||
|
||||
public Disguise setVelocitySent(boolean sendVelocity) {
|
||||
this.velocitySent = sendVelocity;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Can the disguised view himself as the disguise
|
||||
*
|
||||
* @param viewSelfDisguise
|
||||
* @return
|
||||
*/
|
||||
public Disguise setViewSelfDisguise(boolean viewSelfDisguise) {
|
||||
if (isSelfDisguiseVisible() != viewSelfDisguise) {
|
||||
this.viewSelfDisguise = viewSelfDisguise;
|
||||
if (getEntity() != null && getEntity() instanceof Player) {
|
||||
if (DisguiseAPI.getDisguise((Player) getEntity(), getEntity()) == this) {
|
||||
if (isSelfDisguiseVisible()) {
|
||||
DisguiseUtilities.setupFakeDisguise(this);
|
||||
} else {
|
||||
DisguiseUtilities.removeSelfDisguise((Player) getEntity());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public Disguise setWatcher(FlagWatcher newWatcher) {
|
||||
if (!getType().getWatcherClass().isInstance(newWatcher)) {
|
||||
throw new IllegalArgumentException(newWatcher.getClass().getSimpleName() + " is not a instance of "
|
||||
+ getType().getWatcherClass().getSimpleName() + " for DisguiseType " + getType().name());
|
||||
}
|
||||
watcher = newWatcher;
|
||||
if (getEntity() != null) {
|
||||
setupWatcher();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean startDisguise() {
|
||||
if (!isDisguiseInUse()) {
|
||||
if (getEntity() == null) {
|
||||
throw new RuntimeException("No entity is assigned to this disguise!");
|
||||
}
|
||||
// Fire a disguise event
|
||||
DisguiseEvent event = new DisguiseEvent(entity, this);
|
||||
Bukkit.getPluginManager().callEvent(event);
|
||||
// If they cancelled this disguise event. No idea why.
|
||||
// Just return.
|
||||
if (!event.isCancelled()) {
|
||||
disguiseInUse = true;
|
||||
task = Bukkit.getScheduler().runTaskTimer(LibsDisguises.getInstance(), velocityRunnable, 1, 1);
|
||||
// Stick the disguise in the disguises bin
|
||||
DisguiseUtilities.addDisguise(entity.getUniqueId(), (TargetedDisguise) this);
|
||||
if (isSelfDisguiseVisible() && getEntity() instanceof Player) {
|
||||
DisguiseUtilities.removeSelfDisguise((Player) getEntity());
|
||||
}
|
||||
// Resend the disguised entity's packet
|
||||
DisguiseUtilities.refreshTrackers((TargetedDisguise) this);
|
||||
// If he is a player, then self disguise himself
|
||||
Bukkit.getScheduler().scheduleSyncDelayedTask(LibsDisguises.getInstance(), new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
DisguiseUtilities.setupFakeDisguise(Disguise.this);
|
||||
}
|
||||
}, 2);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean stopDisguise() {
|
||||
return removeDisguise();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the list of people who have /disguiseViewSelf toggled on
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public static List<UUID> getViewSelf() {
|
||||
return viewSelf;
|
||||
}
|
||||
}
|
||||
@@ -1,290 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.bukkit.entity.Guardian;
|
||||
import org.bukkit.entity.Horse;
|
||||
import org.bukkit.entity.Skeleton;
|
||||
import org.bukkit.entity.Zombie;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
public enum DisguiseType {
|
||||
|
||||
AREA_EFFECT_CLOUD(3, 0),
|
||||
ARMOR_STAND(78),
|
||||
ARROW(60, 0),
|
||||
BAT,
|
||||
BLAZE,
|
||||
BOAT(1),
|
||||
CAVE_SPIDER,
|
||||
CHICKEN,
|
||||
COW,
|
||||
CREEPER,
|
||||
DONKEY,
|
||||
DRAGON_FIREBALL(93),
|
||||
DROPPED_ITEM(2, 1),
|
||||
EGG(62),
|
||||
ELDER_GUARDIAN,
|
||||
ENDER_CRYSTAL(51),
|
||||
ENDER_DRAGON,
|
||||
ENDER_PEARL(65),
|
||||
ENDER_SIGNAL(72),
|
||||
ENDERMAN,
|
||||
ENDERMITE,
|
||||
EXPERIENCE_ORB,
|
||||
FALLING_BLOCK(70, 1),
|
||||
FIREBALL(63),
|
||||
FIREWORK(76),
|
||||
FISHING_HOOK(90),
|
||||
GHAST,
|
||||
GIANT,
|
||||
GUARDIAN,
|
||||
HORSE,
|
||||
IRON_GOLEM,
|
||||
ITEM_FRAME(71),
|
||||
LEASH_HITCH(77),
|
||||
MAGMA_CUBE,
|
||||
MINECART(10),
|
||||
MINECART_CHEST(10, 1),
|
||||
MINECART_COMMAND(10, 6),
|
||||
MINECART_FURNACE(10, 2),
|
||||
MINECART_HOPPER(10, 5),
|
||||
MINECART_MOB_SPAWNER(10, 4),
|
||||
MINECART_TNT(10, 3),
|
||||
MULE,
|
||||
MUSHROOM_COW,
|
||||
OCELOT,
|
||||
PAINTING,
|
||||
PIG,
|
||||
PIG_ZOMBIE,
|
||||
PLAYER,
|
||||
PRIMED_TNT(50),
|
||||
RABBIT,
|
||||
SHEEP,
|
||||
SHULKER,
|
||||
SHULKER_BULLET(67),
|
||||
SILVERFISH,
|
||||
SKELETON,
|
||||
SKELETON_HORSE,
|
||||
SLIME,
|
||||
SMALL_FIREBALL(63),
|
||||
SNOWBALL(61),
|
||||
SNOWMAN,
|
||||
SPECTRAL_ARROW(91),
|
||||
SPIDER,
|
||||
SPLASH_POTION(73, 0),
|
||||
SQUID,
|
||||
TIPPED_ARROW(92),
|
||||
THROWN_EXP_BOTTLE(75),
|
||||
UNDEAD_HORSE,
|
||||
VILLAGER,
|
||||
WITCH,
|
||||
WITHER,
|
||||
WITHER_SKELETON,
|
||||
WITHER_SKULL(66),
|
||||
WOLF,
|
||||
ZOMBIE,
|
||||
ZOMBIE_VILLAGER,
|
||||
UNKNOWN;
|
||||
|
||||
private static Method isVillager, getVariant, getSkeletonType, isElder;
|
||||
|
||||
static {
|
||||
// We set the entity type in this so that we can safely ignore disguisetypes which don't exist in older versions of MC.
|
||||
// Without erroring up everything.
|
||||
for (DisguiseType type : values()) {
|
||||
try {
|
||||
DisguiseType toUse = type;
|
||||
String name;
|
||||
switch (type) {
|
||||
// Disguise item frame isn't supported. So we don't give it a entity type which should prevent it from being..
|
||||
// Usable.
|
||||
case ITEM_FRAME:
|
||||
break;
|
||||
case DONKEY:
|
||||
case MULE:
|
||||
case UNDEAD_HORSE:
|
||||
case SKELETON_HORSE:
|
||||
toUse = DisguiseType.HORSE;
|
||||
break;
|
||||
case ZOMBIE_VILLAGER:
|
||||
toUse = DisguiseType.ZOMBIE;
|
||||
break;
|
||||
case WITHER_SKELETON:
|
||||
toUse = DisguiseType.SKELETON;
|
||||
break;
|
||||
case ELDER_GUARDIAN:
|
||||
toUse = DisguiseType.GUARDIAN;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
name = toUse.name();
|
||||
type.setEntityType(EntityType.valueOf(name));
|
||||
} catch (Throwable ex) {
|
||||
// This version of Spigot doesn't have the disguise.
|
||||
}
|
||||
}
|
||||
try {
|
||||
isVillager = Zombie.class.getMethod("isVillager");
|
||||
} catch (Throwable ignored) {
|
||||
}
|
||||
try {
|
||||
getVariant = Horse.class.getMethod("getVariant");
|
||||
} catch (Throwable ignored) {
|
||||
// Pre-1.6, but that isn't even supported
|
||||
}
|
||||
try {
|
||||
getSkeletonType = Skeleton.class.getMethod("getSkeletonType");
|
||||
} catch (Throwable ignored) {
|
||||
}
|
||||
try {
|
||||
isElder = Guardian.class.getMethod("isElder");
|
||||
} catch (Throwable ignored) {
|
||||
}
|
||||
}
|
||||
|
||||
public static DisguiseType getType(Entity entity) {
|
||||
DisguiseType disguiseType = getType(entity.getType());
|
||||
switch (disguiseType) {
|
||||
case ZOMBIE:
|
||||
try {
|
||||
if ((Boolean) isVillager.invoke(entity)) {
|
||||
disguiseType = DisguiseType.ZOMBIE_VILLAGER;
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
break;
|
||||
case HORSE:
|
||||
try {
|
||||
Object variant = getVariant.invoke(entity);
|
||||
disguiseType = DisguiseType.valueOf(((Enum) variant).name());
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
break;
|
||||
case SKELETON:
|
||||
try {
|
||||
Object type = getSkeletonType.invoke(entity);
|
||||
if (type == Skeleton.SkeletonType.WITHER) {
|
||||
disguiseType = DisguiseType.WITHER_SKELETON;
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
break;
|
||||
case GUARDIAN:
|
||||
try {
|
||||
if ((Boolean) isElder.invoke(entity)) {
|
||||
disguiseType = DisguiseType.ELDER_GUARDIAN;
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return disguiseType;
|
||||
}
|
||||
|
||||
public static DisguiseType getType(EntityType entityType) {
|
||||
try {
|
||||
return valueOf(entityType.name().toUpperCase());
|
||||
} catch (Throwable ex) {
|
||||
return DisguiseType.UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
private int objectId = -1, defaultData = 0;
|
||||
private EntityType entityType;
|
||||
private Class<? extends FlagWatcher> watcherClass;
|
||||
|
||||
DisguiseType(int... ints) {
|
||||
for (int i = 0; i < ints.length; i++) {
|
||||
int value = ints[i];
|
||||
switch (i) {
|
||||
case 0:
|
||||
objectId = value;
|
||||
break;
|
||||
case 1:
|
||||
defaultData = value;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int getDefaultData() {
|
||||
return defaultData;
|
||||
}
|
||||
|
||||
public Class<? extends Entity> getEntityClass() {
|
||||
if (entityType != null) {
|
||||
return getEntityType().getEntityClass();
|
||||
}
|
||||
return Entity.class;
|
||||
}
|
||||
|
||||
public EntityType getEntityType() {
|
||||
return entityType;
|
||||
}
|
||||
|
||||
/**
|
||||
* The TYPE id of this entity. Different from the Object Id
|
||||
* send in spawn packets when spawning miscs.
|
||||
* @return
|
||||
*/
|
||||
public int getTypeId() {
|
||||
return (int) getEntityType().getTypeId();
|
||||
}
|
||||
|
||||
/**
|
||||
* The object type send in packets when spawning a misc entity.
|
||||
* Otherwise, -1.
|
||||
* @return
|
||||
*/
|
||||
public int getObjectId() {
|
||||
return objectId;
|
||||
}
|
||||
|
||||
public Class getWatcherClass() {
|
||||
return watcherClass;
|
||||
}
|
||||
|
||||
public boolean isMisc() {
|
||||
return getEntityType() != null && !getEntityType().isAlive();
|
||||
}
|
||||
|
||||
public boolean isMob() {
|
||||
return getEntityType() != null && getEntityType().isAlive() && !isPlayer();
|
||||
}
|
||||
|
||||
public boolean isPlayer() {
|
||||
return this == DisguiseType.PLAYER;
|
||||
}
|
||||
|
||||
public boolean isUnknown() {
|
||||
return this == DisguiseType.UNKNOWN;
|
||||
}
|
||||
|
||||
private void setEntityType(EntityType entityType) {
|
||||
this.entityType = entityType;
|
||||
}
|
||||
|
||||
public void setWatcherClass(Class<? extends FlagWatcher> c) {
|
||||
watcherClass = c;
|
||||
}
|
||||
|
||||
public String toReadable() {
|
||||
String[] split = name().split("_");
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
split[i] = split[i].substring(0, 1) + split[i].substring(1).toLowerCase();
|
||||
}
|
||||
return StringUtils.join(split, " ");
|
||||
}
|
||||
}
|
||||
@@ -1,457 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import com.comphenix.protocol.PacketType.Play.Server;
|
||||
import com.comphenix.protocol.ProtocolLibrary;
|
||||
import com.comphenix.protocol.events.PacketContainer;
|
||||
import com.comphenix.protocol.reflect.StructureModifier;
|
||||
import com.comphenix.protocol.wrappers.WrappedDataWatcher;
|
||||
import com.comphenix.protocol.wrappers.WrappedWatchableObject;
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.PacketsManager;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.EntityEquipment;
|
||||
import org.bukkit.inventory.EquipmentSlot;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
|
||||
public class FlagWatcher {
|
||||
|
||||
private boolean addEntityAnimations = DisguiseConfig.isEntityAnimationsAdded();
|
||||
/**
|
||||
* These are the entity values I need to add else it could crash them..
|
||||
*/
|
||||
private HashMap<Integer, Object> backupEntityValues = new HashMap<>();
|
||||
private TargetedDisguise disguise;
|
||||
private HashMap<Integer, Object> entityValues = new HashMap<>();
|
||||
private boolean hasDied;
|
||||
public EntityEquipment equipment;
|
||||
private HashSet<Integer> modifiedEntityAnimations = new HashSet<>();
|
||||
private List<WrappedWatchableObject> watchableObjects;
|
||||
|
||||
public FlagWatcher(Disguise disguise) {
|
||||
this.disguise = (TargetedDisguise) disguise;
|
||||
equipment = ReflectionManager.createEntityEquipment(disguise.getEntity());
|
||||
}
|
||||
|
||||
private byte addEntityAnimations(byte originalValue, byte entityValue) {
|
||||
byte valueByte = originalValue;
|
||||
for (int i = 0; i < 6; i++) {
|
||||
if ((entityValue & 1 << i) != 0 && !modifiedEntityAnimations.contains(i)) {
|
||||
valueByte = (byte) (valueByte | 1 << i);
|
||||
}
|
||||
}
|
||||
originalValue = valueByte;
|
||||
return originalValue;
|
||||
}
|
||||
|
||||
public FlagWatcher clone(Disguise owningDisguise) {
|
||||
FlagWatcher cloned;
|
||||
try {
|
||||
cloned = getClass().getConstructor(Disguise.class).newInstance(getDisguise());
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
cloned = new FlagWatcher(getDisguise());
|
||||
}
|
||||
cloned.entityValues = (HashMap<Integer, Object>) entityValues.clone();
|
||||
cloned.equipment = ReflectionManager.createEntityEquipment(cloned.getDisguise().getEntity());
|
||||
cloned.modifiedEntityAnimations = (HashSet<Integer>) modifiedEntityAnimations.clone();
|
||||
cloned.addEntityAnimations = addEntityAnimations;
|
||||
return cloned;
|
||||
}
|
||||
|
||||
public List<WrappedWatchableObject> convert(List<WrappedWatchableObject> list) {
|
||||
List<WrappedWatchableObject> newList = new ArrayList<>();
|
||||
HashSet<Integer> sentValues = new HashSet<>();
|
||||
boolean sendAllCustom = false;
|
||||
for (WrappedWatchableObject watch : list) {
|
||||
int id = watch.getIndex();
|
||||
sentValues.add(id);
|
||||
// Its sending the air metadata. This is the least commonly sent metadata which all entitys still share.
|
||||
// I send my custom values if I see this!
|
||||
if (id == 1) {
|
||||
sendAllCustom = true;
|
||||
}
|
||||
Object value = null;
|
||||
if (entityValues.containsKey(id)) {
|
||||
if (entityValues.get(id) == null) {
|
||||
continue;
|
||||
}
|
||||
value = entityValues.get(id);
|
||||
} else if (backupEntityValues.containsKey(id)) {
|
||||
if (backupEntityValues.get(id) == null) {
|
||||
continue;
|
||||
}
|
||||
value = backupEntityValues.get(id);
|
||||
}
|
||||
if (value != null) {
|
||||
if (isEntityAnimationsAdded() && id == 0) {
|
||||
value = this.addEntityAnimations((byte) value, (byte) watch.getValue());
|
||||
}
|
||||
boolean isDirty = watch.getDirtyState();
|
||||
watch = new WrappedWatchableObject(ReflectionManager.createDataWatcherItem(id, value));
|
||||
if (!isDirty) {
|
||||
watch.setDirtyState(false);
|
||||
}
|
||||
} else {
|
||||
boolean isDirty = watch.getDirtyState();
|
||||
watch = new WrappedWatchableObject(ReflectionManager.createDataWatcherItem(id, watch.getValue()));
|
||||
if (!isDirty) {
|
||||
watch.setDirtyState(false);
|
||||
}
|
||||
}
|
||||
newList.add(watch);
|
||||
}
|
||||
if (sendAllCustom) {
|
||||
// Its sending the entire meta data. Better add the custom meta
|
||||
for (int id : entityValues.keySet()) {
|
||||
if (sentValues.contains(id)) {
|
||||
continue;
|
||||
}
|
||||
Object value = entityValues.get(id);
|
||||
if (value == null) {
|
||||
continue;
|
||||
}
|
||||
WrappedWatchableObject watch = new WrappedWatchableObject(ReflectionManager.createDataWatcherItem(id, value));
|
||||
newList.add(watch);
|
||||
}
|
||||
}
|
||||
// Here we check for if there is a health packet that says they died.
|
||||
if (getDisguise().isSelfDisguiseVisible() && getDisguise().getEntity() != null && getDisguise().getEntity() instanceof Player) {
|
||||
for (WrappedWatchableObject watch : newList) {
|
||||
// Its a health packet
|
||||
if (watch.getIndex() == 6) {
|
||||
Object value = watch.getValue();
|
||||
if (value != null && value instanceof Float) {
|
||||
float newHealth = (Float) value;
|
||||
if (newHealth > 0 && hasDied) {
|
||||
hasDied = false;
|
||||
DisguiseUtilities.sendSelfDisguise((Player) getDisguise().getEntity(), disguise);
|
||||
} else if (newHealth <= 0 && !hasDied) {
|
||||
hasDied = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return newList;
|
||||
}
|
||||
|
||||
public ItemStack[] getArmor() {
|
||||
ItemStack[] armor = new ItemStack[4];
|
||||
System.arraycopy(armor, 0, armor, 0, 4);
|
||||
return armor;
|
||||
}
|
||||
|
||||
public String getCustomName() {
|
||||
return (String) getValue(2, null);
|
||||
}
|
||||
|
||||
protected TargetedDisguise getDisguise() {
|
||||
return disguise;
|
||||
}
|
||||
|
||||
private boolean getEntityFlag(int byteValue) {
|
||||
return ((byte) getValue(0, (byte) 0) & 1 << byteValue) != 0;
|
||||
}
|
||||
|
||||
public ItemStack getItemInMainHand() {
|
||||
if (equipment == null) return null;
|
||||
return equipment.getItemInMainHand();
|
||||
}
|
||||
|
||||
public ItemStack getItemInOffHand() {
|
||||
if (equipment == null) return null;
|
||||
return equipment.getItemInOffHand();
|
||||
}
|
||||
|
||||
public EntityEquipment getEquipment() {
|
||||
return equipment;
|
||||
}
|
||||
|
||||
protected Object getValue(int no, Object backup) {
|
||||
if (entityValues.containsKey(no)) {
|
||||
return entityValues.get(no);
|
||||
}
|
||||
return backup;
|
||||
}
|
||||
|
||||
public List<WrappedWatchableObject> getWatchableObjects() {
|
||||
if (watchableObjects == null) {
|
||||
rebuildWatchableObjects();
|
||||
}
|
||||
return watchableObjects;
|
||||
}
|
||||
|
||||
public boolean hasCustomName() {
|
||||
return getCustomName() != null;
|
||||
}
|
||||
|
||||
protected boolean hasValue(int no) {
|
||||
return entityValues.containsKey(no);
|
||||
}
|
||||
|
||||
public boolean isCustomNameVisible() {
|
||||
return (boolean) getValue(3, false);
|
||||
}
|
||||
|
||||
public boolean isEntityAnimationsAdded() {
|
||||
return addEntityAnimations;
|
||||
}
|
||||
|
||||
public boolean isBurning() {
|
||||
return getEntityFlag(0);
|
||||
}
|
||||
|
||||
public boolean isSneaking() {
|
||||
return getEntityFlag(1);
|
||||
}
|
||||
|
||||
public boolean isSprinting() {
|
||||
return getEntityFlag(3);
|
||||
}
|
||||
|
||||
public boolean isRightClicking() {
|
||||
return getEntityFlag(4);
|
||||
}
|
||||
|
||||
public boolean isInvisible() {
|
||||
return getEntityFlag(5);
|
||||
}
|
||||
|
||||
public boolean isGlowing() {
|
||||
return getEntityFlag(6);
|
||||
}
|
||||
|
||||
public boolean isFlyingWithElytra() {
|
||||
return getEntityFlag(7);
|
||||
}
|
||||
|
||||
public void rebuildWatchableObjects() {
|
||||
watchableObjects = new ArrayList<>();
|
||||
for (int i = 0; i <= 31; i++) {
|
||||
WrappedWatchableObject watchable = null;
|
||||
if (this.entityValues.containsKey(i) && this.entityValues.get(i) != null) {
|
||||
watchable = new WrappedWatchableObject(ReflectionManager.createDataWatcherItem(i, entityValues.get(i)));
|
||||
} else if (this.backupEntityValues.containsKey(i) && this.backupEntityValues.get(i) != null) {
|
||||
watchable = new WrappedWatchableObject(ReflectionManager.createDataWatcherItem(i, entityValues.get(i)));
|
||||
}
|
||||
if (watchable != null) {
|
||||
watchableObjects.add(watchable);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void sendData(int... dataValues) {
|
||||
if (!DisguiseAPI.isDisguiseInUse(getDisguise()) || getDisguise().getWatcher() != this) {
|
||||
return;
|
||||
}
|
||||
List<WrappedWatchableObject> list = new ArrayList<>();
|
||||
for (int data : dataValues) {
|
||||
if (!entityValues.containsKey(data) || entityValues.get(data) == null) {
|
||||
continue;
|
||||
}
|
||||
Object value = entityValues.get(data);
|
||||
if (isEntityAnimationsAdded() && DisguiseConfig.isMetadataPacketsEnabled() && data == 0) {
|
||||
if (!PacketsManager.isStaticMetadataDisguiseType(disguise))
|
||||
value = addEntityAnimations((byte) value, WrappedDataWatcher.getEntityWatcher(disguise.getEntity()).getByte(0));
|
||||
}
|
||||
WrappedWatchableObject watch = new WrappedWatchableObject(ReflectionManager.createDataWatcherItem(data, value));
|
||||
list.add(watch);
|
||||
}
|
||||
if (!list.isEmpty()) {
|
||||
PacketContainer packet = new PacketContainer(Server.ENTITY_METADATA);
|
||||
StructureModifier<Object> mods = packet.getModifier();
|
||||
mods.write(0, getDisguise().getEntity().getEntityId());
|
||||
packet.getWatchableCollectionModifier().write(0, list);
|
||||
for (Player player : DisguiseUtilities.getPerverts(getDisguise())) {
|
||||
try {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void setAddEntityAnimations(boolean isEntityAnimationsAdded) {
|
||||
this.addEntityAnimations = isEntityAnimationsAdded;
|
||||
}
|
||||
|
||||
public void setArmor(ItemStack[] itemstack) {
|
||||
setItemStack(EquipmentSlot.HEAD, itemstack[0]);
|
||||
setItemStack(EquipmentSlot.CHEST, itemstack[1]);
|
||||
setItemStack(EquipmentSlot.LEGS, itemstack[2]);
|
||||
setItemStack(EquipmentSlot.FEET, itemstack[3]);
|
||||
}
|
||||
|
||||
protected void setBackupValue(int no, Object value) {
|
||||
backupEntityValues.put(no, value);
|
||||
}
|
||||
|
||||
public void setBurning(boolean setBurning) {
|
||||
setEntityFlag(0, setBurning);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
public void setCustomName(String name) {
|
||||
if (name != null && name.length() > 64) {
|
||||
name = name.substring(0, 64);
|
||||
}
|
||||
setValue(2, name);
|
||||
sendData(2);
|
||||
}
|
||||
|
||||
public void setCustomNameVisible(boolean display) {
|
||||
setValue(3, display);
|
||||
sendData(3);
|
||||
}
|
||||
|
||||
private void setEntityFlag(int byteValue, boolean flag) {
|
||||
modifiedEntityAnimations.add(byteValue);
|
||||
byte b0 = (byte) getValue(0, (byte) 0);
|
||||
if (flag) {
|
||||
setValue(0, (byte) (b0 | 1 << byteValue));
|
||||
} else {
|
||||
setValue(0, (byte) (b0 & ~(1 << byteValue)));
|
||||
}
|
||||
}
|
||||
|
||||
public void setInvisible(boolean setInvis) {
|
||||
setEntityFlag(5, setInvis);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
public void setGlowing(boolean glowing) {
|
||||
setEntityFlag(6, glowing);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
public void setFlyingWithElytra(boolean flying) {
|
||||
setEntityFlag(7, flying);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Don't use this, use setItemInMainHand instead
|
||||
*
|
||||
* @param itemstack
|
||||
*/
|
||||
@Deprecated
|
||||
public void setItemInHand(ItemStack itemstack) {
|
||||
setItemInMainHand(itemstack);
|
||||
}
|
||||
|
||||
public void setItemInMainHand(ItemStack itemstack) {
|
||||
setItemStack(EquipmentSlot.HAND, itemstack);
|
||||
}
|
||||
|
||||
public void setItemInOffHand(ItemStack itemstack) {
|
||||
setItemStack(EquipmentSlot.OFF_HAND, itemstack);
|
||||
}
|
||||
|
||||
public void setItemStack(EquipmentSlot slot, ItemStack itemStack) {
|
||||
if (equipment == null) return;
|
||||
// Itemstack which is null means that its not replacing the disguises itemstack.
|
||||
if (itemStack == null) {
|
||||
// Find the item to replace it with
|
||||
if (getDisguise().getEntity() instanceof LivingEntity) {
|
||||
EntityEquipment equipment = ((LivingEntity) getDisguise().getEntity()).getEquipment();
|
||||
setItemStack(equipment, slot, itemStack);
|
||||
}
|
||||
}
|
||||
Object itemToSend = null;
|
||||
if (itemStack != null && itemStack.getTypeId() != 0) {
|
||||
itemToSend = ReflectionManager.getNmsItem(itemStack);
|
||||
}
|
||||
setItemStack(equipment, slot, itemStack);
|
||||
if (DisguiseAPI.isDisguiseInUse(getDisguise()) && getDisguise().getWatcher() == this) {
|
||||
PacketContainer packet = new PacketContainer(Server.ENTITY_EQUIPMENT);
|
||||
StructureModifier<Object> mods = packet.getModifier();
|
||||
mods.write(0, getDisguise().getEntity().getEntityId());
|
||||
mods.write(1, ReflectionManager.createEnumItemSlot(slot));
|
||||
mods.write(2, itemToSend);
|
||||
for (Player player : DisguiseUtilities.getPerverts(getDisguise())) {
|
||||
try {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void setItemStack(EntityEquipment equipment, EquipmentSlot slot, ItemStack itemStack) {
|
||||
if (equipment == null) return;
|
||||
switch (slot) {
|
||||
case CHEST:
|
||||
equipment.setChestplate(itemStack);
|
||||
break;
|
||||
case FEET:
|
||||
equipment.setBoots(itemStack);
|
||||
break;
|
||||
case HAND:
|
||||
equipment.setItemInMainHand(itemStack);
|
||||
break;
|
||||
case HEAD:
|
||||
equipment.setHelmet(itemStack);
|
||||
break;
|
||||
case LEGS:
|
||||
equipment.setLeggings(itemStack);
|
||||
break;
|
||||
case OFF_HAND:
|
||||
equipment.setItemInOffHand(itemStack);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public ItemStack getItemStack(EquipmentSlot slot) {
|
||||
if (equipment == null) return null;
|
||||
switch (slot) {
|
||||
case CHEST:
|
||||
return equipment.getChestplate();
|
||||
case FEET:
|
||||
return equipment.getBoots();
|
||||
case HAND:
|
||||
return equipment.getItemInMainHand();
|
||||
case HEAD:
|
||||
return equipment.getHelmet();
|
||||
case LEGS:
|
||||
return equipment.getLeggings();
|
||||
case OFF_HAND:
|
||||
return equipment.getItemInOffHand();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public void setRightClicking(boolean setRightClicking) {
|
||||
setEntityFlag(4, setRightClicking);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
public void setSneaking(boolean setSneaking) {
|
||||
setEntityFlag(1, setSneaking);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
public void setSprinting(boolean setSprinting) {
|
||||
setEntityFlag(3, setSprinting);
|
||||
sendData(0);
|
||||
}
|
||||
|
||||
protected void setValue(int id, Object value) {
|
||||
entityValues.put(id, value);
|
||||
if (!DisguiseConfig.isMetadataPacketsEnabled()) {
|
||||
this.rebuildWatchableObjects();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,206 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.DroppedItemWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.FallingBlockWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.PaintingWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.SplashPotionWatcher;
|
||||
import org.bukkit.Art;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.security.InvalidParameterException;
|
||||
|
||||
public class MiscDisguise extends TargetedDisguise {
|
||||
|
||||
private int id = -1, data = 0;
|
||||
|
||||
public MiscDisguise(DisguiseType disguiseType) {
|
||||
this(disguiseType, -1, disguiseType.getDefaultData());
|
||||
}
|
||||
|
||||
public MiscDisguise(DisguiseType disguiseType, int id) {
|
||||
this(disguiseType, id, disguiseType.getDefaultData());
|
||||
}
|
||||
|
||||
public MiscDisguise(DisguiseType disguiseType, int id, int data) {
|
||||
if (!disguiseType.isMisc()) {
|
||||
throw new InvalidParameterException("Expected a non-living DisguiseType while constructing MiscDisguise. Received "
|
||||
+ disguiseType + " instead. Please use " + (disguiseType.isPlayer() ? "PlayerDisguise" : "MobDisguise")
|
||||
+ " instead");
|
||||
}
|
||||
createDisguise(disguiseType);
|
||||
this.id = getType().getTypeId();
|
||||
this.data = getType().getDefaultData();
|
||||
switch (disguiseType) {
|
||||
// The only disguises which should use a custom data.
|
||||
case PAINTING:
|
||||
((PaintingWatcher) getWatcher()).setArt(Art.values()[Math.max(0, id) % Art.values().length]);
|
||||
break;
|
||||
case FALLING_BLOCK:
|
||||
((FallingBlockWatcher) getWatcher()).setBlock(new ItemStack(Math.max(1, id), 1, (short) Math.max(0,
|
||||
data)));
|
||||
break;
|
||||
case SPLASH_POTION:
|
||||
((SplashPotionWatcher) getWatcher()).setPotionId(Math.max(0, id));
|
||||
break;
|
||||
case DROPPED_ITEM:
|
||||
if (id > 0) {
|
||||
((DroppedItemWatcher) getWatcher()).setItemStack(new ItemStack(id, Math.max(0, data)));
|
||||
}
|
||||
break;
|
||||
case FISHING_HOOK: // Entity ID of whoever is holding fishing rod
|
||||
case ARROW:
|
||||
case TIPPED_ARROW: // Entity ID of shooter. Used for "Is he on this scoreboard team and do I render it moving through his body?"
|
||||
case SPECTRAL_ARROW:
|
||||
case SMALL_FIREBALL: // Unknown. Uses entity id of shooter. 0 if no shooter
|
||||
case FIREBALL: // Unknown. Uses entity id of shooter. 0 if no shooter
|
||||
case WITHER_SKULL: // Unknown. Uses entity id of shooter. 0 if no shooter
|
||||
this.data = id;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise addPlayer(Player player) {
|
||||
return (MiscDisguise) super.addPlayer(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise addPlayer(String playername) {
|
||||
return (MiscDisguise) super.addPlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise clone() {
|
||||
MiscDisguise disguise = new MiscDisguise(getType(), getData());
|
||||
disguise.setReplaceSounds(isSoundsReplaced());
|
||||
disguise.setViewSelfDisguise(isSelfDisguiseVisible());
|
||||
disguise.setHearSelfDisguise(isSelfDisguiseSoundsReplaced());
|
||||
disguise.setHideArmorFromSelf(isHidingArmorFromSelf());
|
||||
disguise.setHideHeldItemFromSelf(isHidingHeldItemFromSelf());
|
||||
disguise.setVelocitySent(isVelocitySent());
|
||||
disguise.setModifyBoundingBox(isModifyBoundingBox());
|
||||
disguise.setWatcher(getWatcher().clone(disguise));
|
||||
return disguise;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is the getId of everything but falling block.
|
||||
*/
|
||||
public int getData() {
|
||||
switch (getType()) {
|
||||
case FALLING_BLOCK:
|
||||
return (int) ((FallingBlockWatcher) getWatcher()).getBlock().getDurability();
|
||||
case PAINTING:
|
||||
return ((PaintingWatcher) getWatcher()).getArt().getId();
|
||||
case SPLASH_POTION:
|
||||
return ((SplashPotionWatcher) getWatcher()).getPotionId();
|
||||
default:
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Only falling block should use this
|
||||
*/
|
||||
public int getId() {
|
||||
if (getType() == DisguiseType.FALLING_BLOCK) {
|
||||
return ((FallingBlockWatcher) getWatcher()).getBlock().getTypeId();
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isMiscDisguise() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise removePlayer(Player player) {
|
||||
return (MiscDisguise) super.removePlayer(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise removePlayer(String playername) {
|
||||
return (MiscDisguise) super.removePlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setDisguiseTarget(TargetType newTargetType) {
|
||||
return (MiscDisguise) super.setDisguiseTarget(newTargetType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setEntity(Entity entity) {
|
||||
return (MiscDisguise) super.setEntity(entity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setHearSelfDisguise(boolean hearSelfDisguise) {
|
||||
return (MiscDisguise) super.setHearSelfDisguise(hearSelfDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setHideArmorFromSelf(boolean hideArmor) {
|
||||
return (MiscDisguise) super.setHideArmorFromSelf(hideArmor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setHideHeldItemFromSelf(boolean hideHeldItem) {
|
||||
return (MiscDisguise) super.setHideHeldItemFromSelf(hideHeldItem);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setKeepDisguiseOnEntityDespawn(boolean keepDisguise) {
|
||||
return (MiscDisguise) super.setKeepDisguiseOnEntityDespawn(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setKeepDisguiseOnPlayerDeath(boolean keepDisguise) {
|
||||
return (MiscDisguise) super.setKeepDisguiseOnPlayerDeath(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setKeepDisguiseOnPlayerLogout(boolean keepDisguise) {
|
||||
return (MiscDisguise) super.setKeepDisguiseOnPlayerLogout(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setModifyBoundingBox(boolean modifyBox) {
|
||||
return (MiscDisguise) super.setModifyBoundingBox(modifyBox);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setReplaceSounds(boolean areSoundsReplaced) {
|
||||
return (MiscDisguise) super.setReplaceSounds(areSoundsReplaced);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setVelocitySent(boolean sendVelocity) {
|
||||
return (MiscDisguise) super.setVelocitySent(sendVelocity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setViewSelfDisguise(boolean viewSelfDisguise) {
|
||||
return (MiscDisguise) super.setViewSelfDisguise(viewSelfDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise setWatcher(FlagWatcher newWatcher) {
|
||||
return (MiscDisguise) super.setWatcher(newWatcher);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise silentlyAddPlayer(String playername) {
|
||||
return (MiscDisguise) super.silentlyAddPlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MiscDisguise silentlyRemovePlayer(String playername) {
|
||||
return (MiscDisguise) super.silentlyRemovePlayer(playername);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,187 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import java.security.InvalidParameterException;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.AgeableWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.ZombieWatcher;
|
||||
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class MobDisguise extends TargetedDisguise {
|
||||
|
||||
private boolean isAdult;
|
||||
|
||||
public MobDisguise(DisguiseType disguiseType) {
|
||||
this(disguiseType, true);
|
||||
}
|
||||
|
||||
public MobDisguise(DisguiseType disguiseType, boolean isAdult) {
|
||||
if (!disguiseType.isMob()) {
|
||||
throw new InvalidParameterException("Expected a living DisguiseType while constructing MobDisguise. Received "
|
||||
+ disguiseType + " instead. Please use " + (disguiseType.isPlayer() ? "PlayerDisguise" : "MiscDisguise")
|
||||
+ " instead");
|
||||
}
|
||||
this.isAdult = isAdult;
|
||||
createDisguise(disguiseType);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public MobDisguise(DisguiseType disguiseType, boolean isAdult, boolean replaceSounds) {
|
||||
this(disguiseType, isAdult);
|
||||
this.setReplaceSounds(replaceSounds);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public MobDisguise(EntityType entityType) {
|
||||
this(entityType, true);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public MobDisguise(EntityType entityType, boolean isAdult) {
|
||||
this(DisguiseType.getType(entityType), isAdult);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public MobDisguise(EntityType entityType, boolean isAdult, boolean replaceSounds) {
|
||||
this(entityType, isAdult);
|
||||
this.setReplaceSounds(replaceSounds);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise addPlayer(Player player) {
|
||||
return (MobDisguise) super.addPlayer(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise addPlayer(String playername) {
|
||||
return (MobDisguise) super.addPlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise clone() {
|
||||
MobDisguise disguise = new MobDisguise(getType(), isAdult());
|
||||
disguise.setReplaceSounds(isSoundsReplaced());
|
||||
disguise.setViewSelfDisguise(isSelfDisguiseVisible());
|
||||
disguise.setHearSelfDisguise(isSelfDisguiseSoundsReplaced());
|
||||
disguise.setHideArmorFromSelf(isHidingArmorFromSelf());
|
||||
disguise.setHideHeldItemFromSelf(isHidingHeldItemFromSelf());
|
||||
disguise.setVelocitySent(isVelocitySent());
|
||||
disguise.setModifyBoundingBox(isModifyBoundingBox());
|
||||
disguise.setWatcher(getWatcher().clone(disguise));
|
||||
return disguise;
|
||||
}
|
||||
|
||||
public boolean doesDisguiseAge() {
|
||||
return getWatcher() != null && (getWatcher() instanceof AgeableWatcher || getWatcher() instanceof ZombieWatcher);
|
||||
}
|
||||
|
||||
@Override
|
||||
public LivingWatcher getWatcher() {
|
||||
return (LivingWatcher) super.getWatcher();
|
||||
}
|
||||
|
||||
public boolean isAdult() {
|
||||
if (getWatcher() != null) {
|
||||
if (getWatcher() instanceof AgeableWatcher) {
|
||||
return ((AgeableWatcher) getWatcher()).isAdult();
|
||||
} else if (getWatcher() instanceof ZombieWatcher) {
|
||||
return ((ZombieWatcher) getWatcher()).isAdult();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return isAdult;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isMobDisguise() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise removePlayer(Player player) {
|
||||
return (MobDisguise) super.removePlayer(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise removePlayer(String playername) {
|
||||
return (MobDisguise) super.removePlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setDisguiseTarget(TargetType newTargetType) {
|
||||
return (MobDisguise) super.setDisguiseTarget(newTargetType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setEntity(Entity entity) {
|
||||
return (MobDisguise) super.setEntity(entity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setHearSelfDisguise(boolean hearSelfDisguise) {
|
||||
return (MobDisguise) super.setHearSelfDisguise(hearSelfDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setHideArmorFromSelf(boolean hideArmor) {
|
||||
return (MobDisguise) super.setHideArmorFromSelf(hideArmor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setHideHeldItemFromSelf(boolean hideHeldItem) {
|
||||
return (MobDisguise) super.setHideHeldItemFromSelf(hideHeldItem);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setKeepDisguiseOnEntityDespawn(boolean keepDisguise) {
|
||||
return (MobDisguise) super.setKeepDisguiseOnEntityDespawn(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setKeepDisguiseOnPlayerDeath(boolean keepDisguise) {
|
||||
return (MobDisguise) super.setKeepDisguiseOnPlayerDeath(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setKeepDisguiseOnPlayerLogout(boolean keepDisguise) {
|
||||
return (MobDisguise) super.setKeepDisguiseOnPlayerLogout(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setModifyBoundingBox(boolean modifyBox) {
|
||||
return (MobDisguise) super.setModifyBoundingBox(modifyBox);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setReplaceSounds(boolean areSoundsReplaced) {
|
||||
return (MobDisguise) super.setReplaceSounds(areSoundsReplaced);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setVelocitySent(boolean sendVelocity) {
|
||||
return (MobDisguise) super.setVelocitySent(sendVelocity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setViewSelfDisguise(boolean viewSelfDisguise) {
|
||||
return (MobDisguise) super.setViewSelfDisguise(viewSelfDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise setWatcher(FlagWatcher newWatcher) {
|
||||
return (MobDisguise) super.setWatcher(newWatcher);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise silentlyAddPlayer(String playername) {
|
||||
return (MobDisguise) super.silentlyAddPlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MobDisguise silentlyRemovePlayer(String playername) {
|
||||
return (MobDisguise) super.silentlyRemovePlayer(playername);
|
||||
}
|
||||
}
|
||||
@@ -1,242 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
||||
import me.libraryaddict.disguise.LibsDisguises;
|
||||
import me.libraryaddict.disguise.disguisetypes.watchers.PlayerWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.LibsProfileLookup;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class PlayerDisguise extends TargetedDisguise {
|
||||
|
||||
private LibsProfileLookup currentLookup;
|
||||
private WrappedGameProfile gameProfile;
|
||||
private String playerName;
|
||||
private String skinToUse;
|
||||
|
||||
public PlayerDisguise(String name) {
|
||||
if (name.length() > 16) {
|
||||
name = name.substring(0, 16);
|
||||
}
|
||||
playerName = name;
|
||||
createDisguise(DisguiseType.PLAYER);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public PlayerDisguise(String name, boolean replaceSounds) {
|
||||
this(name);
|
||||
this.setReplaceSounds(replaceSounds);
|
||||
}
|
||||
|
||||
public PlayerDisguise(String name, String skinToUse) {
|
||||
this(name);
|
||||
setSkin(skinToUse);
|
||||
}
|
||||
|
||||
public PlayerDisguise(WrappedGameProfile gameProfile) {
|
||||
this(gameProfile.getName());
|
||||
this.gameProfile = gameProfile;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise addPlayer(Player player) {
|
||||
return (PlayerDisguise) super.addPlayer(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise addPlayer(String playername) {
|
||||
return (PlayerDisguise) super.addPlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise clone() {
|
||||
PlayerDisguise disguise = new PlayerDisguise(getName());
|
||||
if (disguise.currentLookup == null && disguise.gameProfile != null) {
|
||||
disguise.skinToUse = getSkin();
|
||||
disguise.gameProfile = gameProfile;
|
||||
} else {
|
||||
disguise.setSkin(getSkin());
|
||||
}
|
||||
disguise.setReplaceSounds(isSoundsReplaced());
|
||||
disguise.setViewSelfDisguise(isSelfDisguiseVisible());
|
||||
disguise.setHearSelfDisguise(isSelfDisguiseSoundsReplaced());
|
||||
disguise.setHideArmorFromSelf(isHidingArmorFromSelf());
|
||||
disguise.setHideHeldItemFromSelf(isHidingHeldItemFromSelf());
|
||||
disguise.setVelocitySent(isVelocitySent());
|
||||
disguise.setModifyBoundingBox(isModifyBoundingBox());
|
||||
disguise.setWatcher(getWatcher().clone(disguise));
|
||||
return disguise;
|
||||
}
|
||||
|
||||
public void setGameProfile(WrappedGameProfile gameProfile) {
|
||||
this.gameProfile = ReflectionManager.getGameProfileWithThisSkin(null, gameProfile.getName(), gameProfile);
|
||||
}
|
||||
|
||||
public WrappedGameProfile getGameProfile() {
|
||||
if (gameProfile == null) {
|
||||
if (getSkin() != null) {
|
||||
gameProfile = ReflectionManager.getGameProfile(null, getName());
|
||||
} else {
|
||||
gameProfile = ReflectionManager.getGameProfileWithThisSkin(null, getName(), DisguiseUtilities.getProfileFromMojang(this));
|
||||
}
|
||||
}
|
||||
return gameProfile;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return playerName;
|
||||
}
|
||||
|
||||
public String getSkin() {
|
||||
return skinToUse;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerWatcher getWatcher() {
|
||||
return (PlayerWatcher) super.getWatcher();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isPlayerDisguise() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise removePlayer(Player player) {
|
||||
return (PlayerDisguise) super.removePlayer(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise removePlayer(String playername) {
|
||||
return (PlayerDisguise) super.removePlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setDisguiseTarget(TargetType newTargetType) {
|
||||
return (PlayerDisguise) super.setDisguiseTarget(newTargetType);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setEntity(Entity entity) {
|
||||
return (PlayerDisguise) super.setEntity(entity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setHearSelfDisguise(boolean hearSelfDisguise) {
|
||||
return (PlayerDisguise) super.setHearSelfDisguise(hearSelfDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setHideArmorFromSelf(boolean hideArmor) {
|
||||
return (PlayerDisguise) super.setHideArmorFromSelf(hideArmor);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setHideHeldItemFromSelf(boolean hideHeldItem) {
|
||||
return (PlayerDisguise) super.setHideHeldItemFromSelf(hideHeldItem);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setKeepDisguiseOnEntityDespawn(boolean keepDisguise) {
|
||||
return (PlayerDisguise) super.setKeepDisguiseOnEntityDespawn(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setKeepDisguiseOnPlayerDeath(boolean keepDisguise) {
|
||||
return (PlayerDisguise) super.setKeepDisguiseOnPlayerDeath(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setKeepDisguiseOnPlayerLogout(boolean keepDisguise) {
|
||||
return (PlayerDisguise) super.setKeepDisguiseOnPlayerLogout(keepDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setModifyBoundingBox(boolean modifyBox) {
|
||||
return (PlayerDisguise) super.setModifyBoundingBox(modifyBox);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setReplaceSounds(boolean areSoundsReplaced) {
|
||||
return (PlayerDisguise) super.setReplaceSounds(areSoundsReplaced);
|
||||
}
|
||||
|
||||
public PlayerDisguise setSkin(String skinToUse) {
|
||||
this.skinToUse = skinToUse;
|
||||
if (skinToUse == null) {
|
||||
this.currentLookup = null;
|
||||
this.gameProfile = null;
|
||||
} else {
|
||||
if (skinToUse.length() > 16) {
|
||||
this.skinToUse = skinToUse.substring(0, 16);
|
||||
}
|
||||
if (LibsDisguises.getInstance().getConfig().getBoolean("ContactMojangServers", true)) {
|
||||
currentLookup = new LibsProfileLookup() {
|
||||
@Override
|
||||
public void onLookup(WrappedGameProfile gameProfile) {
|
||||
if (currentLookup == this && gameProfile != null) {
|
||||
setSkin(gameProfile);
|
||||
if (!gameProfile.getProperties().isEmpty() && DisguiseUtilities.isDisguiseInUse(PlayerDisguise.this)) {
|
||||
DisguiseUtilities.refreshTrackers(PlayerDisguise.this);
|
||||
}
|
||||
currentLookup = null;
|
||||
}
|
||||
}
|
||||
};
|
||||
WrappedGameProfile gameProfile = DisguiseUtilities.getProfileFromMojang(this.skinToUse, currentLookup);
|
||||
if (gameProfile != null) {
|
||||
setSkin(gameProfile);
|
||||
}
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the GameProfile, without tampering.
|
||||
*
|
||||
* @param gameProfile GameProfile
|
||||
* @return
|
||||
*/
|
||||
public PlayerDisguise setSkin(WrappedGameProfile gameProfile) {
|
||||
if (gameProfile == null) {
|
||||
this.gameProfile = null;
|
||||
this.skinToUse = null;
|
||||
return this;
|
||||
}
|
||||
if (LibsDisguises.getInstance().getConfig().getBoolean("ContactMojangServers", true)) {
|
||||
Validate.notEmpty(gameProfile.getName(), "Name must be set");
|
||||
this.skinToUse = gameProfile.getName();
|
||||
this.gameProfile = ReflectionManager.getGameProfileWithThisSkin(null, getName(), gameProfile);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setVelocitySent(boolean sendVelocity) {
|
||||
return (PlayerDisguise) super.setVelocitySent(sendVelocity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setViewSelfDisguise(boolean viewSelfDisguise) {
|
||||
return (PlayerDisguise) super.setViewSelfDisguise(viewSelfDisguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise setWatcher(FlagWatcher newWatcher) {
|
||||
return (PlayerDisguise) super.setWatcher(newWatcher);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise silentlyAddPlayer(String playername) {
|
||||
return (PlayerDisguise) super.silentlyAddPlayer(playername);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerDisguise silentlyRemovePlayer(String playername) {
|
||||
return (PlayerDisguise) super.silentlyRemovePlayer(playername);
|
||||
}
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
public enum RabbitType {
|
||||
|
||||
BLACK(2), BROWN(0), GOLD(4), KILLER_BUNNY(99), PATCHES(3), PEPPER(5), WHITE(1);
|
||||
|
||||
public static RabbitType getType(int id) {
|
||||
for (RabbitType type : values()) {
|
||||
if (type.getTypeId() == id) {
|
||||
return type;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private int type;
|
||||
|
||||
RabbitType(int type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public int getTypeId() {
|
||||
return type;
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public abstract class TargetedDisguise extends Disguise {
|
||||
|
||||
public enum TargetType {
|
||||
HIDE_DISGUISE_TO_EVERYONE_BUT_THESE_PLAYERS, SHOW_TO_EVERYONE_BUT_THESE_PLAYERS
|
||||
}
|
||||
|
||||
private List<String> disguiseViewers = new ArrayList<>();
|
||||
private TargetType targetType = TargetType.SHOW_TO_EVERYONE_BUT_THESE_PLAYERS;
|
||||
|
||||
public TargetedDisguise addPlayer(Player player) {
|
||||
addPlayer(player.getName());
|
||||
return this;
|
||||
}
|
||||
|
||||
public TargetedDisguise addPlayer(String playername) {
|
||||
if (!disguiseViewers.contains(playername)) {
|
||||
disguiseViewers.add(playername);
|
||||
if (DisguiseAPI.isDisguiseInUse(this)) {
|
||||
DisguiseUtilities.checkConflicts(this, playername);
|
||||
DisguiseUtilities.refreshTracker(this, playername);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean canSee(Player player) {
|
||||
return canSee(player.getName());
|
||||
}
|
||||
|
||||
public boolean canSee(String playername) {
|
||||
boolean hasPlayer = disguiseViewers.contains(playername);
|
||||
if (targetType == TargetType.SHOW_TO_EVERYONE_BUT_THESE_PLAYERS) {
|
||||
return !hasPlayer;
|
||||
}
|
||||
return hasPlayer;
|
||||
}
|
||||
|
||||
public TargetType getDisguiseTarget() {
|
||||
return targetType;
|
||||
}
|
||||
|
||||
public List<String> getObservers() {
|
||||
return Collections.unmodifiableList(disguiseViewers);
|
||||
}
|
||||
|
||||
public TargetedDisguise removePlayer(Player player) {
|
||||
removePlayer(player.getName());
|
||||
return this;
|
||||
}
|
||||
|
||||
public TargetedDisguise removePlayer(String playername) {
|
||||
if (disguiseViewers.contains(playername)) {
|
||||
disguiseViewers.remove(playername);
|
||||
if (DisguiseAPI.isDisguiseInUse(this)) {
|
||||
DisguiseUtilities.checkConflicts(this, playername);
|
||||
DisguiseUtilities.refreshTracker(this, playername);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public TargetedDisguise setDisguiseTarget(TargetType newTargetType) {
|
||||
if (DisguiseUtilities.isDisguiseInUse(this)) {
|
||||
throw new RuntimeException("Cannot set the disguise target after the entity has been disguised");
|
||||
}
|
||||
targetType = newTargetType;
|
||||
return this;
|
||||
}
|
||||
|
||||
public TargetedDisguise silentlyAddPlayer(String playername) {
|
||||
if (!disguiseViewers.contains(playername)) {
|
||||
disguiseViewers.add(playername);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public TargetedDisguise silentlyRemovePlayer(String playername) {
|
||||
if (disguiseViewers.contains(playername)) {
|
||||
disguiseViewers.remove(playername);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.entity.Entity;
|
||||
|
||||
public class AgeableWatcher extends LivingWatcher {
|
||||
|
||||
public AgeableWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
Entity e;
|
||||
|
||||
}
|
||||
|
||||
public boolean isAdult() {
|
||||
return !isBaby();
|
||||
}
|
||||
|
||||
public boolean isBaby() {
|
||||
return (boolean) getValue(11, false);
|
||||
}
|
||||
|
||||
public void setAdult() {
|
||||
setBaby(false);
|
||||
}
|
||||
|
||||
public void setBaby() {
|
||||
setBaby(true);
|
||||
}
|
||||
|
||||
public void setBaby(boolean isBaby) {
|
||||
setValue(11, isBaby);
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
|
||||
import java.awt.*;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
public class AreaEffectCloudWatcher extends FlagWatcher {
|
||||
|
||||
public AreaEffectCloudWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public float getRadius() {
|
||||
return (float) getValue(5, 0f);
|
||||
}
|
||||
|
||||
public int getColor() {
|
||||
return (int) getValue(6, Color.BLACK.getRGB());
|
||||
}
|
||||
|
||||
public boolean isIgnoreRadius() {
|
||||
return (boolean) getValue(7, false);
|
||||
}
|
||||
|
||||
public int getParticleId() {
|
||||
return (int) getValue(8, 0);
|
||||
}
|
||||
|
||||
public void setRadius(float radius) {
|
||||
setValue(5, radius);
|
||||
}
|
||||
|
||||
public void setColor(int color) {
|
||||
setValue(6, color);
|
||||
}
|
||||
|
||||
public void setIgnoreRadius(boolean ignore) {
|
||||
setValue(7, ignore);
|
||||
}
|
||||
|
||||
public void setParticleId(int particleId) {
|
||||
setValue(8, particleId);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
public class ArmorStandWatcher extends LivingWatcher {
|
||||
|
||||
public ArmorStandWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
private boolean getArmorStandFlag(int value) {
|
||||
return ((byte) getValue(10, 0) & value) != 0;
|
||||
}
|
||||
|
||||
public boolean isNoBasePlate() {
|
||||
return getArmorStandFlag(8);
|
||||
}
|
||||
|
||||
public boolean isNoGravity() {
|
||||
return getArmorStandFlag(2);
|
||||
}
|
||||
|
||||
public boolean isShowArms() {
|
||||
return getArmorStandFlag(4);
|
||||
}
|
||||
|
||||
public boolean isSmall() {
|
||||
return getArmorStandFlag(1);
|
||||
}
|
||||
|
||||
public boolean isMarker() {
|
||||
return getArmorStandFlag(10);
|
||||
}
|
||||
|
||||
private void setArmorStandFlag(int value, boolean isTrue) {
|
||||
byte b1 = (byte) getValue(10, (byte) 0);
|
||||
if (isTrue) {
|
||||
b1 = (byte) (b1 | value);
|
||||
} else {
|
||||
b1 = (byte) (b1 & value);
|
||||
}
|
||||
setValue(10, b1);
|
||||
sendData(10);
|
||||
}
|
||||
|
||||
public void setNoBasePlate(boolean noBasePlate) {
|
||||
setArmorStandFlag(8, noBasePlate);
|
||||
sendData(10);
|
||||
}
|
||||
|
||||
public void setNoGravity(boolean noGravity) {
|
||||
setArmorStandFlag(2, noGravity);
|
||||
sendData(10);
|
||||
}
|
||||
|
||||
public void setShowArms(boolean showArms) {
|
||||
setArmorStandFlag(4, showArms);
|
||||
sendData(10);
|
||||
}
|
||||
|
||||
public void setSmall(boolean isSmall) {
|
||||
setArmorStandFlag(1, isSmall);
|
||||
sendData(10);
|
||||
}
|
||||
|
||||
public void setMarker(boolean isMarker) {
|
||||
setArmorStandFlag(10, isMarker);
|
||||
sendData(10);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
|
||||
public class ArrowWatcher extends FlagWatcher {
|
||||
|
||||
public ArrowWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isCritical() {
|
||||
return (byte) getValue(5, (byte) 0) == 1;
|
||||
}
|
||||
|
||||
public void setCritical(boolean critical) {
|
||||
setValue(5, (byte) (critical ? 1 : 0));
|
||||
sendData(5);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
public class BatWatcher extends LivingWatcher {
|
||||
|
||||
public BatWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
setHanging(false);
|
||||
}
|
||||
|
||||
public boolean isHanging() {
|
||||
return ((byte)getValue(11, (byte) 1)) == 1;
|
||||
}
|
||||
|
||||
public void setHanging(boolean hanging) {
|
||||
setValue(11, hanging ? (byte) 1 : (byte) 0);
|
||||
sendData(11);
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
public class BlazeWatcher extends LivingWatcher {
|
||||
|
||||
public BlazeWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isBlazing() {
|
||||
return (boolean) getValue(11, false);
|
||||
}
|
||||
|
||||
public void setBlazing(boolean isBlazing) {
|
||||
setValue(11, isBlazing);
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
|
||||
public class BoatWatcher extends FlagWatcher {
|
||||
|
||||
//TODO: Add stuff for new boat values
|
||||
|
||||
public BoatWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public int getDamage() {
|
||||
return (int) getValue(7, 40F);
|
||||
}
|
||||
|
||||
public void setDamage(float dmg) {
|
||||
setValue(7, dmg);
|
||||
sendData(7);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
public class CreeperWatcher extends LivingWatcher {
|
||||
|
||||
public CreeperWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isIgnited() {
|
||||
return (boolean) getValue(13, false);
|
||||
}
|
||||
|
||||
public boolean isPowered() {
|
||||
return (boolean) getValue(12, false);
|
||||
}
|
||||
|
||||
public void setIgnited(boolean ignited) {
|
||||
setValue(13, ignited);
|
||||
sendData(13);
|
||||
}
|
||||
|
||||
public void setPowered(boolean powered) {
|
||||
setValue(12, powered);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
//TODO: Add support for custom items instead of just stone
|
||||
public class DroppedItemWatcher extends FlagWatcher {
|
||||
|
||||
public DroppedItemWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public ItemStack getItemStack() {
|
||||
return (ItemStack) getValue(5, new ItemStack(1));
|
||||
}
|
||||
|
||||
public void setItemStack(ItemStack item) {
|
||||
setValue(5, item);
|
||||
sendData(5);
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.comphenix.protocol.wrappers.BlockPosition;
|
||||
import com.google.common.base.Optional;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
public class EnderCrystalWatcher extends FlagWatcher {
|
||||
|
||||
public EnderCrystalWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public void setBeamTarget(BlockPosition position) {
|
||||
setValue(5, Optional.of(position));
|
||||
sendData(5);
|
||||
}
|
||||
|
||||
public Optional<BlockPosition> getBeamTarget() {
|
||||
return (Optional) getValue(5, Optional.absent());
|
||||
}
|
||||
|
||||
public void setShowBottom(boolean bool) {
|
||||
setValue(6, bool);
|
||||
sendData(6);
|
||||
}
|
||||
|
||||
public boolean isShowBottom() {
|
||||
return (boolean) getValue(6, false);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
public class EnderDragonWatcher extends LivingWatcher {
|
||||
|
||||
public EnderDragonWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public int getPhase() {
|
||||
return (int) getValue(11, 0);
|
||||
}
|
||||
|
||||
public void setPhase(int phase) {
|
||||
setValue(11, phase);
|
||||
sendData(11);
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.google.common.base.Optional;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.apache.commons.lang3.tuple.Pair;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
public class EndermanWatcher extends LivingWatcher {
|
||||
|
||||
public EndermanWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ItemStack getItemInMainHand() {
|
||||
Optional<Integer> value = (Optional<Integer>) getValue(11, Optional.of(1));
|
||||
if (value.isPresent()) {
|
||||
Pair<Integer, Integer> pair = ReflectionManager.getFromCombinedId(value.get());
|
||||
int id = pair.getLeft();
|
||||
int data = pair.getRight();
|
||||
return new ItemStack(id, 1, (short) data);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setItemInMainHand(ItemStack itemstack) {
|
||||
setItemInMainHand(itemstack.getTypeId(), itemstack.getDurability());
|
||||
}
|
||||
|
||||
public void setItemInMainHand(int typeId) {
|
||||
setItemInMainHand(typeId, 0);
|
||||
}
|
||||
|
||||
public void setItemInMainHand(int typeId, int data) {
|
||||
int combined = ReflectionManager.getCombinedId(typeId, data);
|
||||
setValue(11, Optional.of(combined));
|
||||
}
|
||||
|
||||
public boolean isAggressive() {
|
||||
return (boolean) getValue(12, false);
|
||||
}
|
||||
|
||||
public void setAggressive(boolean isAggressive) {
|
||||
setValue(12, isAggressive);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
public class FallingBlockWatcher extends FlagWatcher {
|
||||
|
||||
private ItemStack block;
|
||||
|
||||
public FallingBlockWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public FallingBlockWatcher clone(Disguise disguise) {
|
||||
FallingBlockWatcher watcher = (FallingBlockWatcher) super.clone(disguise);
|
||||
watcher.setBlock(getBlock());
|
||||
return watcher;
|
||||
}
|
||||
|
||||
public ItemStack getBlock() {
|
||||
return block;
|
||||
}
|
||||
|
||||
public void setBlock(ItemStack block) {
|
||||
this.block = block;
|
||||
if (block.getType() == null || block.getType() == Material.AIR) {
|
||||
block.setType(Material.STONE);
|
||||
}
|
||||
if (DisguiseAPI.isDisguiseInUse(getDisguise()) && getDisguise().getWatcher() == this) {
|
||||
DisguiseUtilities.refreshTrackers(getDisguise());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
public class GhastWatcher extends LivingWatcher {
|
||||
|
||||
public GhastWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isAggressive() {
|
||||
return (boolean) getValue(11, false);
|
||||
}
|
||||
|
||||
public void setAggressive(boolean isAggressive) {
|
||||
setValue(11, isAggressive);
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class GuardianWatcher extends LivingWatcher {
|
||||
|
||||
public GuardianWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this guardian targetting someone?
|
||||
* @return
|
||||
*/
|
||||
public boolean isTarget() {
|
||||
return ((int)getValue(12, 0)) != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shoot a beam at the given entityId.
|
||||
* @param entityId
|
||||
*/
|
||||
public void setTarget(int entityId) {
|
||||
setValue(12, entityId);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shoot a beam at the given player name.
|
||||
* @param playername
|
||||
*/
|
||||
public void setTarget(String playername) {
|
||||
Player player = Bukkit.getPlayer(playername);
|
||||
if (player == null) return;
|
||||
setValue(12, player.getEntityId());
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public boolean isRetractingSpikes() {
|
||||
return isGuardianFlag(2);
|
||||
}
|
||||
|
||||
public void setRetractingSpikes(boolean isRetracting) {
|
||||
setGuardianFlag(2, isRetracting);
|
||||
}
|
||||
|
||||
public boolean isElder() {
|
||||
return isGuardianFlag(4);
|
||||
}
|
||||
|
||||
public void setElder(boolean isGuardian) {
|
||||
setGuardianFlag(4, isGuardian);
|
||||
}
|
||||
|
||||
protected boolean isGuardianFlag(int no) {
|
||||
return ((byte) getValue(11, (byte) 0) & no) != 0;
|
||||
}
|
||||
|
||||
protected void setGuardianFlag(int no, boolean flag) {
|
||||
byte b0 = (byte) getValue(11, (byte) 0);
|
||||
if (flag) {
|
||||
setValue(11, (byte) (b0 | no));
|
||||
} else {
|
||||
setValue(11, (byte) (b0 & -(no + 1)));
|
||||
}
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,178 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.google.common.base.Optional;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Horse.Color;
|
||||
import org.bukkit.entity.Horse.Style;
|
||||
import org.bukkit.entity.Horse.Variant;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
public class HorseWatcher extends AgeableWatcher {
|
||||
|
||||
public HorseWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
setStyle(Style.values()[DisguiseUtilities.random.nextInt(Style.values().length)]);
|
||||
setColor(Color.values()[DisguiseUtilities.random.nextInt(Color.values().length)]);
|
||||
}
|
||||
|
||||
public Variant getVariant() {
|
||||
return Variant.values()[(int) getValue(13, 0)];
|
||||
}
|
||||
|
||||
public void setVariant(Variant variant) {
|
||||
setVariant(variant.ordinal());
|
||||
}
|
||||
|
||||
public void setVariant(int variant) {
|
||||
if (variant < 0 || variant > 4) {
|
||||
variant = 0; //Crashing people is mean
|
||||
}
|
||||
setValue(13, variant);
|
||||
sendData(13);
|
||||
}
|
||||
|
||||
public Color getColor() {
|
||||
return Color.values()[((Integer) getValue(14, 0) & 0xFF)];
|
||||
}
|
||||
|
||||
public ItemStack getHorseArmor() {
|
||||
int horseValue = getHorseArmorAsInt();
|
||||
switch (horseValue) {
|
||||
case 1:
|
||||
return new ItemStack(Material.getMaterial("IRON_BARDING"));
|
||||
case 2:
|
||||
return new ItemStack(Material.getMaterial("GOLD_BARDING"));
|
||||
case 3:
|
||||
return new ItemStack(Material.getMaterial("DIAMOND_BARDING"));
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
protected int getHorseArmorAsInt() {
|
||||
return (int) getValue(16, 0);
|
||||
}
|
||||
|
||||
public Optional<UUID> getOwner() {
|
||||
return (Optional<UUID>) getValue(15, Optional.absent());
|
||||
}
|
||||
|
||||
public Style getStyle() {
|
||||
return Style.values()[((int) getValue(14, 0) >>> 8)];
|
||||
}
|
||||
|
||||
public boolean hasChest() {
|
||||
return isHorseFlag(8);
|
||||
}
|
||||
|
||||
public boolean isBreedable() {
|
||||
return isHorseFlag(16);
|
||||
}
|
||||
|
||||
public boolean isGrazing() {
|
||||
return isHorseFlag(32);
|
||||
}
|
||||
|
||||
public boolean isMouthOpen() {
|
||||
return isHorseFlag(128);
|
||||
}
|
||||
|
||||
public boolean isRearing() {
|
||||
return isHorseFlag(64);
|
||||
}
|
||||
|
||||
public boolean isSaddled() {
|
||||
return isHorseFlag(4);
|
||||
}
|
||||
|
||||
public boolean isTamed() {
|
||||
return isHorseFlag(2);
|
||||
}
|
||||
|
||||
private boolean isHorseFlag(int i) {
|
||||
return (getHorseFlag() & i) != 0;
|
||||
}
|
||||
|
||||
private byte getHorseFlag() {
|
||||
return (byte) getValue(12, (byte) 0);
|
||||
}
|
||||
|
||||
public void setCanBreed(boolean breed) {
|
||||
setHorseFlag(16, breed);
|
||||
}
|
||||
|
||||
public void setCarryingChest(boolean chest) {
|
||||
setHorseFlag(8, chest);
|
||||
}
|
||||
|
||||
public void setColor(Color color) {
|
||||
setValue(14, color.ordinal() & 0xFF | getStyle().ordinal() << 8);
|
||||
sendData(14);
|
||||
}
|
||||
|
||||
private void setHorseFlag(int i, boolean flag) {
|
||||
byte j = (byte) getValue(12, (byte) 0);
|
||||
if (flag) {
|
||||
setValue(12, (byte) (j | i));
|
||||
} else {
|
||||
setValue(12, (byte) (j & ~i));
|
||||
}
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setGrazing(boolean grazing) {
|
||||
setHorseFlag(32, grazing);
|
||||
}
|
||||
|
||||
protected void setHorseArmor(int armor) {
|
||||
setValue(16, armor);
|
||||
sendData(16);
|
||||
}
|
||||
|
||||
public void setHorseArmor(ItemStack item) {
|
||||
int value = 0;
|
||||
if (item != null) {
|
||||
Material mat = item.getType();
|
||||
if (mat == Material.IRON_BARDING) {
|
||||
value = 1;
|
||||
} else if (mat == Material.GOLD_BARDING) {
|
||||
value = 2;
|
||||
} else if (mat == Material.DIAMOND_BARDING) {
|
||||
value = 3;
|
||||
}
|
||||
}
|
||||
setHorseArmor(value);
|
||||
}
|
||||
|
||||
public void setMouthOpen(boolean mouthOpen) {
|
||||
setHorseFlag(128, mouthOpen);
|
||||
}
|
||||
|
||||
public void setOwner(UUID uuid) {
|
||||
setValue(15, Optional.of(uuid));
|
||||
sendData(15);
|
||||
}
|
||||
|
||||
public void setRearing(boolean rear) {
|
||||
setHorseFlag(64, rear);
|
||||
}
|
||||
|
||||
public void setSaddled(boolean saddled) {
|
||||
setHorseFlag(4, saddled);
|
||||
}
|
||||
|
||||
public void setStyle(Style style) {
|
||||
setValue(14, getColor().ordinal() & 0xFF | style.ordinal() << 8);
|
||||
sendData(14);
|
||||
}
|
||||
|
||||
public void setTamed(boolean tamed) {
|
||||
setHorseFlag(2, tamed);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
public class ItemFrameWatcher extends FlagWatcher {
|
||||
|
||||
public ItemFrameWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public ItemStack getItem() {
|
||||
if (getValue(5, null) == null) {
|
||||
return new ItemStack(0);
|
||||
}
|
||||
return (ItemStack) getValue(5, null);
|
||||
}
|
||||
|
||||
public int getRotation() {
|
||||
return (int) getValue(6, 0);
|
||||
}
|
||||
|
||||
public void setItem(ItemStack newItem) {
|
||||
if (newItem == null) {
|
||||
newItem = new ItemStack(0);
|
||||
}
|
||||
newItem = newItem.clone();
|
||||
newItem.setAmount(1);
|
||||
setValue(5, newItem);
|
||||
sendData(5);
|
||||
}
|
||||
|
||||
public void setRotation(int rotation) {
|
||||
setValue(6, (byte) (rotation % 4));
|
||||
sendData(6);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,173 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.comphenix.protocol.PacketType.Play.Server;
|
||||
import com.comphenix.protocol.ProtocolLibrary;
|
||||
import com.comphenix.protocol.events.PacketContainer;
|
||||
import com.comphenix.protocol.wrappers.WrappedAttribute;
|
||||
import com.comphenix.protocol.wrappers.WrappedAttribute.Builder;
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import me.libraryaddict.disguise.utilities.ReflectionManager;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.potion.PotionEffectType;
|
||||
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
public class LivingWatcher extends FlagWatcher {
|
||||
|
||||
static Map<Integer, Object> list = new HashMap<>();
|
||||
static Method getId;
|
||||
|
||||
static {
|
||||
try {
|
||||
getId = ReflectionManager.getNmsMethod("MobEffectList", "getId", ReflectionManager.getNmsClass("MobEffectList"));
|
||||
Object REGISTRY = ReflectionManager.getNmsField("MobEffectList", "REGISTRY").get(null);
|
||||
for (Object next: ((Iterable)REGISTRY)) {
|
||||
int id = (int) getId.invoke(null, next);
|
||||
list.put(id, next);
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
private double maxHealth;
|
||||
private boolean maxHealthSet;
|
||||
private HashSet<Integer> potionEffects = new HashSet<>();
|
||||
|
||||
public LivingWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public void addPotionEffect(PotionEffectType potionEffect) {
|
||||
if (!hasPotionEffect(potionEffect)) {
|
||||
removePotionEffect(potionEffect);
|
||||
potionEffects.add(potionEffect.getId());
|
||||
sendPotionEffects();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public LivingWatcher clone(Disguise disguise) {
|
||||
LivingWatcher clone = (LivingWatcher) super.clone(disguise);
|
||||
clone.potionEffects = (HashSet<Integer>) potionEffects.clone();
|
||||
clone.maxHealth = maxHealth;
|
||||
clone.maxHealthSet = maxHealthSet;
|
||||
return clone;
|
||||
}
|
||||
|
||||
public float getHealth() {
|
||||
return (float) getValue(6, 0F);
|
||||
}
|
||||
|
||||
public double getMaxHealth() {
|
||||
return maxHealth;
|
||||
}
|
||||
|
||||
public boolean isPotionParticlesAmbient() {
|
||||
return (boolean) getValue(8, false);
|
||||
}
|
||||
|
||||
private int getPotions() {
|
||||
int m = 3694022;
|
||||
|
||||
if (potionEffects.isEmpty()) {
|
||||
return m;
|
||||
}
|
||||
|
||||
float f1 = 0.0F;
|
||||
float f2 = 0.0F;
|
||||
float f3 = 0.0F;
|
||||
float f4 = 0.0F;
|
||||
try {
|
||||
for (int localMobEffect : potionEffects) {
|
||||
int n = (Integer) getId.invoke(list.get(localMobEffect));
|
||||
f1 += (n >> 16 & 0xFF) / 255.0F;
|
||||
f2 += (n >> 8 & 0xFF) / 255.0F;
|
||||
f3 += (n & 0xFF) / 255.0F;
|
||||
f4 += 1.0F;
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
|
||||
f1 = f1 / f4 * 255.0F;
|
||||
f2 = f2 / f4 * 255.0F;
|
||||
f3 = f3 / f4 * 255.0F;
|
||||
|
||||
return (int) f1 << 16 | (int) f2 << 8 | (int) f3;
|
||||
}
|
||||
|
||||
public boolean hasPotionEffect(PotionEffectType type) {
|
||||
return potionEffects.contains(type.getId());
|
||||
}
|
||||
|
||||
public boolean isMaxHealthSet() {
|
||||
return maxHealthSet;
|
||||
}
|
||||
|
||||
public void removePotionEffect(PotionEffectType type) {
|
||||
if (potionEffects.contains(type.getId())) {
|
||||
potionEffects.remove(type.getId());
|
||||
sendPotionEffects();
|
||||
}
|
||||
}
|
||||
|
||||
public void setPotionParticlesAmbient(boolean particles) {
|
||||
setValue(8, particles);
|
||||
sendData(8);
|
||||
}
|
||||
|
||||
private void sendPotionEffects() {
|
||||
setValue(7, getPotions());
|
||||
sendData(7);
|
||||
}
|
||||
|
||||
public void setHealth(float health) {
|
||||
setValue(6, health);
|
||||
sendData(6);
|
||||
}
|
||||
|
||||
public int getArrowsSticking() {
|
||||
return (int) getValue(9, 0);
|
||||
}
|
||||
|
||||
public void setArrowsSticking(int arrowsNo) {
|
||||
setValue(9, arrowsNo);
|
||||
sendData(9);
|
||||
}
|
||||
|
||||
public void setMaxHealth(double newHealth) {
|
||||
this.maxHealth = newHealth;
|
||||
this.maxHealthSet = true;
|
||||
if (DisguiseAPI.isDisguiseInUse(getDisguise()) && getDisguise().getWatcher() == this) {
|
||||
PacketContainer packet = new PacketContainer(Server.UPDATE_ATTRIBUTES);
|
||||
List<WrappedAttribute> attributes = new ArrayList<>();
|
||||
Builder builder;
|
||||
builder = WrappedAttribute.newBuilder();
|
||||
builder.attributeKey("generic.maxHealth");
|
||||
builder.baseValue(getMaxHealth());
|
||||
builder.packet(packet);
|
||||
attributes.add(builder.build());
|
||||
Entity entity = getDisguise().getEntity();
|
||||
packet.getIntegers().write(0, entity.getEntityId());
|
||||
packet.getAttributeCollectionModifier().write(0, attributes);
|
||||
for (Player player : DisguiseUtilities.getPerverts(getDisguise())) {
|
||||
try {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet, false);
|
||||
} catch (InvocationTargetException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
public class MinecartWatcher extends FlagWatcher {
|
||||
|
||||
public MinecartWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public ItemStack getBlockInCart() {
|
||||
int id = (int) getValue(8, 0) & 0xffff;
|
||||
int data = (int) getValue(8, 0) >> 16;
|
||||
return new ItemStack(id, 1, (short) data);
|
||||
}
|
||||
|
||||
public int getBlockYOffset() {
|
||||
return (int) getValue(9, 0);
|
||||
}
|
||||
|
||||
public boolean isViewBlockInCart() {
|
||||
return (boolean) getValue(10, false);
|
||||
}
|
||||
|
||||
public void setBlockInCart(ItemStack item) {
|
||||
int id = item.getTypeId();
|
||||
int data = item.getDurability();
|
||||
setValue(8, id & 0xffff | data << 16);
|
||||
setValue(10, true); //Show block
|
||||
sendData(8, 10);
|
||||
}
|
||||
|
||||
public void setBlockOffset(int i) {
|
||||
setValue(9, i);
|
||||
sendData(9);
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public void setBlockOffSet(int i) {
|
||||
setBlockOffset(i);
|
||||
}
|
||||
|
||||
public void setViewBlockInCart(boolean viewBlock) {
|
||||
setValue(10, viewBlock);
|
||||
sendData(10);
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.entity.Ocelot;
|
||||
import org.bukkit.entity.Ocelot.Type;
|
||||
|
||||
public class OcelotWatcher extends TameableWatcher {
|
||||
|
||||
public OcelotWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public Type getType() {
|
||||
return Ocelot.Type.getType((int) getValue(14, 0));
|
||||
}
|
||||
|
||||
public void setType(Type newType) {
|
||||
setValue(14, newType.getId());
|
||||
sendData(14);
|
||||
}
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.Art;
|
||||
|
||||
public class PaintingWatcher extends FlagWatcher {
|
||||
|
||||
private Art painting;
|
||||
|
||||
public PaintingWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PaintingWatcher clone(Disguise disguise) {
|
||||
PaintingWatcher watcher = (PaintingWatcher) super.clone(disguise);
|
||||
watcher.setArt(getArt());
|
||||
return watcher;
|
||||
}
|
||||
|
||||
public Art getArt() {
|
||||
return painting;
|
||||
}
|
||||
|
||||
public void setArt(Art newPainting) {
|
||||
this.painting = newPainting;
|
||||
if (getDisguise().getEntity() != null && getDisguise().getWatcher() == this) {
|
||||
DisguiseUtilities.refreshTrackers(getDisguise());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
public class PigWatcher extends AgeableWatcher {
|
||||
|
||||
public PigWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isSaddled() {
|
||||
return (boolean) getValue(12, false);
|
||||
}
|
||||
|
||||
public void setSaddled(boolean isSaddled) {
|
||||
setValue(12, isSaddled);
|
||||
sendData(12);
|
||||
}
|
||||
}
|
||||
@@ -1,197 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.comphenix.protocol.PacketType.Play.Server;
|
||||
import com.comphenix.protocol.ProtocolLibrary;
|
||||
import com.comphenix.protocol.events.PacketContainer;
|
||||
import com.comphenix.protocol.reflect.StructureModifier;
|
||||
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
||||
import me.libraryaddict.disguise.DisguiseAPI;
|
||||
import me.libraryaddict.disguise.DisguiseConfig;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.PlayerDisguise;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
public class PlayerWatcher extends LivingWatcher {
|
||||
|
||||
private boolean isInBed;
|
||||
private BlockFace sleepingDirection;
|
||||
|
||||
public PlayerWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlayerWatcher clone(Disguise disguise) {
|
||||
PlayerWatcher watcher = (PlayerWatcher) super.clone(disguise);
|
||||
watcher.isInBed = isInBed;
|
||||
return watcher;
|
||||
}
|
||||
|
||||
public BlockFace getSleepingDirection() {
|
||||
if (sleepingDirection == null) {
|
||||
if (this.getDisguise().getEntity() != null && isSleeping()) {
|
||||
this.sleepingDirection = BlockFace.values()[Math
|
||||
.round(this.getDisguise().getEntity().getLocation().getYaw() / 90F) & 0x3];
|
||||
} else {
|
||||
return BlockFace.EAST;
|
||||
}
|
||||
}
|
||||
return sleepingDirection;
|
||||
}
|
||||
|
||||
|
||||
// Bit 0 (0x01): Cape enabled
|
||||
// Bit 1 (0x02): Jacket enabled
|
||||
// Bit 2 (0x04): Left Sleeve enabled
|
||||
// Bit 3 (0x08): Right Sleeve enabled
|
||||
// Bit 4 (0x10): Left Pants Leg enabled
|
||||
// Bit 5 (0x20): Right Pants Leg enabled
|
||||
// Bit 6 (0x40): Hat enabled
|
||||
|
||||
private boolean isSkinFlag(int i) {
|
||||
return ((byte) getValue(12, (byte) 0) & 1 << i) != 0;
|
||||
}
|
||||
|
||||
public boolean isCapeEnabled() {
|
||||
return isSkinFlag(1);
|
||||
}
|
||||
|
||||
public boolean isJackedEnabled() {
|
||||
return isSkinFlag(2);
|
||||
}
|
||||
|
||||
public boolean isLeftSleeveEnabled() {
|
||||
return isSkinFlag(3);
|
||||
}
|
||||
|
||||
public boolean isRightSleeveEnabled() {
|
||||
return isSkinFlag(4);
|
||||
}
|
||||
|
||||
public boolean isLeftPantsEnabled() {
|
||||
return isSkinFlag(5);
|
||||
}
|
||||
|
||||
public boolean isRightPantsEnabled() {
|
||||
return isSkinFlag(6);
|
||||
}
|
||||
|
||||
public boolean isHatEnabled() {
|
||||
return isSkinFlag(7);
|
||||
}
|
||||
|
||||
public void setCapeEnabled(boolean enabled) {
|
||||
setSkinFlags(1, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setJackedEnabled(boolean enabled) {
|
||||
setSkinFlags(2, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setLeftSleeveEnabled(boolean enabled) {
|
||||
setSkinFlags(3, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setRightSleeveEnabled(boolean enabled) {
|
||||
setSkinFlags(4, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setLeftPantsEnabled(boolean enabled) {
|
||||
setSkinFlags(5, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setRightPantsEnabled(boolean enabled) {
|
||||
setSkinFlags(6, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setHatEnabled(boolean enabled) {
|
||||
setSkinFlags(7, enabled);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
|
||||
public boolean isSleeping() {
|
||||
return isInBed;
|
||||
}
|
||||
|
||||
public void setSkin(String playerName) {
|
||||
((PlayerDisguise) getDisguise()).setSkin(playerName);
|
||||
}
|
||||
|
||||
public void setSkin(WrappedGameProfile profile) {
|
||||
((PlayerDisguise) getDisguise()).setSkin(profile);
|
||||
}
|
||||
|
||||
public void setSleeping(BlockFace sleepingDirection) {
|
||||
setSleeping(true, sleepingDirection);
|
||||
}
|
||||
|
||||
public void setSleeping(boolean sleep) {
|
||||
setSleeping(sleep, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* If no BlockFace is supplied. It grabs it from the entities facing direction if applicable.
|
||||
*
|
||||
* @param sleeping
|
||||
* @param sleepingDirection
|
||||
*/
|
||||
public void setSleeping(boolean sleeping, BlockFace sleepingDirection) {
|
||||
if (sleepingDirection != null) {
|
||||
this.sleepingDirection = BlockFace.values()[sleepingDirection.ordinal() % 4];
|
||||
}
|
||||
if (sleeping != isSleeping()) {
|
||||
isInBed = sleeping;
|
||||
if (DisguiseConfig.isBedPacketsEnabled() && DisguiseUtilities.isDisguiseInUse(getDisguise())) {
|
||||
try {
|
||||
if (isSleeping()) {
|
||||
for (Player player : DisguiseUtilities.getPerverts(getDisguise())) {
|
||||
PacketContainer[] packets = DisguiseUtilities.getBedPackets(player, this.getDisguise().getEntity()
|
||||
.getLocation(), player.getLocation(), (PlayerDisguise) this.getDisguise());
|
||||
if (getDisguise().getEntity() == player) {
|
||||
for (PacketContainer packet : packets) {
|
||||
packet = packet.shallowClone();
|
||||
packet.getIntegers().write(0, DisguiseAPI.getSelfDisguiseId());
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
||||
}
|
||||
} else {
|
||||
for (PacketContainer packet : packets) {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
PacketContainer packet = new PacketContainer(Server.ANIMATION);
|
||||
StructureModifier<Integer> mods = packet.getIntegers();
|
||||
mods.write(0, getDisguise().getEntity().getEntityId());
|
||||
mods.write(1, 3);
|
||||
for (Player player : DisguiseUtilities.getPerverts(getDisguise())) {
|
||||
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
||||
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void setSkinFlags(int i, boolean flag) {
|
||||
byte b0 = (byte) getValue(12, (byte) 0);
|
||||
if (flag) {
|
||||
setValue(12, (byte) (b0 | 1 << i));
|
||||
} else {
|
||||
setValue(12, (byte) (b0 & (~1 << i)));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.RabbitType;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
|
||||
public class RabbitWatcher extends AgeableWatcher {
|
||||
|
||||
public RabbitWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
setType(RabbitType.values()[DisguiseUtilities.random.nextInt(RabbitType.values().length)]);
|
||||
}
|
||||
|
||||
public RabbitType getType() {
|
||||
return RabbitType.getType((int) getValue(18, 0));
|
||||
}
|
||||
|
||||
public void setType(RabbitType type) {
|
||||
setValue(12, type.getTypeId());
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.AnimalColor;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.DyeColor;
|
||||
|
||||
public class SheepWatcher extends AgeableWatcher {
|
||||
|
||||
public SheepWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
setValue(12, (byte) 0);
|
||||
}
|
||||
|
||||
public AnimalColor getColor() {
|
||||
return AnimalColor.getColor(((int) getValue(12, (byte) 0) & 15));
|
||||
}
|
||||
|
||||
public boolean isSheared() {
|
||||
return ((byte) getValue(12, (byte) 0) & 16) != 0;
|
||||
}
|
||||
|
||||
public void setColor(AnimalColor color) {
|
||||
setColor(DyeColor.getByWoolData((byte) color.getId()));
|
||||
}
|
||||
|
||||
public void setColor(DyeColor color) {
|
||||
byte b0 = (byte) getValue(12, (byte) 0);
|
||||
setValue(12, (byte) (b0 & 240 | color.getWoolData() & 15));
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setSheared(boolean flag) {
|
||||
byte b0 = (byte) getValue(12, (byte) 0);
|
||||
if (flag) {
|
||||
setValue(12, (byte) (b0 | 16));
|
||||
} else {
|
||||
setValue(12, (byte) (b0 & -17));
|
||||
}
|
||||
sendData(12);
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.comphenix.protocol.wrappers.BlockPosition;
|
||||
import com.google.common.base.Optional;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.block.BlockFace;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
//TODO: Add the appropriate data values to this class
|
||||
public class ShulkerWatcher extends LivingWatcher {
|
||||
|
||||
public ShulkerWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public BlockFace getFacingDirection() {
|
||||
return BlockFace.UP;
|
||||
}
|
||||
|
||||
public void setFacingDirection() {
|
||||
|
||||
}
|
||||
|
||||
public Optional<BlockPosition> getAttachmentPosition() {
|
||||
return Optional.absent();
|
||||
}
|
||||
|
||||
public void setAttachmentPosition(BlockPosition pos) {
|
||||
|
||||
}
|
||||
|
||||
public byte getShieldHeight() {
|
||||
return 0x00;
|
||||
}
|
||||
|
||||
public void setShieldHeight() {
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.entity.Skeleton.SkeletonType;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
public class SkeletonWatcher extends LivingWatcher {
|
||||
|
||||
public SkeletonWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public void setType(SkeletonType type) {
|
||||
setValue(11, type.getId());
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
public SkeletonType getType() {
|
||||
return SkeletonType.getType((int) getValue(11, SkeletonType.NORMAL.getId()));
|
||||
}
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
|
||||
public class SlimeWatcher extends LivingWatcher {
|
||||
|
||||
public SlimeWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
setSize(DisguiseUtilities.random.nextInt(4) + 1);
|
||||
}
|
||||
|
||||
public int getSize() {
|
||||
return (int) getValue(11, 1);
|
||||
}
|
||||
|
||||
public void setSize(int size) {
|
||||
if (size <= 0 || size >= 128) {
|
||||
size = 1;
|
||||
}
|
||||
setValue(11, size);
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
|
||||
public class SplashPotionWatcher extends FlagWatcher {
|
||||
|
||||
private int potionId;
|
||||
|
||||
public SplashPotionWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public SplashPotionWatcher clone(Disguise disguise) {
|
||||
SplashPotionWatcher watcher = (SplashPotionWatcher) super.clone(disguise);
|
||||
watcher.setPotionId(getPotionId());
|
||||
return watcher;
|
||||
}
|
||||
|
||||
public int getPotionId() {
|
||||
return potionId;
|
||||
}
|
||||
|
||||
public void setPotionId(int newPotionId) {
|
||||
this.potionId = newPotionId;
|
||||
if (getDisguise().getEntity() != null && getDisguise().getWatcher() == this) {
|
||||
DisguiseUtilities.refreshTrackers(getDisguise());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import com.google.common.base.Optional;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
public class TameableWatcher extends AgeableWatcher {
|
||||
|
||||
public TameableWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public Optional<UUID> getOwner() {
|
||||
return (Optional<UUID>) getValue(13, Optional.absent());
|
||||
}
|
||||
|
||||
public boolean isSitting() {
|
||||
return isTameableFlag(1);
|
||||
}
|
||||
|
||||
public boolean isTamed() {
|
||||
return isTameableFlag(4);
|
||||
}
|
||||
|
||||
protected boolean isTameableFlag(int no) {
|
||||
return ((byte) getValue(12, (byte) 0) & no) != 0;
|
||||
}
|
||||
|
||||
protected void setTameableFlag(int no, boolean flag) {
|
||||
byte value = (byte) getValue(12, (byte) 0);
|
||||
if (flag) {
|
||||
setValue(12, (byte) (value | no));
|
||||
} else {
|
||||
setValue(12, (byte) (value & -(no + 1)));
|
||||
}
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setOwner(UUID owner) {
|
||||
setValue(13, Optional.of(owner));
|
||||
sendData(13);
|
||||
}
|
||||
|
||||
public void setSitting(boolean sitting) {
|
||||
setTameableFlag(1, sitting);
|
||||
}
|
||||
|
||||
public void setTamed(boolean tamed) {
|
||||
setTameableFlag(4, tamed);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.Color;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
public class TippedArrowWatcher extends ArrowWatcher {
|
||||
|
||||
public TippedArrowWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
int r = DisguiseUtilities.random.nextInt(256);
|
||||
int g = DisguiseUtilities.random.nextInt(256);
|
||||
int b = DisguiseUtilities.random.nextInt(256);
|
||||
setColor(Color.fromRGB(r, g, b));
|
||||
}
|
||||
|
||||
public Color getColor() {
|
||||
int color = (int) getValue(5, Color.WHITE.asRGB());
|
||||
return Color.fromRGB(color);
|
||||
}
|
||||
|
||||
public void setColor(Color color) {
|
||||
setValue(5, color.asRGB());
|
||||
sendData(5);
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
||||
import org.bukkit.entity.Villager.Profession;
|
||||
|
||||
public class VillagerWatcher extends AgeableWatcher {
|
||||
|
||||
public VillagerWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
setProfession(Profession.values()[DisguiseUtilities.random.nextInt(Profession.values().length)]);
|
||||
}
|
||||
|
||||
public Profession getProfession() {
|
||||
return Profession.getProfession((int) getValue(16, 0));
|
||||
}
|
||||
|
||||
public void setProfession(int professionId) {
|
||||
setValue(12, professionId);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setProfession(Profession newProfession) {
|
||||
setProfession(newProfession.getId());
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
/**
|
||||
* @author Navid
|
||||
*/
|
||||
public class WitchWatcher extends LivingWatcher {
|
||||
|
||||
public WitchWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
|
||||
public boolean isAggressive() {
|
||||
return (boolean) getValue(11, false);
|
||||
}
|
||||
|
||||
public void setAggressive(boolean aggressive) {
|
||||
setValue(11, aggressive);
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
|
||||
|
||||
public class WitherSkullWatcher extends FlagWatcher {
|
||||
|
||||
public WitherSkullWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isBlue() {
|
||||
return (boolean) getValue(5, false);
|
||||
}
|
||||
|
||||
public void setBlue(boolean blue) {
|
||||
setValue(5, blue);
|
||||
sendData(5);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.ChatColor;
|
||||
|
||||
import java.security.InvalidParameterException;
|
||||
|
||||
public class WitherWatcher extends LivingWatcher {
|
||||
|
||||
public WitherWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the amount of time this Wither is invulnerable for
|
||||
* @return
|
||||
*/
|
||||
public int getInvulnerability() {
|
||||
return (int) getValue(14, 0);
|
||||
}
|
||||
|
||||
public int[] getTargets() {
|
||||
return new int[]{(Integer) getValue(11, 0), (Integer) getValue(12, 0), (Integer) getValue(13, 0)};
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the amount of time this Wither is invulnerable for
|
||||
*/
|
||||
public void setInvulnerability(int invulnerability) {
|
||||
setValue(14, invulnerability);
|
||||
sendData(14);
|
||||
}
|
||||
|
||||
public void setTargets(int... targets) {
|
||||
if (targets.length != 3) {
|
||||
throw new InvalidParameterException(ChatColor.RED + "Expected 3 numbers for wither setTargets. Received "
|
||||
+ targets.length);
|
||||
}
|
||||
setValue(11, targets[0]);
|
||||
setValue(12, targets[1]);
|
||||
setValue(13, targets[2]);
|
||||
sendData(11, 12, 13);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.AnimalColor;
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.DyeColor;
|
||||
|
||||
public class WolfWatcher extends TameableWatcher {
|
||||
|
||||
public WolfWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public AnimalColor getCollarColor() {
|
||||
return AnimalColor.getColor((int) getValue(16, 14));
|
||||
}
|
||||
|
||||
/**
|
||||
* Used for tail rotation.
|
||||
* @return
|
||||
*/
|
||||
public float getDamageTaken() {
|
||||
return (float) getValue(14, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Used for tail rotation.
|
||||
* @param damage
|
||||
*/
|
||||
public void setDamageTaken(float damage) {
|
||||
setValue(14, damage);
|
||||
sendData(14);
|
||||
}
|
||||
|
||||
public boolean isBegging() {
|
||||
return (boolean) getValue(15, false);
|
||||
}
|
||||
|
||||
public void setBegging(boolean begging) {
|
||||
setValue(15, begging);
|
||||
sendData(15);
|
||||
}
|
||||
|
||||
public boolean isAngry() {
|
||||
return isTameableFlag(2);
|
||||
}
|
||||
|
||||
public void setAngry(boolean angry) {
|
||||
setTameableFlag(2, angry);
|
||||
}
|
||||
|
||||
public void setCollarColor(AnimalColor color) {
|
||||
setCollarColor(DyeColor.getByWoolData((byte) color.getId()));
|
||||
}
|
||||
|
||||
public void setCollarColor(DyeColor newColor) {
|
||||
if (!isTamed()) {
|
||||
setTamed(true);
|
||||
}
|
||||
if (newColor.getWoolData() != getCollarColor().getId()) {
|
||||
setValue(16, (int) newColor.getDyeData());
|
||||
sendData(16);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
package me.libraryaddict.disguise.disguisetypes.watchers;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
import org.bukkit.entity.Villager.Profession;
|
||||
|
||||
public class ZombieWatcher extends LivingWatcher {
|
||||
|
||||
public ZombieWatcher(Disguise disguise) {
|
||||
super(disguise);
|
||||
}
|
||||
|
||||
public boolean isAdult() {
|
||||
return !isBaby();
|
||||
}
|
||||
|
||||
public boolean isBaby() {
|
||||
return (boolean) getValue(11, false);
|
||||
}
|
||||
|
||||
public boolean isShaking() {
|
||||
return (boolean) getValue(14, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this zombie a villager?
|
||||
* @return
|
||||
*/
|
||||
public boolean isVillager() {
|
||||
return ((int)getValue(12, 0)) != 0;
|
||||
}
|
||||
|
||||
public boolean isAggressive() {
|
||||
return (boolean) getValue(14, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Only returns a valid value if this zombie
|
||||
* is a villager.
|
||||
* @return
|
||||
*/
|
||||
public Profession getProfession() {
|
||||
return Profession.getProfession((int) getValue(12, 0));
|
||||
}
|
||||
|
||||
public void setAdult() {
|
||||
setBaby(false);
|
||||
}
|
||||
|
||||
public void setBaby() {
|
||||
setBaby(true);
|
||||
}
|
||||
|
||||
public void setBaby(boolean baby) {
|
||||
setValue(11, baby);
|
||||
sendData(11);
|
||||
}
|
||||
|
||||
public void setShaking(boolean shaking) {
|
||||
setValue(13, (byte) (shaking ? 1 : 0));
|
||||
sendData(13);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the profession of this zombie, in turn
|
||||
* turning it into a Zombie Villager
|
||||
* @param id
|
||||
*/
|
||||
public void setProfession(int id) {
|
||||
setValue(12, id);
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the profession of this zombie, in turn
|
||||
* turning it into a Zombie Villager
|
||||
* @param profession
|
||||
*/
|
||||
public void setProfession(Profession profession) {
|
||||
setValue(12, profession.getId());
|
||||
sendData(12);
|
||||
}
|
||||
|
||||
public void setAggressive(boolean handsup) {
|
||||
setValue(14, handsup);
|
||||
sendData(14);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package me.libraryaddict.disguise.events;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.event.Cancellable;
|
||||
import org.bukkit.event.Event;
|
||||
import org.bukkit.event.HandlerList;
|
||||
|
||||
public class DisguiseEvent extends Event implements Cancellable {
|
||||
|
||||
private static final HandlerList handlers = new HandlerList();
|
||||
|
||||
public static HandlerList getHandlerList() {
|
||||
return handlers;
|
||||
}
|
||||
|
||||
private Disguise disguise;
|
||||
private Entity disguised;
|
||||
private boolean isCancelled;
|
||||
|
||||
public DisguiseEvent(Entity entity, Disguise disguise) {
|
||||
this.disguised = entity;
|
||||
this.disguise = disguise;
|
||||
}
|
||||
|
||||
public Disguise getDisguise() {
|
||||
return disguise;
|
||||
}
|
||||
|
||||
public Entity getEntity() {
|
||||
return disguised;
|
||||
}
|
||||
|
||||
@Override
|
||||
public HandlerList getHandlers() {
|
||||
return handlers;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isCancelled() {
|
||||
return isCancelled;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCancelled(boolean cancelled) {
|
||||
isCancelled = cancelled;
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package me.libraryaddict.disguise.events;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
||||
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.event.Cancellable;
|
||||
import org.bukkit.event.Event;
|
||||
import org.bukkit.event.HandlerList;
|
||||
|
||||
public class UndisguiseEvent extends Event implements Cancellable {
|
||||
|
||||
private static final HandlerList handlers = new HandlerList();
|
||||
|
||||
public static HandlerList getHandlerList() {
|
||||
return handlers;
|
||||
}
|
||||
|
||||
private Disguise disguise;
|
||||
private Entity disguised;
|
||||
private boolean isCancelled;
|
||||
|
||||
public UndisguiseEvent(Entity entity, Disguise disguise) {
|
||||
this.disguised = entity;
|
||||
this.disguise = disguise;
|
||||
}
|
||||
|
||||
public Disguise getDisguise() {
|
||||
return disguise;
|
||||
}
|
||||
|
||||
public Entity getEntity() {
|
||||
return disguised;
|
||||
}
|
||||
|
||||
@Override
|
||||
public HandlerList getHandlers() {
|
||||
return handlers;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isCancelled() {
|
||||
return isCancelled;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCancelled(boolean cancelled) {
|
||||
isCancelled = cancelled;
|
||||
}
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import org.bukkit.entity.Entity;
|
||||
|
||||
import java.net.URL;
|
||||
import java.net.URLDecoder;
|
||||
import java.security.CodeSource;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Enumeration;
|
||||
import java.util.jar.JarEntry;
|
||||
import java.util.jar.JarFile;
|
||||
|
||||
/**
|
||||
* User: Austin Date: 4/22/13 Time: 11:47 PM (c) lazertester
|
||||
*/
|
||||
// Code for this taken and slightly modified from
|
||||
// https://github.com/ddopson/java-class-enumerator
|
||||
public class ClassGetter {
|
||||
|
||||
public static ArrayList<Class<?>> getClassesForPackage(String pkgname) {
|
||||
ArrayList<Class<?>> classes = new ArrayList<>();
|
||||
// String relPath = pkgname.replace('.', '/');
|
||||
|
||||
// Get a File object for the package
|
||||
CodeSource src = Entity.class.getProtectionDomain().getCodeSource();
|
||||
if (src != null) {
|
||||
URL resource = src.getLocation();
|
||||
resource.getPath();
|
||||
processJarfile(resource, pkgname, classes);
|
||||
}
|
||||
return classes;
|
||||
}
|
||||
|
||||
private static Class<?> loadClass(String className) {
|
||||
try {
|
||||
return Class.forName(className);
|
||||
} catch (ClassNotFoundException e) {
|
||||
throw new RuntimeException("Unexpected ClassNotFoundException loading class '" + className + "'");
|
||||
} catch (NoClassDefFoundError e) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static void processJarfile(URL resource, String pkgname, ArrayList<Class<?>> classes) {
|
||||
try {
|
||||
String relPath = pkgname.replace('.', '/');
|
||||
String resPath = URLDecoder.decode(resource.getPath(), "UTF-8");
|
||||
String jarPath = resPath.replaceFirst("[.]jar[!].*", ".jar").replaceFirst("file:", "");
|
||||
JarFile jarFile = new JarFile(jarPath);
|
||||
Enumeration<JarEntry> entries = jarFile.entries();
|
||||
while (entries.hasMoreElements()) {
|
||||
JarEntry entry = entries.nextElement();
|
||||
String entryName = entry.getName();
|
||||
String className = null;
|
||||
if (entryName.endsWith(".class") && entryName.startsWith(relPath)
|
||||
&& entryName.length() > (relPath.length() + "/".length())) {
|
||||
className = entryName.replace('/', '.').replace('\\', '.').replace(".class", "");
|
||||
}
|
||||
if (className != null) {
|
||||
Class<?> c = loadClass(className);
|
||||
if (c != null) {
|
||||
classes.add(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,205 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import org.bukkit.Sound;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
|
||||
/**
|
||||
* Only living disguises go in here!
|
||||
*/
|
||||
public enum DisguiseSound {
|
||||
|
||||
ARROW(null, null, null, null, Sound.ENTITY_ARROW_HIT, Sound.ENTITY_ARROW_SHOOT),
|
||||
BAT(Sound.ENTITY_BAT_HURT, null, Sound.ENTITY_BAT_DEATH, Sound.ENTITY_BAT_AMBIENT, Sound.ENTITY_PLAYER_SMALL_FALL, Sound.ENTITY_BAT_LOOP, Sound.ENTITY_PLAYER_BIG_FALL,
|
||||
Sound.ENTITY_BAT_TAKEOFF),
|
||||
BLAZE(Sound.ENTITY_BLAZE_HURT, null, Sound.ENTITY_BLAZE_DEATH, Sound.ENTITY_BLAZE_AMBIENT, Sound.ENTITY_PLAYER_SMALL_FALL, Sound.ENTITY_PLAYER_BIG_FALL),
|
||||
CAVE_SPIDER(Sound.ENTITY_SPIDER_AMBIENT, Sound.ENTITY_SPIDER_STEP, Sound.ENTITY_SPIDER_DEATH, Sound.ENTITY_SPIDER_AMBIENT),
|
||||
CHICKEN(Sound.ENTITY_CHICKEN_HURT, Sound.ENTITY_CHICKEN_STEP, Sound.ENTITY_CHICKEN_HURT, Sound.ENTITY_CHICKEN_AMBIENT, Sound.ENTITY_PLAYER_SMALL_FALL,
|
||||
Sound.ENTITY_CHICKEN_EGG, Sound.ENTITY_PLAYER_BIG_FALL),
|
||||
COW(Sound.ENTITY_COW_HURT, Sound.ENTITY_COW_STEP, Sound.ENTITY_COW_DEATH, Sound.ENTITY_COW_AMBIENT),
|
||||
CREEPER(Sound.ENTITY_CREEPER_HURT, "step.grass", Sound.ENTITY_CREEPER_DEATH, null),
|
||||
DONKEY(Sound.ENTITY_DONKEY_HURT, "step.grass", Sound.ENTITY_DONKEY_DEATH, Sound.ENTITY_DONKEY_AMBIENT, Sound.ENTITY_HORSE_GALLOP,
|
||||
Sound.ENTITY_HORSE_SADDLE, Sound.ENTITY_DONKEY_ANGRY, Sound.ENTITY_HORSE_STEP_WOOD, Sound.ENTITY_HORSE_ARMOR,
|
||||
Sound.ENTITY_HORSE_LAND, Sound.ENTITY_HORSE_JUMP, Sound.ENTITY_HORSE_ANGRY),
|
||||
ELDER_GUARDIAN(Sound.ENTITY_ELDER_GUARDIAN_HURT, null, Sound.ENTITY_ELDER_GUARDIAN_DEATH, Sound.ENTITY_ELDER_GUARDIAN_AMBIENT),
|
||||
ENDER_DRAGON(Sound.ENTITY_ENDERDRAGON_HURT, null, Sound.ENTITY_ENDERDRAGON_DEATH, Sound.ENTITY_ENDERDRAGON_AMBIENT, Sound.ENTITY_PLAYER_SMALL_FALL,
|
||||
Sound.ENTITY_ENDERDRAGON_FLAP, Sound.ENTITY_PLAYER_BIG_FALL),
|
||||
ENDERMAN(Sound.ENTITY_ENDERMEN_HURT, "step.grass", Sound.ENTITY_ENDERMEN_DEATH, Sound.ENTITY_ENDERMEN_AMBIENT, Sound.ENTITY_ENDERMEN_SCREAM,
|
||||
Sound.ENTITY_ENDERMEN_TELEPORT, Sound.ENTITY_ENDERMEN_STARE),
|
||||
ENDERMITE(Sound.ENTITY_SILVERFISH_HURT, Sound.ENTITY_ENDERMITE_STEP, Sound.ENTITY_ENDERMITE_DEATH, Sound.ENTITY_ENDERMITE_AMBIENT),
|
||||
GHAST(Sound.ENTITY_GHAST_HURT, null, Sound.ENTITY_GHAST_DEATH, Sound.ENTITY_GHAST_AMBIENT, Sound.ENTITY_PLAYER_SMALL_FALL, Sound.ENTITY_GHAST_SHOOT,
|
||||
Sound.ENTITY_PLAYER_BIG_FALL, Sound.ENTITY_GHAST_SCREAM, Sound.ENTITY_GHAST_WARN),
|
||||
GIANT(Sound.ENTITY_PLAYER_HURT, "step.grass", null, null),
|
||||
GUARDIAN(Sound.ENTITY_GUARDIAN_HURT, null, Sound.ENTITY_GUARDIAN_DEATH, Sound.ENTITY_ELDER_GUARDIAN_AMBIENT),
|
||||
HORSE(Sound.ENTITY_HORSE_HURT, "step.grass", Sound.ENTITY_HORSE_DEATH, Sound.ENTITY_HORSE_AMBIENT, Sound.ENTITY_HORSE_GALLOP,
|
||||
Sound.ENTITY_HORSE_SADDLE, Sound.ENTITY_DONKEY_ANGRY, Sound.ENTITY_HORSE_STEP_WOOD, Sound.ENTITY_HORSE_ARMOR,
|
||||
Sound.ENTITY_HORSE_LAND, Sound.ENTITY_HORSE_JUMP, Sound.ENTITY_HORSE_ANGRY),
|
||||
IRON_GOLEM(Sound.ENTITY_IRONGOLEM_HURT, Sound.ENTITY_IRONGOLEM_STEP, Sound.ENTITY_IRONGOLEM_DEATH, Sound.ENTITY_IRONGOLEM_ATTACK),
|
||||
MAGMA_CUBE(Sound.ENTITY_MAGMACUBE_HURT, Sound.ENTITY_MAGMACUBE_JUMP, null, null),
|
||||
MULE(Sound.ENTITY_MULE_HURT, "step.grass", Sound.ENTITY_MULE_DEATH, Sound.ENTITY_MULE_AMBIENT),
|
||||
MUSHROOM_COW(Sound.ENTITY_COW_HURT, Sound.ENTITY_COW_STEP, Sound.ENTITY_COW_HURT, Sound.ENTITY_COW_AMBIENT),
|
||||
OCELOT(Sound.ENTITY_CAT_HURT, "step.grass", Sound.ENTITY_CAT_HURT, Sound.ENTITY_CAT_AMBIENT, Sound.ENTITY_CAT_PURR, Sound.ENTITY_CAT_PURREOW),
|
||||
PIG(Sound.ENTITY_PIG_HURT, Sound.ENTITY_PIG_STEP, Sound.ENTITY_PIG_DEATH, Sound.ENTITY_PIG_AMBIENT),
|
||||
PIG_ZOMBIE(Sound.ENTITY_ZOMBIE_PIG_HURT, null, Sound.ENTITY_ZOMBIE_PIG_DEATH, Sound.ENTITY_ZOMBIE_PIG_AMBIENT, Sound.ENTITY_ZOMBIE_PIG_ANGRY),
|
||||
PLAYER(Sound.ENTITY_PLAYER_HURT, "step.grass", Sound.ENTITY_PLAYER_DEATH, null),
|
||||
RABBIT(Sound.ENTITY_RABBIT_HURT, Sound.ENTITY_RABBIT_JUMP, Sound.ENTITY_RABBIT_DEATH, Sound.ENTITY_RABBIT_AMBIENT),
|
||||
SHEEP(Sound.ENTITY_SHEEP_HURT, Sound.ENTITY_SHEEP_STEP, null, Sound.ENTITY_SHEEP_AMBIENT, Sound.ENTITY_SHEEP_SHEAR),
|
||||
SHULKER(Sound.ENTITY_SHULKER_HURT, null, Sound.ENTITY_SHULKER_DEATH, Sound.ENTITY_SHULKER_AMBIENT, Sound.ENTITY_SHULKER_OPEN,
|
||||
Sound.ENTITY_SHULKER_CLOSE, Sound.ENTITY_SHULKER_HURT_CLOSED, Sound.ENTITY_SHULKER_TELEPORT),
|
||||
SILVERFISH(Sound.ENTITY_SILVERFISH_HURT, Sound.ENTITY_SILVERFISH_STEP, Sound.ENTITY_SILVERFISH_DEATH, Sound.ENTITY_SILVERFISH_AMBIENT),
|
||||
SKELETON(Sound.ENTITY_SKELETON_HURT, Sound.ENTITY_SKELETON_STEP, Sound.ENTITY_SKELETON_DEATH, Sound.ENTITY_SKELETON_AMBIENT),
|
||||
SKELETON_HORSE(Sound.ENTITY_SKELETON_HORSE_HURT, "step.grass", Sound.ENTITY_SKELETON_HORSE_DEATH, Sound.ENTITY_SKELETON_HORSE_AMBIENT,
|
||||
Sound.ENTITY_HORSE_GALLOP,
|
||||
Sound.ENTITY_HORSE_SADDLE, Sound.ENTITY_DONKEY_ANGRY, Sound.ENTITY_HORSE_STEP_WOOD, Sound.ENTITY_HORSE_ARMOR,
|
||||
Sound.ENTITY_HORSE_LAND, Sound.ENTITY_HORSE_JUMP, Sound.ENTITY_HORSE_ANGRY),
|
||||
SLIME(Sound.ENTITY_SLIME_HURT, Sound.ENTITY_SLIME_JUMP, Sound.ENTITY_SLIME_DEATH, null),
|
||||
SNOWMAN(Sound.ENTITY_SNOWMAN_HURT, null, Sound.ENTITY_SNOWMAN_DEATH, Sound.ENTITY_SNOWMAN_AMBIENT, Sound.ENTITY_SNOWMAN_SHOOT),
|
||||
SPIDER(Sound.ENTITY_SPIDER_AMBIENT, Sound.ENTITY_SPIDER_STEP, Sound.ENTITY_SPIDER_DEATH, Sound.ENTITY_SPIDER_AMBIENT),
|
||||
SQUID(Sound.ENTITY_SQUID_HURT, null, Sound.ENTITY_SQUID_DEATH, Sound.ENTITY_SQUID_AMBIENT),
|
||||
UNDEAD_HORSE(Sound.ENTITY_ZOMBIE_HORSE_HURT, "step.grass", Sound.ENTITY_ZOMBIE_HORSE_DEATH, Sound.ENTITY_ZOMBIE_HORSE_AMBIENT, Sound.ENTITY_HORSE_GALLOP,
|
||||
Sound.ENTITY_HORSE_SADDLE, Sound.ENTITY_DONKEY_ANGRY, Sound.ENTITY_HORSE_STEP_WOOD, Sound.ENTITY_HORSE_ARMOR,
|
||||
Sound.ENTITY_HORSE_LAND, Sound.ENTITY_HORSE_JUMP, Sound.ENTITY_HORSE_ANGRY),
|
||||
VILLAGER(Sound.ENTITY_VILLAGER_HURT, null, Sound.ENTITY_VILLAGER_DEATH, Sound.ENTITY_VILLAGER_AMBIENT, Sound.ENTITY_VILLAGER_TRADING, Sound.ENTITY_VILLAGER_NO,
|
||||
Sound.ENTITY_VILLAGER_YES),
|
||||
WITCH(Sound.ENTITY_WITCH_HURT, null, Sound.ENTITY_WITCH_DEATH, Sound.ENTITY_WITCH_AMBIENT),
|
||||
WITHER(Sound.ENTITY_WITHER_HURT, null, Sound.ENTITY_WITHER_DEATH, Sound.ENTITY_WITHER_AMBIENT, Sound.ENTITY_PLAYER_SMALL_FALL, Sound.ENTITY_WITHER_SPAWN,
|
||||
Sound.ENTITY_PLAYER_BIG_FALL, Sound.ENTITY_WITHER_SHOOT),
|
||||
WITHER_SKELETON(Sound.ENTITY_SKELETON_HURT, Sound.ENTITY_SKELETON_STEP, Sound.ENTITY_SKELETON_DEATH, Sound.ENTITY_SKELETON_AMBIENT),
|
||||
WOLF(Sound.ENTITY_WOLF_HURT, Sound.ENTITY_WOLF_STEP, Sound.ENTITY_WOLF_DEATH, Sound.ENTITY_WOLF_AMBIENT, Sound.ENTITY_WOLF_GROWL, Sound.ENTITY_WOLF_PANT,
|
||||
Sound.ENTITY_WOLF_HOWL, Sound.ENTITY_WOLF_SHAKE, Sound.ENTITY_WOLF_WHINE),
|
||||
ZOMBIE(Sound.ENTITY_ZOMBIE_HURT, Sound.ENTITY_ZOMBIE_STEP, Sound.ENTITY_ZOMBIE_DEATH, Sound.ENTITY_ZOMBIE_AMBIENT,
|
||||
Sound.ENTITY_ZOMBIE_INFECT, Sound.ENTITY_ZOMBIE_BREAK_DOOR_WOOD, Sound.ENTITY_ZOMBIE_ATTACK_DOOR_WOOD, Sound.ENTITY_ZOMBIE_ATTACK_IRON_DOOR),
|
||||
ZOMBIE_VILLAGER(Sound.ENTITY_ZOMBIE_VILLAGER_HURT, Sound.ENTITY_ZOMBIE_VILLAGER_STEP, Sound.ENTITY_ZOMBIE_VILLAGER_DEATH, Sound.ENTITY_ZOMBIE_VILLAGER_AMBIENT,
|
||||
Sound.ENTITY_ZOMBIE_INFECT, Sound.ENTITY_ZOMBIE_BREAK_DOOR_WOOD, Sound.ENTITY_ZOMBIE_ATTACK_DOOR_WOOD, Sound.ENTITY_ZOMBIE_ATTACK_IRON_DOOR);
|
||||
|
||||
public enum SoundType {
|
||||
CANCEL, DEATH, HURT, IDLE, STEP
|
||||
}
|
||||
|
||||
public static DisguiseSound getType(String name) {
|
||||
//TODO: FIX the disguise sounds
|
||||
try {
|
||||
return valueOf(name);
|
||||
} catch (Exception ex) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private HashSet<String> cancelSounds = new HashSet<>();
|
||||
private float damageSoundVolume = 1F;
|
||||
private HashMap<SoundType, String> disguiseSounds = new HashMap<>();
|
||||
|
||||
DisguiseSound(Object hurt, Object step, Object death, Object idle, Object... sounds) {
|
||||
addSound(hurt, SoundType.HURT);
|
||||
addSound(step, SoundType.STEP);
|
||||
addSound(death, SoundType.DEATH);
|
||||
addSound(idle, SoundType.IDLE);
|
||||
for (Object obj : sounds) {
|
||||
addSound(obj, SoundType.CANCEL);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private void addSound(Object sound, SoundType type) {
|
||||
String s;
|
||||
if (sound == null) {
|
||||
return;
|
||||
} else if (sound instanceof String) {
|
||||
s = (String) sound;
|
||||
} else if (sound instanceof Sound) {
|
||||
s = ReflectionManager.getCraftSound((Sound) sound);
|
||||
} else {
|
||||
throw new RuntimeException("Was given a unknown object " + sound);
|
||||
}
|
||||
switch (type) {
|
||||
case HURT:
|
||||
disguiseSounds.put(SoundType.HURT, s);
|
||||
break;
|
||||
case STEP:
|
||||
disguiseSounds.put(SoundType.STEP, s);
|
||||
break;
|
||||
case DEATH:
|
||||
disguiseSounds.put(SoundType.DEATH, s);
|
||||
break;
|
||||
case IDLE:
|
||||
disguiseSounds.put(SoundType.IDLE, s);
|
||||
break;
|
||||
case CANCEL:
|
||||
cancelSounds.add(s);
|
||||
}
|
||||
}
|
||||
|
||||
public float getDamageAndIdleSoundVolume() {
|
||||
return damageSoundVolume;
|
||||
}
|
||||
|
||||
public String getSound(SoundType type) {
|
||||
if (type == null || !disguiseSounds.containsKey(type)) {
|
||||
return null;
|
||||
}
|
||||
return disguiseSounds.get(type);
|
||||
}
|
||||
|
||||
public HashSet<String> getSoundsToCancel() {
|
||||
return cancelSounds;
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to check if this sound name is owned by this disguise sound.
|
||||
*/
|
||||
public SoundType getType(String sound, boolean ignoreDamage) {
|
||||
if (sound == null) return SoundType.CANCEL;
|
||||
if (isCancelSound(sound)) {
|
||||
return SoundType.CANCEL;
|
||||
}
|
||||
if (disguiseSounds.containsKey(SoundType.STEP) && disguiseSounds.get(SoundType.STEP).startsWith("step.")
|
||||
&& sound.startsWith("step.")) {
|
||||
return SoundType.STEP;
|
||||
}
|
||||
for (SoundType type : SoundType.values()) {
|
||||
if (!disguiseSounds.containsKey(type) || type == SoundType.DEATH || (ignoreDamage && type == SoundType.HURT)) {
|
||||
continue;
|
||||
}
|
||||
String s = disguiseSounds.get(type);
|
||||
if (s != null) {
|
||||
if (s.equals(sound)) {
|
||||
return type;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean isCancelSound(String sound) {
|
||||
return getSoundsToCancel().contains(sound);
|
||||
}
|
||||
|
||||
public void removeSound(SoundType type, Sound sound) {
|
||||
removeSound(type, ReflectionManager.getCraftSound(sound));
|
||||
}
|
||||
|
||||
public void removeSound(SoundType type, String sound) {
|
||||
if (type == SoundType.CANCEL) {
|
||||
cancelSounds.remove(sound);
|
||||
} else {
|
||||
disguiseSounds.remove(type);
|
||||
}
|
||||
}
|
||||
|
||||
public void setDamageAndIdleSoundVolume(float strength) {
|
||||
this.damageSoundVolume = strength;
|
||||
}
|
||||
|
||||
public void setSound(SoundType type, Sound sound) {
|
||||
setSound(type, ReflectionManager.getCraftSound(sound));
|
||||
}
|
||||
|
||||
public void setSound(SoundType type, String sound) {
|
||||
if (type == SoundType.CANCEL) {
|
||||
cancelSounds.add(sound);
|
||||
} else {
|
||||
disguiseSounds.put(type, sound);
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,146 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
public class DisguiseValues {
|
||||
|
||||
private static HashMap<DisguiseType, DisguiseValues> values = new HashMap<>();
|
||||
|
||||
public static DisguiseValues getDisguiseValues(DisguiseType type) {
|
||||
switch (type) {
|
||||
case DONKEY:
|
||||
case MULE:
|
||||
case UNDEAD_HORSE:
|
||||
case SKELETON_HORSE:
|
||||
type = DisguiseType.HORSE;
|
||||
break;
|
||||
case MINECART_CHEST:
|
||||
case MINECART_COMMAND:
|
||||
case MINECART_FURNACE:
|
||||
case MINECART_HOPPER:
|
||||
case MINECART_TNT:
|
||||
case MINECART_MOB_SPAWNER:
|
||||
type = DisguiseType.MINECART;
|
||||
break;
|
||||
case WITHER_SKELETON:
|
||||
type = DisguiseType.SKELETON;
|
||||
break;
|
||||
case ZOMBIE_VILLAGER:
|
||||
type = DisguiseType.ZOMBIE;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return values.get(type);
|
||||
}
|
||||
|
||||
public static HashMap<Integer, Object> getMetaValues(DisguiseType type) {
|
||||
return getDisguiseValues(type).getMetaValues();
|
||||
}
|
||||
|
||||
public static Class getNmsEntityClass(DisguiseType type) {
|
||||
return getDisguiseValues(type).getNmsEntityClass();
|
||||
}
|
||||
|
||||
private FakeBoundingBox adultBox;
|
||||
private FakeBoundingBox babyBox;
|
||||
private float[] entitySize;
|
||||
private int enumEntitySize;
|
||||
private double maxHealth;
|
||||
private HashMap<Integer, Object> metaValues = new HashMap<>();
|
||||
private Class nmsEntityClass;
|
||||
|
||||
@SuppressWarnings("LeakingThisInConstructor")
|
||||
public DisguiseValues(DisguiseType type, Class classType, int entitySize, double maxHealth) {
|
||||
values.put(type, this);
|
||||
enumEntitySize = entitySize;
|
||||
nmsEntityClass = classType;
|
||||
this.maxHealth = maxHealth;
|
||||
}
|
||||
|
||||
public FakeBoundingBox getAdultBox() {
|
||||
return adultBox;
|
||||
}
|
||||
|
||||
public FakeBoundingBox getBabyBox() {
|
||||
return babyBox;
|
||||
}
|
||||
|
||||
public float[] getEntitySize() {
|
||||
return entitySize;
|
||||
}
|
||||
|
||||
public int getEntitySize(double paramDouble) {
|
||||
double d = paramDouble - (((int) Math.floor(paramDouble)) + 0.5D);
|
||||
|
||||
switch (enumEntitySize) {
|
||||
case 1:
|
||||
if (d < 0.0D ? d < -0.3125D : d < 0.3125D) {
|
||||
return (int) Math.ceil(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
return (int) Math.floor(paramDouble * 32.0D);
|
||||
case 2:
|
||||
if (d < 0.0D ? d < -0.3125D : d < 0.3125D) {
|
||||
return (int) Math.floor(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
return (int) Math.ceil(paramDouble * 32.0D);
|
||||
case 3:
|
||||
if (d > 0.0D) {
|
||||
return (int) Math.floor(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
return (int) Math.ceil(paramDouble * 32.0D);
|
||||
case 4:
|
||||
if (d < 0.0D ? d < -0.1875D : d < 0.1875D) {
|
||||
return (int) Math.ceil(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
return (int) Math.floor(paramDouble * 32.0D);
|
||||
case 5:
|
||||
if (d < 0.0D ? d < -0.1875D : d < 0.1875D) {
|
||||
return (int) Math.floor(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
return (int) Math.ceil(paramDouble * 32.0D);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (d > 0.0D) {
|
||||
return (int) Math.ceil(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
return (int) Math.floor(paramDouble * 32.0D);
|
||||
}
|
||||
|
||||
public double getMaxHealth() {
|
||||
return maxHealth;
|
||||
}
|
||||
|
||||
public HashMap<Integer, Object> getMetaValues() {
|
||||
return metaValues;
|
||||
}
|
||||
|
||||
public Class getNmsEntityClass() {
|
||||
return nmsEntityClass;
|
||||
}
|
||||
|
||||
public void setAdultBox(FakeBoundingBox newBox) {
|
||||
adultBox = newBox;
|
||||
}
|
||||
|
||||
public void setBabyBox(FakeBoundingBox newBox) {
|
||||
babyBox = newBox;
|
||||
}
|
||||
|
||||
public void setEntitySize(float[] size) {
|
||||
this.entitySize = size;
|
||||
}
|
||||
|
||||
public void setMetaValue(int id, Object value) {
|
||||
metaValues.put(id, value);
|
||||
}
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
public class FakeBoundingBox {
|
||||
|
||||
private double xMod;
|
||||
private double yMod;
|
||||
private double zMod;
|
||||
|
||||
public FakeBoundingBox(double xMod, double yMod, double zMod) {
|
||||
this.xMod = xMod;
|
||||
this.yMod = yMod;
|
||||
this.zMod = zMod;
|
||||
}
|
||||
|
||||
public double getX() {
|
||||
return xMod / 2;
|
||||
}
|
||||
|
||||
public double getY() {
|
||||
return yMod;
|
||||
}
|
||||
|
||||
public double getZ() {
|
||||
return zMod / 2;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,9 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
||||
|
||||
public interface LibsProfileLookup {
|
||||
|
||||
void onLookup(WrappedGameProfile gameProfile);
|
||||
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
||||
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import com.mojang.authlib.ProfileLookupCallback;
|
||||
|
||||
public class LibsProfileLookupCaller implements ProfileLookupCallback {
|
||||
|
||||
private WrappedGameProfile gameProfile;
|
||||
|
||||
public WrappedGameProfile getGameProfile() {
|
||||
return gameProfile;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onProfileLookupFailed(GameProfile gameProfile, Exception arg1) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onProfileLookupSucceeded(GameProfile profile) {
|
||||
gameProfile = WrappedGameProfile.fromHandle(profile);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,672 +0,0 @@
|
||||
/*
|
||||
* Copyright 2011-2013 Tyler Blair. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are
|
||||
* permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* The views and conclusions contained in the software and documentation are those of the
|
||||
* authors and contributors and should not be interpreted as representing official policies,
|
||||
* either expressed or implied, of anybody else.
|
||||
*/
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.configuration.InvalidConfigurationException;
|
||||
import org.bukkit.configuration.file.YamlConfiguration;
|
||||
import org.bukkit.plugin.Plugin;
|
||||
import org.bukkit.plugin.PluginDescriptionFile;
|
||||
import org.bukkit.scheduler.BukkitTask;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.OutputStream;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.net.Proxy;
|
||||
import java.net.URL;
|
||||
import java.net.URLConnection;
|
||||
import java.net.URLEncoder;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
import java.util.logging.Level;
|
||||
import java.util.zip.GZIPOutputStream;
|
||||
|
||||
public class Metrics {
|
||||
|
||||
/**
|
||||
* The current revision number
|
||||
*/
|
||||
private final static int REVISION = 7;
|
||||
/**
|
||||
* The base url of the metrics domain
|
||||
*/
|
||||
private static final String BASE_URL = "http://report.mcstats.org";
|
||||
/**
|
||||
* The url used to report a server's status
|
||||
*/
|
||||
private static final String REPORT_URL = "/plugin/%s";
|
||||
/**
|
||||
* Interval of time to ping (in minutes)
|
||||
*/
|
||||
private static final int PING_INTERVAL = 15;
|
||||
/**
|
||||
* The plugin this metrics submits for
|
||||
*/
|
||||
private final Plugin plugin;
|
||||
/**
|
||||
* All of the custom graphs to submit to metrics
|
||||
*/
|
||||
private final Set<Graph> graphs = Collections.synchronizedSet(new HashSet<Graph>());
|
||||
/**
|
||||
* The plugin configuration file
|
||||
*/
|
||||
private final YamlConfiguration configuration;
|
||||
/**
|
||||
* The plugin configuration file
|
||||
*/
|
||||
private final File configurationFile;
|
||||
/**
|
||||
* Unique server id
|
||||
*/
|
||||
private final String guid;
|
||||
/**
|
||||
* Debug mode
|
||||
*/
|
||||
private final boolean debug;
|
||||
/**
|
||||
* Lock for synchronization
|
||||
*/
|
||||
private final Object optOutLock = new Object();
|
||||
/**
|
||||
* The scheduled task
|
||||
*/
|
||||
private volatile BukkitTask task = null;
|
||||
|
||||
public Metrics(final Plugin plugin) throws IOException {
|
||||
if (plugin == null) {
|
||||
throw new IllegalArgumentException("Plugin cannot be null");
|
||||
}
|
||||
this.plugin = plugin;
|
||||
// load the config
|
||||
configurationFile = getConfigFile();
|
||||
configuration = YamlConfiguration.loadConfiguration(configurationFile);
|
||||
// add some defaults
|
||||
configuration.addDefault("opt-out", false);
|
||||
configuration.addDefault("guid", UUID.randomUUID().toString());
|
||||
configuration.addDefault("debug", false);
|
||||
// Do we need to create the file?
|
||||
if (configuration.get("guid", null) == null) {
|
||||
configuration.options().header("http://mcstats.org").copyDefaults(true);
|
||||
configuration.save(configurationFile);
|
||||
}
|
||||
// Load the guid then
|
||||
guid = configuration.getString("guid");
|
||||
debug = configuration.getBoolean("debug", false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct and create a Graph that can be used to separate specific plotters to their own graphs on the metrics website. Plotters can be added to the graph object returned.
|
||||
*
|
||||
* @param name The name of the graph
|
||||
* @return Graph object created. Will never return NULL under normal circumstances unless bad parameters are given
|
||||
*/
|
||||
public Graph createGraph(final String name) {
|
||||
if (name == null) {
|
||||
throw new IllegalArgumentException("Graph name cannot be null");
|
||||
}
|
||||
// Construct the graph object
|
||||
final Graph graph = new Graph(name);
|
||||
// Now we can add our graph
|
||||
graphs.add(graph);
|
||||
// and return back
|
||||
return graph;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a Graph object to BukkitMetrics that represents data for the plugin that should be sent to the backend
|
||||
*
|
||||
* @param graph The name of the graph
|
||||
*/
|
||||
public void addGraph(final Graph graph) {
|
||||
if (graph == null) {
|
||||
throw new IllegalArgumentException("Graph cannot be null");
|
||||
}
|
||||
graphs.add(graph);
|
||||
}
|
||||
|
||||
/**
|
||||
* Start measuring statistics. This will immediately create an async repeating task as the plugin and send the initial data to the metrics backend, and then after that it will post in increments of PING_INTERVAL * 1200 ticks.
|
||||
*
|
||||
* @return True if statistics measuring is running, otherwise false.
|
||||
*/
|
||||
public boolean start() {
|
||||
synchronized (optOutLock) {
|
||||
// Did we opt out?
|
||||
if (isOptOut()) {
|
||||
return false;
|
||||
}
|
||||
// Is metrics already running?
|
||||
if (task != null) {
|
||||
return true;
|
||||
}
|
||||
// Begin hitting the server with glorious data
|
||||
task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
|
||||
private boolean firstPost = true;
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
// This has to be synchronized or it can collide with the disable method.
|
||||
synchronized (optOutLock) {
|
||||
// Disable Task, if it is running and the server owner decided to opt-out
|
||||
if (isOptOut() && task != null) {
|
||||
task.cancel();
|
||||
task = null;
|
||||
// Tell all plotters to stop gathering information.
|
||||
for (Graph graph : graphs) {
|
||||
graph.onOptOut();
|
||||
}
|
||||
}
|
||||
}
|
||||
// We use the inverse of firstPost because if it is the first time we are posting,
|
||||
// it is not a interval ping, so it evaluates to FALSE
|
||||
// Each time thereafter it will evaluate to TRUE, i.e PING!
|
||||
postPlugin(!firstPost);
|
||||
// After the first post we set firstPost to false
|
||||
// Each post thereafter will be a ping
|
||||
firstPost = false;
|
||||
} catch (IOException e) {
|
||||
if (debug) {
|
||||
Bukkit.getLogger().log(Level.INFO, "[Metrics] " + e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
}, 0, PING_INTERVAL * 1200);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Has the server owner denied plugin metrics?
|
||||
*
|
||||
* @return true if metrics should be opted out of it
|
||||
*/
|
||||
public boolean isOptOut() {
|
||||
synchronized (optOutLock) {
|
||||
try {
|
||||
// Reload the metrics file
|
||||
configuration.load(getConfigFile());
|
||||
} catch (IOException | InvalidConfigurationException ex) {
|
||||
if (debug) {
|
||||
Bukkit.getLogger().log(Level.INFO, "[Metrics] " + ex.getMessage());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return configuration.getBoolean("opt-out", false);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Enables metrics for the server by setting "opt-out" to false in the config file and starting the metrics task.
|
||||
*
|
||||
* @throws java.io.IOException
|
||||
*/
|
||||
public void enable() throws IOException {
|
||||
// This has to be synchronized or it can collide with the check in the task.
|
||||
synchronized (optOutLock) {
|
||||
// Check if the server owner has already set opt-out, if not, set it.
|
||||
if (isOptOut()) {
|
||||
configuration.set("opt-out", false);
|
||||
configuration.save(configurationFile);
|
||||
}
|
||||
// Enable Task, if it is not running
|
||||
if (task == null) {
|
||||
start();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Disables metrics for the server by setting "opt-out" to true in the config file and canceling the metrics task.
|
||||
*
|
||||
* @throws java.io.IOException
|
||||
*/
|
||||
public void disable() throws IOException {
|
||||
// This has to be synchronized or it can collide with the check in the task.
|
||||
synchronized (optOutLock) {
|
||||
// Check if the server owner has already set opt-out, if not, set it.
|
||||
if (!isOptOut()) {
|
||||
configuration.set("opt-out", true);
|
||||
configuration.save(configurationFile);
|
||||
}
|
||||
// Disable Task, if it is running
|
||||
if (task != null) {
|
||||
task.cancel();
|
||||
task = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the File object of the config file that should be used to store data such as the GUID and opt-out status
|
||||
*
|
||||
* @return the File object for the config file
|
||||
*/
|
||||
public File getConfigFile() {
|
||||
// I believe the easiest way to get the base folder (e.g Spigot set via -P) for plugins to use
|
||||
// is to abuse the plugin object we already have
|
||||
// plugin.getDataFolder() => base/plugins/PluginA/
|
||||
// pluginsFolder => base/plugins/
|
||||
// The base is not necessarily relative to the startup directory.
|
||||
File pluginsFolder = plugin.getDataFolder().getParentFile();
|
||||
// return => base/plugins/PluginMetrics/config.yml
|
||||
return new File(new File(pluginsFolder, "PluginMetrics"), "config.yml");
|
||||
}
|
||||
|
||||
/**
|
||||
* Generic method that posts a plugin to the metrics website
|
||||
*/
|
||||
private void postPlugin(final boolean isPing) throws IOException {
|
||||
// Server software specific section
|
||||
PluginDescriptionFile description = plugin.getDescription();
|
||||
String pluginName = description.getName();
|
||||
boolean onlineMode = Bukkit.getServer().getOnlineMode(); // TRUE if online mode is enabled
|
||||
String pluginVersion = description.getVersion();
|
||||
String serverVersion = Bukkit.getVersion();
|
||||
int playersOnline = Bukkit.getServer().getOnlinePlayers().size();
|
||||
// END server software specific section -- all code below does not use any code outside of this class / Java
|
||||
// Construct the post data
|
||||
StringBuilder json = new StringBuilder(1024);
|
||||
json.append('{');
|
||||
// The plugin's description file containg all of the plugin data such as name, version, author, etc
|
||||
appendJSONPair(json, "guid", guid);
|
||||
appendJSONPair(json, "plugin_version", pluginVersion);
|
||||
appendJSONPair(json, "server_version", serverVersion);
|
||||
appendJSONPair(json, "players_online", Integer.toString(playersOnline));
|
||||
// New data as of R6
|
||||
String osname = System.getProperty("os.name");
|
||||
String osarch = System.getProperty("os.arch");
|
||||
String osversion = System.getProperty("os.version");
|
||||
String java_version = System.getProperty("java.version");
|
||||
int coreCount = Runtime.getRuntime().availableProcessors();
|
||||
// normalize os arch .. amd64 -> x86_64
|
||||
if (osarch.equals("amd64")) {
|
||||
osarch = "x86_64";
|
||||
}
|
||||
appendJSONPair(json, "osname", osname);
|
||||
appendJSONPair(json, "osarch", osarch);
|
||||
appendJSONPair(json, "osversion", osversion);
|
||||
appendJSONPair(json, "cores", Integer.toString(coreCount));
|
||||
appendJSONPair(json, "auth_mode", onlineMode ? "1" : "0");
|
||||
appendJSONPair(json, "java_version", java_version);
|
||||
// If we're pinging, append it
|
||||
if (isPing) {
|
||||
appendJSONPair(json, "ping", "1");
|
||||
}
|
||||
if (graphs.size() > 0) {
|
||||
synchronized (graphs) {
|
||||
json.append(',');
|
||||
json.append('"');
|
||||
json.append("graphs");
|
||||
json.append('"');
|
||||
json.append(':');
|
||||
json.append('{');
|
||||
boolean firstGraph = true;
|
||||
for (Graph graph : graphs) {
|
||||
StringBuilder graphJson = new StringBuilder();
|
||||
graphJson.append('{');
|
||||
for (Plotter plotter : graph.getPlotters()) {
|
||||
appendJSONPair(graphJson, plotter.getColumnName(), Integer.toString(plotter.getValue()));
|
||||
}
|
||||
graphJson.append('}');
|
||||
if (!firstGraph) {
|
||||
json.append(',');
|
||||
}
|
||||
json.append(escapeJSON(graph.getName()));
|
||||
json.append(':');
|
||||
json.append(graphJson);
|
||||
firstGraph = false;
|
||||
}
|
||||
json.append('}');
|
||||
}
|
||||
}
|
||||
// close json
|
||||
json.append('}');
|
||||
// Create the url
|
||||
URL url = new URL(BASE_URL + String.format(REPORT_URL, urlEncode(pluginName)));
|
||||
// Connect to the website
|
||||
URLConnection connection;
|
||||
// Mineshafter creates a socks proxy, so we can safely bypass it
|
||||
// It does not reroute POST requests so we need to go around it
|
||||
if (isMineshafterPresent()) {
|
||||
connection = url.openConnection(Proxy.NO_PROXY);
|
||||
} else {
|
||||
connection = url.openConnection();
|
||||
}
|
||||
byte[] uncompressed = json.toString().getBytes();
|
||||
byte[] compressed = gzip(json.toString());
|
||||
// Headers
|
||||
connection.addRequestProperty("User-Agent", "MCStats/" + REVISION);
|
||||
connection.addRequestProperty("Content-Type", "application/json");
|
||||
connection.addRequestProperty("Content-Encoding", "gzip");
|
||||
connection.addRequestProperty("Content-Length", Integer.toString(compressed.length));
|
||||
connection.addRequestProperty("Accept", "application/json");
|
||||
connection.addRequestProperty("Connection", "close");
|
||||
connection.setDoOutput(true);
|
||||
if (debug) {
|
||||
System.out.println("[Metrics] Prepared request for " + pluginName + " uncompressed=" + uncompressed.length + " compressed=" + compressed.length);
|
||||
}
|
||||
// Write the data
|
||||
OutputStream os = connection.getOutputStream();
|
||||
os.write(compressed);
|
||||
os.flush();
|
||||
String response;
|
||||
try ( // Now read the response
|
||||
BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
|
||||
response = reader.readLine();
|
||||
// close resources
|
||||
os.close();
|
||||
}
|
||||
if (response == null || response.startsWith("ERR") || response.startsWith("7")) {
|
||||
if (response == null) {
|
||||
response = "null";
|
||||
} else if (response.startsWith("7")) {
|
||||
response = response.substring(response.startsWith("7,") ? 2 : 1);
|
||||
}
|
||||
throw new IOException(response);
|
||||
} else {
|
||||
// Is this the first update this hour?
|
||||
if (response.equals("1") || response.contains("This is your first update this hour")) {
|
||||
synchronized (graphs) {
|
||||
for (Graph graph : graphs) {
|
||||
for (Plotter plotter : graph.getPlotters()) {
|
||||
plotter.reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* GZip compress a string of bytes
|
||||
*
|
||||
* @param input
|
||||
* @return byte[]
|
||||
*/
|
||||
public static byte[] gzip(String input) {
|
||||
ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
||||
GZIPOutputStream gzos = null;
|
||||
try {
|
||||
gzos = new GZIPOutputStream(baos);
|
||||
gzos.write(input.getBytes("UTF-8"));
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace(System.out);
|
||||
} finally {
|
||||
if (gzos != null) {
|
||||
try {
|
||||
gzos.close();
|
||||
} catch (IOException ignore) {
|
||||
}
|
||||
}
|
||||
}
|
||||
return baos.toByteArray();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if mineshafter is present. If it is, we need to bypass it to send POST requests
|
||||
*
|
||||
* @return true if mineshafter is installed on the server
|
||||
*/
|
||||
private boolean isMineshafterPresent() {
|
||||
try {
|
||||
Class.forName("mineshafter.MineServer");
|
||||
return true;
|
||||
} catch (Exception e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends a json encoded key/value pair to the given string builder.
|
||||
*
|
||||
* @param json
|
||||
* @param key
|
||||
* @param value
|
||||
* @throws UnsupportedEncodingException
|
||||
*/
|
||||
private static void appendJSONPair(StringBuilder json, String key, String value) throws UnsupportedEncodingException {
|
||||
boolean isValueNumeric = false;
|
||||
try {
|
||||
if (value.equals("0") || !value.endsWith("0")) {
|
||||
Double.parseDouble(value);
|
||||
isValueNumeric = true;
|
||||
}
|
||||
} catch (NumberFormatException e) {
|
||||
isValueNumeric = false;
|
||||
}
|
||||
if (json.charAt(json.length() - 1) != '{') {
|
||||
json.append(',');
|
||||
}
|
||||
json.append(escapeJSON(key));
|
||||
json.append(':');
|
||||
if (isValueNumeric) {
|
||||
json.append(value);
|
||||
} else {
|
||||
json.append(escapeJSON(value));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape a string to create a valid JSON string
|
||||
*
|
||||
* @param text
|
||||
* @return String
|
||||
*/
|
||||
private static String escapeJSON(String text) {
|
||||
StringBuilder builder = new StringBuilder();
|
||||
builder.append('"');
|
||||
for (int index = 0; index < text.length(); index++) {
|
||||
char chr = text.charAt(index);
|
||||
switch (chr) {
|
||||
case '"':
|
||||
case '\\':
|
||||
builder.append('\\');
|
||||
builder.append(chr);
|
||||
break;
|
||||
case '\b':
|
||||
builder.append("\\b");
|
||||
break;
|
||||
case '\t':
|
||||
builder.append("\\t");
|
||||
break;
|
||||
case '\n':
|
||||
builder.append("\\n");
|
||||
break;
|
||||
case '\r':
|
||||
builder.append("\\r");
|
||||
break;
|
||||
default:
|
||||
if (chr < ' ') {
|
||||
String t = "000" + Integer.toHexString(chr);
|
||||
builder.append("\\u").append(t.substring(t.length() - 4));
|
||||
} else {
|
||||
builder.append(chr);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
builder.append('"');
|
||||
return builder.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode text as UTF-8
|
||||
*
|
||||
* @param text the text to encode
|
||||
* @return the encoded text, as UTF-8
|
||||
*/
|
||||
private static String urlEncode(final String text) throws UnsupportedEncodingException {
|
||||
return URLEncoder.encode(text, "UTF-8");
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a custom graph on the website
|
||||
*/
|
||||
public static class Graph {
|
||||
|
||||
/**
|
||||
* The graph's name, alphanumeric and spaces only :) If it does not comply to the above when submitted, it is rejected
|
||||
*/
|
||||
private final String name;
|
||||
/**
|
||||
* The set of plotters that are contained within this graph
|
||||
*/
|
||||
private final Set<Plotter> plotters = new LinkedHashSet<>();
|
||||
|
||||
private Graph(final String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the graph's name
|
||||
*
|
||||
* @return the Graph's name
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a plotter to the graph, which will be used to plot entries
|
||||
*
|
||||
* @param plotter the plotter to add to the graph
|
||||
*/
|
||||
public void addPlotter(final Plotter plotter) {
|
||||
plotters.add(plotter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a plotter from the graph
|
||||
*
|
||||
* @param plotter the plotter to remove from the graph
|
||||
*/
|
||||
public void removePlotter(final Plotter plotter) {
|
||||
plotters.remove(plotter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an <b>unmodifiable</b> set of the plotter objects in the graph
|
||||
*
|
||||
* @return an unmodifiable {@link java.util.Set} of the plotter objects
|
||||
*/
|
||||
public Set<Plotter> getPlotters() {
|
||||
return Collections.unmodifiableSet(plotters);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return name.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object object) {
|
||||
if (!(object instanceof Graph)) {
|
||||
return false;
|
||||
}
|
||||
final Graph graph = (Graph) object;
|
||||
return graph.name.equals(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when the server owner decides to opt-out of BukkitMetrics while the server is running.
|
||||
*/
|
||||
protected void onOptOut() {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Interface used to collect custom data for a plugin
|
||||
*/
|
||||
public static abstract class Plotter {
|
||||
|
||||
/**
|
||||
* The plot's name
|
||||
*/
|
||||
private final String name;
|
||||
|
||||
/**
|
||||
* Construct a plotter with the default plot name
|
||||
*/
|
||||
public Plotter() {
|
||||
this("Default");
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a plotter with a specific plot name
|
||||
*
|
||||
* @param name the name of the plotter to use, which will show up on the website
|
||||
*/
|
||||
public Plotter(final String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current value for the plotted point. Since this function defers to an external function it may or may not return immediately thus cannot be guaranteed to be thread friendly or safe. This function can be called from any thread so care should be taken when accessing resources that need to be synchronized.
|
||||
*
|
||||
* @return the current value for the point to be plotted.
|
||||
*/
|
||||
public abstract int getValue();
|
||||
|
||||
/**
|
||||
* Get the column name for the plotted point
|
||||
*
|
||||
* @return the plotted point's column name
|
||||
*/
|
||||
public String getColumnName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called after the website graphs have been updated
|
||||
*/
|
||||
public void reset() {
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return getColumnName().hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object object) {
|
||||
if (!(object instanceof Plotter)) {
|
||||
return false;
|
||||
}
|
||||
final Plotter plotter = (Plotter) object;
|
||||
return plotter.name.equals(name) && plotter.getValue() == getValue();
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,727 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import com.comphenix.protocol.wrappers.MinecraftKey;
|
||||
import com.comphenix.protocol.wrappers.WrappedDataWatcher.Registry;
|
||||
import com.comphenix.protocol.wrappers.WrappedDataWatcher.Serializer;
|
||||
import com.comphenix.protocol.wrappers.WrappedDataWatcher.WrappedDataWatcherObject;
|
||||
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import org.apache.commons.lang3.tuple.ImmutablePair;
|
||||
import org.apache.commons.lang3.tuple.Pair;
|
||||
import org.bukkit.Art;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.Sound;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.EntityEquipment;
|
||||
import org.bukkit.inventory.EquipmentSlot;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.potion.PotionEffect;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
public class ReflectionManager {
|
||||
|
||||
private static final String bukkitVersion = Bukkit.getServer().getClass().getName().split("\\.")[3];
|
||||
private static final Class<?> craftItemClass;
|
||||
private static Method damageAndIdleSoundMethod;
|
||||
private static final Field entitiesField;
|
||||
private static final Constructor<?> boundingBoxConstructor;
|
||||
private static final Method setBoundingBoxMethod;
|
||||
private static final Method ihmGet;
|
||||
private static final Field pingField;
|
||||
private static Map<Class<?>, String> primitiveTypes;
|
||||
private static final Field trackerField;
|
||||
public static final Field entityCountField;
|
||||
|
||||
/*
|
||||
* This portion of code is originally Copyright (C) 2014-2014 Kane York.
|
||||
*
|
||||
* In addition to the implicit license granted to libraryaddict to redistribuite the code, the
|
||||
* code is also licensed to the public under the BSD 2-clause license.
|
||||
*
|
||||
* The publicly licensed version may be viewed here: https://gist.github.com/riking/2f330f831c30e2276df7
|
||||
*/
|
||||
static {
|
||||
primitiveTypes = ImmutableMap.<Class<?>, String>builder().put(boolean.class, "Z").put(byte.class, "B")
|
||||
.put(char.class, "C").put(short.class, "S").put(int.class, "I").put(long.class, "J").put(float.class, "F")
|
||||
.put(double.class, "D").put(void.class, "V").build();
|
||||
}
|
||||
|
||||
static {
|
||||
for (Method method : getNmsClass("EntityLiving").getDeclaredMethods()) {
|
||||
try {
|
||||
if (method.getReturnType() == float.class && Modifier.isProtected(method.getModifiers())
|
||||
&& method.getParameterTypes().length == 0) {
|
||||
Object entity = createEntityInstance("Cow");
|
||||
method.setAccessible(true);
|
||||
float value = (Float) method.invoke(entity);
|
||||
if (value == 0.4F) {
|
||||
damageAndIdleSoundMethod = method;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
craftItemClass = getCraftClass("inventory.CraftItemStack");
|
||||
pingField = getNmsField("EntityPlayer", "ping");
|
||||
trackerField = getNmsField("WorldServer", "tracker");
|
||||
entitiesField = getNmsField("EntityTracker", "trackedEntities");
|
||||
ihmGet = getNmsMethod("IntHashMap", "get", int.class);
|
||||
boundingBoxConstructor = getNmsConstructor("AxisAlignedBB", double.class, double.class, double.class,
|
||||
double.class, double.class, double.class);
|
||||
setBoundingBoxMethod = getNmsMethod("Entity", "a", getNmsClass("AxisAlignedBB"));
|
||||
entityCountField = getNmsField("Entity", "entityCount");
|
||||
entityCountField.setAccessible(true);
|
||||
}
|
||||
|
||||
public static Object createEntityInstance(String entityName) {
|
||||
try {
|
||||
Class<?> entityClass = getNmsClass("Entity" + entityName);
|
||||
Object entityObject;
|
||||
Object world = getWorldServer(Bukkit.getWorlds().get(0));
|
||||
switch (entityName) {
|
||||
case "Player":
|
||||
Object minecraftServer = getNmsMethod("MinecraftServer", "getServer").invoke(null);
|
||||
Object playerinteractmanager = getNmsClass("PlayerInteractManager").getDeclaredConstructor(getNmsClass("World")).newInstance(world);
|
||||
WrappedGameProfile gameProfile = getGameProfile(null, "Steve");
|
||||
entityObject = entityClass.getDeclaredConstructor(getNmsClass("MinecraftServer"), getNmsClass("WorldServer"),
|
||||
gameProfile.getHandleType(), playerinteractmanager.getClass()).newInstance(minecraftServer, world,
|
||||
gameProfile.getHandle(), playerinteractmanager);
|
||||
break;
|
||||
case "EnderPearl":
|
||||
entityObject = entityClass.getDeclaredConstructor(getNmsClass("World"), getNmsClass("EntityLiving")).newInstance(world, createEntityInstance("Cow"));
|
||||
break;
|
||||
case "Potion":
|
||||
entityObject = entityClass.getDeclaredConstructor(getNmsClass("World"), Double.TYPE, Double.TYPE, Double.TYPE, getNmsClass("ItemStack"))
|
||||
.newInstance(world, 0d, 0d, 0d, getNmsItem(new ItemStack(Material.SPLASH_POTION)));
|
||||
break;
|
||||
default:
|
||||
entityObject = entityClass.getDeclaredConstructor(getNmsClass("World")).newInstance(world);
|
||||
break;
|
||||
}
|
||||
return entityObject;
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object getMobEffectList(int id) {
|
||||
Method nmsMethod = getNmsMethod("MobEffectList", "fromId", Integer.TYPE);
|
||||
try {
|
||||
return nmsMethod.invoke(null, id);
|
||||
} catch (IllegalAccessException | InvocationTargetException e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public static Object createMobEffect(PotionEffect effect) {
|
||||
return createMobEffect(effect.getType().getId(), effect.getDuration(), effect.getAmplifier(), effect.isAmbient(), effect.hasParticles());
|
||||
}
|
||||
|
||||
public static Object createMobEffect(int id, int duration, int amplification, boolean ambient, boolean particles) {
|
||||
try {
|
||||
return getNmsClass("MobEffect").getDeclaredConstructor(getNmsClass("MobEffectList"), Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE)
|
||||
.newInstance(getMobEffectList(id), duration, amplification, ambient, particles);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static String dir2fqn(String s) {
|
||||
return s.replaceAll("/", ".");
|
||||
}
|
||||
|
||||
public static FakeBoundingBox getBoundingBox(Entity entity) {
|
||||
try {
|
||||
Object boundingBox = getNmsMethod("Entity", "getBoundingBox").invoke(getNmsEntity(entity));
|
||||
double x = 0, y = 0, z = 0;
|
||||
int stage = 0;
|
||||
for (Field field : boundingBox.getClass().getDeclaredFields()) {
|
||||
if (field.getType().getSimpleName().equals("double")) {
|
||||
stage++;
|
||||
switch (stage) {
|
||||
case 1:
|
||||
x -= field.getDouble(boundingBox);
|
||||
break;
|
||||
case 2:
|
||||
y -= field.getDouble(boundingBox);
|
||||
break;
|
||||
case 3:
|
||||
z -= field.getDouble(boundingBox);
|
||||
break;
|
||||
case 4:
|
||||
x += field.getDouble(boundingBox);
|
||||
break;
|
||||
case 5:
|
||||
y += field.getDouble(boundingBox);
|
||||
break;
|
||||
case 6:
|
||||
z += field.getDouble(boundingBox);
|
||||
break;
|
||||
default:
|
||||
throw new Exception("Error while setting the bounding box, more doubles than I thought??");
|
||||
}
|
||||
}
|
||||
}
|
||||
return new FakeBoundingBox(x, y, z);
|
||||
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Entity getBukkitEntity(Object nmsEntity) {
|
||||
try {
|
||||
return (Entity) getNmsMethod("Entity", "getBukkitEntity").invoke(nmsEntity);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static ItemStack getBukkitItem(Object nmsItem) {
|
||||
try {
|
||||
return (ItemStack) craftItemClass.getMethod("asBukkitCopy", getNmsClass("ItemStack")).invoke(null, nmsItem);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static String getBukkitVersion() {
|
||||
return bukkitVersion;
|
||||
}
|
||||
|
||||
public static Class<?> getCraftClass(String className) {
|
||||
try {
|
||||
return Class.forName("org.bukkit.craftbukkit." + getBukkitVersion() + "." + className);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Constructor getCraftConstructor(Class clazz, Class<?>... parameters) {
|
||||
try {
|
||||
Constructor declaredConstructor = clazz.getDeclaredConstructor(parameters);
|
||||
declaredConstructor.setAccessible(true);
|
||||
return declaredConstructor;
|
||||
} catch (NoSuchMethodException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Constructor getCraftConstructor(String className, Class<?>... parameters) {
|
||||
return getCraftConstructor(getCraftClass(className), parameters);
|
||||
}
|
||||
|
||||
public static String getCraftSound(Sound sound) {
|
||||
try {
|
||||
return (String) getCraftClass("CraftSound").getMethod("getSound", Sound.class).invoke(null, sound);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object getEntityTrackerEntry(Entity target) throws Exception {
|
||||
Object world = getWorldServer(target.getWorld());
|
||||
Object tracker = trackerField.get(world);
|
||||
Object trackedEntities = entitiesField.get(tracker);
|
||||
return ihmGet.invoke(trackedEntities, target.getEntityId());
|
||||
}
|
||||
|
||||
public static Object getMinecraftServer() {
|
||||
try {
|
||||
return getCraftMethod("CraftServer", "getServer").invoke(Bukkit.getServer());
|
||||
} catch (IllegalAccessException | InvocationTargetException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static String getEnumArt(Art art) {
|
||||
try {
|
||||
Object enumArt = getCraftClass("CraftArt").getMethod("BukkitToNotch", Art.class).invoke(null, art);
|
||||
for (Field field : enumArt.getClass().getDeclaredFields()) {
|
||||
if (field.getType() == String.class) {
|
||||
return (String) field.get(enumArt);
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object getBlockPosition(int x, int y, int z) {
|
||||
try {
|
||||
return getNmsClass("BlockPosition").getDeclaredConstructor(int.class, int.class, int.class).newInstance(x, y, z);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Enum getEnumDirection(int direction) {
|
||||
try {
|
||||
return (Enum) getNmsMethod("EnumDirection", "fromType2", int.class).invoke(null, direction);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Enum getEnumPlayerInfoAction(int action) {
|
||||
try {
|
||||
return (Enum) getNmsClass("PacketPlayOutPlayerInfo$EnumPlayerInfoAction").getEnumConstants()[action];
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object getPlayerInfoData(Object playerInfoPacket, WrappedGameProfile gameProfile) {
|
||||
try {
|
||||
Object playerListName = getNmsClass("ChatComponentText").getDeclaredConstructor(String.class)
|
||||
.newInstance(gameProfile.getName());
|
||||
return getNmsClass("PacketPlayOutPlayerInfo$PlayerInfoData").getDeclaredConstructor(getNmsClass("PacketPlayOutPlayerInfo"),
|
||||
gameProfile.getHandleType(), int.class, getNmsClass("WorldSettings$EnumGamemode"), getNmsClass("IChatBaseComponent"))
|
||||
.newInstance(playerInfoPacket, gameProfile.getHandle(), 0,
|
||||
getNmsClass("WorldSettings$EnumGamemode").getEnumConstants()[1], playerListName);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static WrappedGameProfile getGameProfile(Player player) {
|
||||
return WrappedGameProfile.fromPlayer(player);
|
||||
}
|
||||
|
||||
public static WrappedGameProfile getGameProfile(UUID uuid, String playerName) {
|
||||
try {
|
||||
return new WrappedGameProfile(uuid != null ? uuid : UUID.randomUUID(), playerName);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static WrappedGameProfile getGameProfileWithThisSkin(UUID uuid, String playerName, WrappedGameProfile profileWithSkin) {
|
||||
try {
|
||||
WrappedGameProfile gameProfile = new WrappedGameProfile(uuid != null ? uuid : UUID.randomUUID(), playerName);
|
||||
gameProfile.getProperties().putAll(profileWithSkin.getProperties());
|
||||
return gameProfile;
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Class getNmsClass(String className) {
|
||||
try {
|
||||
return Class.forName("net.minecraft.server." + getBukkitVersion() + "." + className);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Constructor getNmsConstructor(Class clazz, Class<?>... parameters) {
|
||||
try {
|
||||
Constructor declaredConstructor = clazz.getDeclaredConstructor(parameters);
|
||||
declaredConstructor.setAccessible(true);
|
||||
return declaredConstructor;
|
||||
} catch (NoSuchMethodException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Constructor getNmsConstructor(String className, Class<?>... parameters) {
|
||||
return getNmsConstructor(getNmsClass(className), parameters);
|
||||
}
|
||||
|
||||
public static Object getNmsEntity(Entity entity) {
|
||||
try {
|
||||
return getCraftClass("entity.CraftEntity").getMethod("getHandle").invoke(entity);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Field getNmsField(Class clazz, String fieldName) {
|
||||
try {
|
||||
Field declaredField = clazz.getDeclaredField(fieldName);
|
||||
declaredField.setAccessible(true);
|
||||
return declaredField;
|
||||
} catch (NoSuchFieldException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Field getNmsField(String className, String fieldName) {
|
||||
return getNmsField(getNmsClass(className), fieldName);
|
||||
}
|
||||
|
||||
public static Object getNmsItem(ItemStack itemstack) {
|
||||
try {
|
||||
return craftItemClass.getDeclaredMethod("asNMSCopy", ItemStack.class).invoke(null, itemstack);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Method getCraftMethod(String className, String methodName, Class<?>... parameters) {
|
||||
return getCraftMethod(getCraftClass(className), methodName, parameters);
|
||||
}
|
||||
|
||||
public static Method getCraftMethod(Class<?> clazz, String methodName, Class<?>... parameters) {
|
||||
try {
|
||||
Method declaredMethod = clazz.getDeclaredMethod(methodName, parameters);
|
||||
declaredMethod.setAccessible(true);
|
||||
return declaredMethod;
|
||||
} catch (NoSuchMethodException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Method getNmsMethod(Class<?> clazz, String methodName, Class<?>... parameters) {
|
||||
try {
|
||||
Method declaredMethod = clazz.getDeclaredMethod(methodName, parameters);
|
||||
declaredMethod.setAccessible(true);
|
||||
return declaredMethod;
|
||||
} catch (NoSuchMethodException e) {
|
||||
e.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Method getNmsMethod(String className, String methodName, Class<?>... parameters) {
|
||||
return getNmsMethod(getNmsClass(className), methodName, parameters);
|
||||
}
|
||||
|
||||
public static double getPing(Player player) {
|
||||
try {
|
||||
return (double) pingField.getInt(ReflectionManager.getNmsEntity(player));
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return 0D;
|
||||
}
|
||||
|
||||
public static float[] getSize(Entity entity) {
|
||||
try {
|
||||
float length = getNmsField("Entity", "length").getFloat(getNmsEntity(entity));
|
||||
float width = getNmsField("Entity", "width").getFloat(getNmsEntity(entity));
|
||||
float height = (Float) getNmsMethod("Entity", "getHeadHeight").invoke(getNmsEntity(entity));
|
||||
return new float[]{length, width, height};
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static WrappedGameProfile getSkullBlob(WrappedGameProfile gameProfile) {
|
||||
try {
|
||||
Object minecraftServer = getNmsMethod("MinecraftServer", "getServer").invoke(null);
|
||||
for (Method method : getNmsClass("MinecraftServer").getDeclaredMethods()) {
|
||||
if (method.getReturnType().getSimpleName().equals("MinecraftSessionService")) {
|
||||
Object session = method.invoke(minecraftServer);
|
||||
return WrappedGameProfile.fromHandle(session.getClass()
|
||||
.getDeclaredMethod("fillProfileProperties", gameProfile.getHandleType(), boolean.class)
|
||||
.invoke(session, gameProfile.getHandle(), true));
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Float getSoundModifier(Object entity) {
|
||||
try {
|
||||
damageAndIdleSoundMethod.setAccessible(true);
|
||||
return (Float) damageAndIdleSoundMethod.invoke(entity);
|
||||
} catch (Exception ignored) {
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static WrappedGameProfile grabProfileAddUUID(String playername) {
|
||||
try {
|
||||
Object minecraftServer = getNmsMethod("MinecraftServer", "getServer").invoke(null);
|
||||
for (Method method : getNmsClass("MinecraftServer").getDeclaredMethods()) {
|
||||
if (method.getReturnType().getSimpleName().equals("GameProfileRepository")) {
|
||||
Object profileRepo = method.invoke(minecraftServer);
|
||||
Object agent = Class.forName("com.mojang.authlib.Agent").getDeclaredField("MINECRAFT").get(null);
|
||||
LibsProfileLookupCaller callback = new LibsProfileLookupCaller();
|
||||
profileRepo
|
||||
.getClass()
|
||||
.getDeclaredMethod("findProfilesByNames", String[].class, agent.getClass(),
|
||||
Class.forName("com.mojang.authlib.ProfileLookupCallback"))
|
||||
.invoke(profileRepo, new String[]{playername}, agent, callback);
|
||||
if (callback.getGameProfile() != null) {
|
||||
return callback.getGameProfile();
|
||||
}
|
||||
return getGameProfile(null, playername);
|
||||
}
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static String methodSignaturePart(Class<?> param) {
|
||||
if (param.isArray()) {
|
||||
return "[" + methodSignaturePart(param.getComponentType());
|
||||
} else if (param.isPrimitive()) {
|
||||
return primitiveTypes.get(param);
|
||||
} else {
|
||||
return "L" + param.getName().replaceAll("\\.", "/") + ";";
|
||||
}
|
||||
}
|
||||
|
||||
public static void removePlayer(Player player) {
|
||||
//Some future remove code if needed
|
||||
}
|
||||
|
||||
public static void setBoundingBox(Entity entity, FakeBoundingBox newBox) {
|
||||
try {
|
||||
Location loc = entity.getLocation();
|
||||
Object boundingBox = boundingBoxConstructor.newInstance(loc.getX() - newBox.getX(), loc.getY() - newBox.getY(),
|
||||
loc.getZ() - newBox.getZ(), loc.getX() + newBox.getX(), loc.getY() + newBox.getY(), loc.getZ() + newBox.getZ());
|
||||
setBoundingBoxMethod.invoke(getNmsEntity(entity), boundingBox);
|
||||
} catch (Exception ex) {
|
||||
ex.printStackTrace(System.out);
|
||||
}
|
||||
}
|
||||
|
||||
public static Enum getSoundCategory(String category) {
|
||||
Method method = getNmsMethod("SoundCategory", "a", String.class);
|
||||
try {
|
||||
Enum invoke = (Enum) method.invoke(null, category.toLowerCase());
|
||||
if (invoke == null) {
|
||||
Class<?> clazz = getNmsClass("SoundCategory");
|
||||
Enum[] enums = clazz != null ? (Enum[]) clazz.getEnumConstants() : null;
|
||||
for (Enum anEnum : enums != null ? enums : new Enum[0]) {
|
||||
if (anEnum.name().equals("MASTER")) return anEnum;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the NMS object EnumItemSlot from an EquipmentSlot.
|
||||
*
|
||||
* @param slot
|
||||
* @return null if the equipment slot is null
|
||||
*/
|
||||
public static Enum createEnumItemSlot(EquipmentSlot slot) {
|
||||
Class<?> clazz = getNmsClass("EnumItemSlot");
|
||||
Object[] enums = clazz != null ? clazz.getEnumConstants() : null;
|
||||
if (enums == null) return null;
|
||||
switch (slot) {
|
||||
case HAND:
|
||||
return (Enum) enums[0];
|
||||
case OFF_HAND:
|
||||
return (Enum) enums[1];
|
||||
case FEET:
|
||||
return (Enum) enums[2];
|
||||
case LEGS:
|
||||
return (Enum) enums[3];
|
||||
case CHEST:
|
||||
return (Enum) enums[4];
|
||||
case HEAD:
|
||||
return (Enum) enums[5];
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the Bukkit object EquipmentSlot from an EnumItemSlot object.
|
||||
*
|
||||
* @return null if the object isn't an nms EnumItemSlot
|
||||
*/
|
||||
public static EquipmentSlot createEquipmentSlot(Object enumItemSlot) {
|
||||
try {
|
||||
Enum nmsSlot = (Enum) enumItemSlot;
|
||||
switch (nmsSlot.name()) {
|
||||
case "MAINHAND":
|
||||
return EquipmentSlot.HAND;
|
||||
case "OFFHAND":
|
||||
return EquipmentSlot.OFF_HAND;
|
||||
case "FEET":
|
||||
return EquipmentSlot.FEET;
|
||||
case "LEGS":
|
||||
return EquipmentSlot.LEGS;
|
||||
case "CHEST":
|
||||
return EquipmentSlot.CHEST;
|
||||
case "HEAD":
|
||||
return EquipmentSlot.HAND;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
return null;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets equipment from this entity based on the slot given.
|
||||
*
|
||||
* @param slot
|
||||
* @return null if the disguisedEntity is not an instance of a living entity
|
||||
*/
|
||||
public static ItemStack getEquipment(EquipmentSlot slot, Entity disguisedEntity) {
|
||||
if (!(disguisedEntity instanceof LivingEntity)) return null;
|
||||
switch (slot) {
|
||||
case HAND:
|
||||
return ((LivingEntity) disguisedEntity).getEquipment().getItemInMainHand();
|
||||
case OFF_HAND:
|
||||
return ((LivingEntity) disguisedEntity).getEquipment().getItemInOffHand();
|
||||
case FEET:
|
||||
return ((LivingEntity) disguisedEntity).getEquipment().getBoots();
|
||||
case LEGS:
|
||||
return ((LivingEntity) disguisedEntity).getEquipment().getLeggings();
|
||||
case CHEST:
|
||||
return ((LivingEntity) disguisedEntity).getEquipment().getChestplate();
|
||||
case HEAD:
|
||||
return ((LivingEntity) disguisedEntity).getEquipment().getHelmet();
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Necessary for 1.9
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
public static String convertSoundEffectToString(Object soundEffect) {
|
||||
try {
|
||||
Field f_getMinecraftKey = getNmsField("SoundEffect", "b");
|
||||
f_getMinecraftKey.setAccessible(true);
|
||||
MinecraftKey key = MinecraftKey.fromHandle(f_getMinecraftKey.get(soundEffect));
|
||||
return key.getKey();
|
||||
} catch (IllegalAccessException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object getCraftSoundEffect(String sound) {
|
||||
try {
|
||||
return getCraftMethod("CraftSound", "getSoundEffect", String.class).invoke(null, sound);
|
||||
} catch (IllegalAccessException | InvocationTargetException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* This creates a DataWatcherItem usable with WrappedWatchableObject
|
||||
*
|
||||
* @param id
|
||||
* @param value
|
||||
* @return
|
||||
*/
|
||||
public static Object createDataWatcherItem(int id, Object value) {
|
||||
if (value == null) return null;
|
||||
Serializer serializer = Registry.get(value.getClass());
|
||||
WrappedDataWatcherObject watcherObject = new WrappedDataWatcherObject(id, serializer);
|
||||
Constructor construct = getNmsConstructor("DataWatcher$Item", getNmsClass("DataWatcherObject"), Object.class);
|
||||
try {
|
||||
return construct.newInstance(watcherObject.getHandle(), value);
|
||||
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static EntityEquipment createEntityEquipment(Entity entity) {
|
||||
if (!(entity instanceof LivingEntity)) return null;
|
||||
Constructor construct = getCraftConstructor("CraftEntityEquipment", getCraftClass("CraftLivingEntity"));
|
||||
try {
|
||||
return (EntityEquipment) construct.newInstance((LivingEntity) entity);
|
||||
} catch (InstantiationException | IllegalAccessException | InvocationTargetException | ClassCastException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static int getCombinedId(int id, int data) {
|
||||
return id + (data << 12);
|
||||
}
|
||||
|
||||
public static Pair<Integer, Integer> getFromCombinedId(int combinedId) {
|
||||
int j = combinedId & 4095;
|
||||
int k = combinedId >> 12 & 15;
|
||||
return new ImmutablePair<>(j, k);
|
||||
}
|
||||
|
||||
public static Object getWorldServer(World w) {
|
||||
try {
|
||||
return getCraftMethod("CraftWorld", "getHandle").invoke(w);
|
||||
} catch (IllegalAccessException | InvocationTargetException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object getPlayerInteractManager(World w) {
|
||||
Object worldServer = getWorldServer(w);
|
||||
try {
|
||||
return getNmsConstructor("PlayerInteractManager", getNmsClass("World")).newInstance(worldServer);
|
||||
} catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Object createEntityPlayer(World w, WrappedGameProfile profile) {
|
||||
Object entityPlayer = null;
|
||||
try {
|
||||
entityPlayer = getNmsConstructor("EntityPlayer",
|
||||
getNmsClass("MinecraftServer"),
|
||||
getNmsClass("WorldServer"),
|
||||
GameProfile.class,
|
||||
getNmsClass("PlayerInteractManager"))
|
||||
.newInstance(getMinecraftServer(), getWorldServer(w), profile.getHandle(), getPlayerInteractManager(w));
|
||||
} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return entityPlayer;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
package me.libraryaddict.disguise.utilities;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.InputStreamReader;
|
||||
import java.net.HttpURLConnection;
|
||||
import java.net.URL;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
public class UpdateChecker {
|
||||
|
||||
private String latestVersion;
|
||||
|
||||
private boolean checkHigher(String currentVersion, String newVersion) {
|
||||
String current = toReadable(currentVersion);
|
||||
String newVers = toReadable(newVersion);
|
||||
return current.compareTo(newVers) < 0;
|
||||
}
|
||||
|
||||
public void checkUpdate(String currentVersion) {
|
||||
String version = getSpigotVersion();
|
||||
if (version != null) {
|
||||
if (checkHigher(currentVersion, version)) {
|
||||
latestVersion = version;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public String getLatestVersion() {
|
||||
return latestVersion;
|
||||
}
|
||||
|
||||
/**
|
||||
* Asks spigot for the version
|
||||
*/
|
||||
private String getSpigotVersion() {
|
||||
try {
|
||||
HttpURLConnection con = (HttpURLConnection) new URL("http://www.spigotmc.org/api/general.php").openConnection();
|
||||
con.setDoOutput(true);
|
||||
con.setRequestMethod("POST");
|
||||
con.getOutputStream().write(
|
||||
("key=98BE0FE67F88AB82B4C197FAF1DC3B69206EFDCC4D3B80FC83A00037510B99B4&resource=81").getBytes("UTF-8"));
|
||||
String version = new BufferedReader(new InputStreamReader(con.getInputStream())).readLine();
|
||||
if (version.length() <= 7) {
|
||||
return version;
|
||||
}
|
||||
} catch (Exception ex) {
|
||||
System.out.print("[LibsDisguises] Failed to check for a update on spigot. Now checking bukkit..");
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private String toReadable(String version) {
|
||||
String[] split = Pattern.compile(".", Pattern.LITERAL).split(version.replace("v", ""));
|
||||
version = "";
|
||||
for (String s : split) {
|
||||
version += String.format("%4s", s);
|
||||
}
|
||||
return version;
|
||||
}
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
# Shall I notify people of a LibsDisguises update?
|
||||
NotifyUpdate: true
|
||||
# Whats the permission to get the notification?
|
||||
Permission: 'libsdisguises.update'
|
||||
# Whats the max size allowed for command disguiseradius
|
||||
DisguiseRadiusMax: 50
|
||||
# Whats the max size allowed for command undisguiseradius
|
||||
UndisguiseRadiusMax: 50
|
||||
# Shall the players view their disguises?
|
||||
# Best used when viewing yourself in 3rd person
|
||||
ViewSelfDisguises: true
|
||||
# Shall I disguise the sounds?
|
||||
# This turns your damage sound into a MOOOO
|
||||
DisguiseSounds: true
|
||||
# Shall the disguised hear their disguise sounds or their damage sounds.
|
||||
# I disable this as it can be a little confusing when not used with self disguises
|
||||
HearSelfDisguise: true
|
||||
# Shall I send the velocity packets? I REALLY recommend you don't disable.
|
||||
# This is the only thing allowing the mobs to fly without glitching out.
|
||||
SendVelocity: true
|
||||
# For self disguises, they need to have the armor and the held item removed
|
||||
# Else they see floating armor, floating held items.
|
||||
# This turns the items invisible in the disguised players inventory. It does not actually remove them!
|
||||
RemoveArmor: true
|
||||
RemoveHeldItem: false
|
||||
# If you set a disguise to burning, it will no longer be able to be shown as sneaking or invisible.
|
||||
# Set this to true if you want the disguise to get the animations of the disguised entity. Such as invisible, on fire, sprinting, sneaking, blocking
|
||||
# This is only valid if you set a animation on the disguise itself. Because the entitys animations are applied otherwise.
|
||||
AddEntityAnimations: true
|
||||
# When a sheep or wolf is right clicked with dye. The client automatically assumes it was successful and displays the sheeps wool or the wolfs collar as dyed.
|
||||
# This is a option that either prevents that happening, or it changes their color officially in the plugin so that everyone sees it changed.
|
||||
# Its currently set to false which means that the color is not changed and will refresh itself to the player.
|
||||
# Please note that this will not remove the dye from their hands. This also does not check if the disguised entity is actually a sheep/wolf and wants a say in its color.
|
||||
DyeableSheep: false
|
||||
DyeableWolf: false
|
||||
# This is only called into action when the disguise is constructed using the commands.
|
||||
# And when the disguise supports that. This will not be used at all for plugins constructing the disguises for instance.
|
||||
# Such as prophunt. Its also false because its kind of a retarded feature.
|
||||
# This is pretty simple. It shows the players displayname (Name as it appears in chat) above their head.
|
||||
# This also overrides any custom name they have set in their disguise options.
|
||||
ShowNamesAboveDisguises: false
|
||||
# This supports the above option.
|
||||
# If this is true, then the name shown above the head appears regardless of if you are looking at the disguise directly or not.
|
||||
NameAboveHeadAlwaysVisible: true
|
||||
# This modifys the bounding box, This is stuff like can a arrow hit them.
|
||||
# If you turn this to true, arrows will act like they hit the disguise in the right place!
|
||||
# So someone disguised as a enderdragon will easily get shot down by arrows!
|
||||
# This WILL conflict with NoCheatPlus. Other plugins may also get problems.
|
||||
# This shouldn't really be enabled for players as it also interferes with their movement because the server thinks the player is larger than he really is.
|
||||
# That makes the player unable to approach this building because the server thinks he is trying to glitch inside blocks.
|
||||
ModifyBoundingBox: false
|
||||
# This prevents disguised players from being targeted by monsters.
|
||||
# This doesn't prevent their targeting you if already targeting when disguised
|
||||
# They will just ignore you unless provoked.
|
||||
MonstersIgnoreDisguises: false
|
||||
# Sigh. People are going to want this.
|
||||
# So lets make your disguise blown if you are attacked..
|
||||
# Works only for disguised players when attacked by a entity (arrow, monster. etc)
|
||||
# This will blow all disguises he has on him
|
||||
BlowDisguises: false
|
||||
BlownDisguiseMessage: '&cYour disguise was blown!'
|
||||
|
||||
#Stop shulker disguises from moving, they're weird. This option only effects PLAYERS that are disguised, other entities disguised as shulkers will NOT be effected!
|
||||
StopShulkerDisguisesFromMoving: true
|
||||
|
||||
# A option to choose how many seconds a DisguiseEntity command is valid for people to right click a entity to disguise it before expiring
|
||||
DisguiseEntityExpire: 10
|
||||
|
||||
# Another option to choose the same thing for DisguiseClone command
|
||||
DisguiseCloneExpire: 10
|
||||
# Max disguises to store at a time with the DisguiseClone command
|
||||
DisguiseCloneSize: 3
|
||||
|
||||
# This I don't really recommend turning on as it can make a memory leak..
|
||||
# These disguises, as normal will not persist after a server restart.
|
||||
# There is also no EntityDeath option as entities do not revive after death.
|
||||
KeepDisguises:
|
||||
EntityDespawn: false
|
||||
PlayerDeath: false
|
||||
PlayerLogout: false
|
||||
|
||||
# This controls if a entitys max health is determined by the entity, or by the disguise.
|
||||
# Wither is 200, a player is 20. With this enabled, a player disguised as a wither will have the boss bar health accurate to the players health.
|
||||
# Else it will be 1/20 of the boss bar when he is full health.
|
||||
# Setting this in LivingWatcher overrides both values.
|
||||
MaxHealthDeterminedByEntity: true
|
||||
|
||||
# This here is a option to turn off misc disguises.
|
||||
# This means you can not have a living entity disguise as a non-living entity.
|
||||
# This disables the Attributes packet, Non-living entities can still disguise as other non-living
|
||||
# This means that the above option will not work as it uses the attribute packet.
|
||||
MiscDisguisesForLiving: true
|
||||
|
||||
# Turn this to true to have players undisguised when switching worlds
|
||||
UndisguiseOnWorldChange: false
|
||||
|
||||
# Contact Mojang's servers? Disabling this option will disable player skin disguises!
|
||||
ContactMojangServers: true
|
||||
|
||||
# This will help performance, especially with CPU
|
||||
# Due to safety reasons, self disguises can never have their packets disabled.
|
||||
PacketsEnabled:
|
||||
# This disables the animation packet. If a disguised entity sends a animation packet and they are using a non-living disguise. People will crash.
|
||||
# Disabling this also means that if a player disguised as a non-player leaves a bug. People will crash
|
||||
Animation: true
|
||||
# Disabling this means that you can't use the setSleeping option on a player disguise. Also you will crash anyone watching when you try to sleep in a bed if disguised as a non-player
|
||||
# This also sends a chunk packet at key positions else it doesn't work for 1.8. Lazyness means it does it for older versions too currently.
|
||||
Bed: true
|
||||
# This disguises the collect packet. If a living entity disguised as a non-living entity picks up a item. People will crash. This fixes it
|
||||
# This also fixes people crashing if a item disguised as a sleeping player is picked up - Only true if Bed is enabled as well
|
||||
Collect: true
|
||||
# This disables a fix for when a disguised entity wearing armor dies, if the disguise can wear armor. It drops unpickupable items to anyone watching.
|
||||
EntityStatus: true
|
||||
# Entity equipment is the packets that are sent to ensure that a disguise has or doesn't have armor, and their held item.
|
||||
# Disabling this means that any disguises which can wear armor or hold items will show the armor/held item that the disguised is wearing.
|
||||
Equipment: true
|
||||
# This doesn't actually disable the packet. It would introduce problems. Instead it does the next best thing and caches the data.
|
||||
# This means that entity metadata will not change, and will only be sent in the spawn packet.
|
||||
# This is good if performance is extremely in need.
|
||||
# This is bad to disable unless you are ONLY going to use the disguises for decorations.
|
||||
# To be honest. This is basically "Disable entity animations". That option is called 'AddEntityAnimations' in the config but unlike that, this is always in effect.
|
||||
# Animations set by use of the api or through the disguise command are still in effect.
|
||||
Metadata: true
|
||||
# Movement packets are the biggest cpu hit. These are majorly used to ensure that the disguises facing direction isn't bugged up.
|
||||
# If you are using the Item_Frame disguise, when a packet is sent (Roughly every 2min) the disguise will bug up until they move.
|
||||
Movement: true
|
||||
# Disable this if you don't mind crashing everytime you see someone riding something disguised as a non-living entity
|
||||
Riding: true
|
||||
# When disguised as a wither skull, it sends a look packet every tick so that the wither skull is facing the right way.
|
||||
WitherSkull: true
|
||||
@@ -1,103 +0,0 @@
|
||||
name: LibsDisguises
|
||||
main: me.libraryaddict.disguise.LibsDisguises
|
||||
description: A disguise plugin with various disguises.
|
||||
version: ${projectVersion}
|
||||
author: libraryaddict
|
||||
authors: [Byteflux, Navid K.]
|
||||
softdepend: [ProtocolLib]
|
||||
commands:
|
||||
libsdisguises:
|
||||
permission: libsdisguises.seecmd.libsdisguises
|
||||
description: Main command for libsdisguises.
|
||||
disguise:
|
||||
aliases: [d, dis]
|
||||
permission: libsdisguises.seecmd.disguise
|
||||
description: Disguise yourself as an entity.
|
||||
disguiseentity:
|
||||
aliases: [dentity, disentity]
|
||||
permission: libsdisguises.seecmd.disguiseentity
|
||||
description: Disguise an entity as another entity.
|
||||
disguisehelp:
|
||||
aliases: [dhelp, dishelp]
|
||||
permission: libsdisguises.seecmd.disguisehelp
|
||||
description: Help command for LibsDisguises.
|
||||
disguiseplayer:
|
||||
aliases: [dplayer, displayer]
|
||||
permission: libsdisguises.seecmd.disguiseplayer
|
||||
description: Disguise another player as an entity.
|
||||
disguiseradius:
|
||||
aliases: [disradius, dradius]
|
||||
permission: libsdisguises.seecmd.disguiseradius
|
||||
description: Disguise all entities within a radius as an entity.
|
||||
undisguise:
|
||||
aliases: [u, und, undis]
|
||||
permission: libsdisguises.seecmd.undisguise
|
||||
description: Undisguise yourself.
|
||||
undisguiseentity:
|
||||
aliases: [undisentity, undentity]
|
||||
permission: libsdisguises.seecmd.undisguiseentity
|
||||
description: Undisguise an entity.
|
||||
undisguiseplayer:
|
||||
aliases: [undisplayer, undplayer]
|
||||
permission: libsdisguises.seecmd.undisguiseplayer
|
||||
description: Undisguise a player.
|
||||
undisguiseradius:
|
||||
aliases: [undisradius, undradius]
|
||||
permission: libsdisguises.seecmd.undisguiseradius
|
||||
description: Undisguise all entities within a radius.
|
||||
disguiseclone:
|
||||
aliases: [disguisec, disc, disclone, dclone, clonedisguise, clonedis, cdisguise, cdis]
|
||||
permission: libsdisguises.seecmd.disguiseclone
|
||||
description: Copy a disguise (or entity) and use it later.
|
||||
disguiseviewself:
|
||||
aliases: [dviewself, dvs, disguisevs, disvs, vsd, viewselfdisguise, viewselfd]
|
||||
permission: libsdisguises.seecmd.viewself
|
||||
description: Toggle seeing your own disguise on or off.
|
||||
|
||||
permissions:
|
||||
libsdisguises.reload:
|
||||
description: Allows the user to reload LibsDisguises.
|
||||
default: op
|
||||
libsdisguises.seethrough:
|
||||
description: Allows player to see through disguises.
|
||||
default: false
|
||||
libsdisguises.seecmd:
|
||||
description: See all commands in tab-completion
|
||||
default: true
|
||||
children:
|
||||
libsdisguises.seecmd.libsdisguises: true
|
||||
libsdisguises.seecmd.disguise: true
|
||||
libsdisguises.seecmd.disguiseentity: true
|
||||
libsdisguises.seecmd.disguisehelp: true
|
||||
libsdisguises.seecmd.disguiseplayer: true
|
||||
libsdisguises.seecmd.disguiseradius: true
|
||||
libsdisguises.seecmd.undisguise: true
|
||||
libsdisguises.seecmd.undisguiseentity: true
|
||||
libsdisguises.seecmd.undisguiseplayer: true
|
||||
libsdisguises.seecmd.undisguiseradius: true
|
||||
libsdisguises.seecmd.disguiseclone: true
|
||||
libsdisguises.seecmd.disguiseviewself: true
|
||||
libsdisguises.seecmd.libsdisguises:
|
||||
description: See the /libsdisguises command in tab-completion
|
||||
libsdisguises.seecmd.disguiseviewself:
|
||||
description: See the /disguiseviewself command in tab-completion
|
||||
libsdisguises.seecmd.disguise:
|
||||
description: See the /disguise command in tab-completion
|
||||
libsdisguises.seecmd.disguiseentity:
|
||||
description: See the /disguiseentity command in tab-completion
|
||||
libsdisguises.seecmd.disguisehelp:
|
||||
description: See the /disguisehelp command in tab-completion
|
||||
libsdisguises.seecmd.disguiseplayer:
|
||||
description: See the /disguiseplayer command in tab-completion
|
||||
libsdisguises.seecmd.disguiseradius:
|
||||
description: See the /disguiseradius command in tab-completion
|
||||
libsdisguises.seecmd.undisguise:
|
||||
description: See the /undisguise command in tab-completion
|
||||
libsdisguises.seecmd.undisguiseentity:
|
||||
description: See the /undisguiseentity command in tab-completion
|
||||
libsdisguises.seecmd.undisguiseplayer:
|
||||
description: See the /undisguiseplayer command in tab-completion
|
||||
libsdisguises.seecmd.undisguiseradius:
|
||||
description: See the /undisguiseradius command in tab-completion
|
||||
libsdisguises.seecmd.disguiseclone:
|
||||
description: See the /disguiseclone command in tab-completion
|
||||
Reference in New Issue
Block a user