Upstream/LibsDisguises
1
0
Fork 1
mirror of https://github.com/libraryaddict/LibsDisguises.git synced 2024-09-11 01:38:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

Bed chunk fix

Browse Source
This commit is contained in:
libraryaddict 2016-05-12 09:47:08 +12:00
parent 3e493fdda6
commit e0293227dd
2 changed files with 2045 additions and 1902 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

986
src/me/libraryaddict/disguise/DisguiseListener.java
View File

@ -1,430 +1,556 @@
package me.libraryaddict.disguise; package me.libraryaddict.disguise;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet; import java.util.HashSet;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.entity.Entity; import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity; import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler; import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority; import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityTargetEvent; import org.bukkit.event.entity.EntityTargetEvent;
import org.bukkit.event.player.PlayerChangedWorldEvent; import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerInteractEntityEvent; import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerMoveEvent; import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerRespawnEvent; import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.player.PlayerTeleportEvent; import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.event.vehicle.VehicleEnterEvent; import org.bukkit.event.vehicle.VehicleEnterEvent;
import org.bukkit.event.vehicle.VehicleExitEvent; import org.bukkit.event.vehicle.VehicleExitEvent;
import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
import com.comphenix.protocol.ProtocolLibrary; import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.PacketContainer; import com.comphenix.protocol.events.PacketContainer;
import me.libraryaddict.disguise.disguisetypes.Disguise; import me.libraryaddict.disguise.disguisetypes.Disguise;
import me.libraryaddict.disguise.disguisetypes.DisguiseType; import me.libraryaddict.disguise.disguisetypes.DisguiseType;
import me.libraryaddict.disguise.disguisetypes.PlayerDisguise; import me.libraryaddict.disguise.disguisetypes.PlayerDisguise;
import me.libraryaddict.disguise.disguisetypes.TargetedDisguise; import me.libraryaddict.disguise.disguisetypes.TargetedDisguise;
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher; import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
import me.libraryaddict.disguise.utilities.DisguiseUtilities; import me.libraryaddict.disguise.utilities.DisguiseUtilities;
import me.libraryaddict.disguise.utilities.ReflectionManager; import me.libraryaddict.disguise.utilities.ReflectionManager;
import me.libraryaddict.disguise.utilities.UpdateChecker; import me.libraryaddict.disguise.utilities.UpdateChecker;
public class DisguiseListener implements Listener { public class DisguiseListener implements Listener
{
private String currentVersion;
private HashMap<String, Boolean[]> disguiseClone = new HashMap<>(); private String currentVersion;
private HashMap<String, Disguise> disguiseEntity = new HashMap<>(); private HashMap<String, Boolean[]> disguiseClone = new HashMap<>();
private HashMap<String, BukkitRunnable> disguiseRunnable = new HashMap<>(); private HashMap<String, Disguise> disguiseEntity = new HashMap<>();
private String latestVersion; private HashMap<String, BukkitRunnable> disguiseRunnable = new HashMap<>();
private LibsDisguises plugin; private String latestVersion;
private BukkitTask updaterTask; private LibsDisguises plugin;
private BukkitTask updaterTask;
public DisguiseListener(LibsDisguises libsDisguises) {
plugin = libsDisguises; public DisguiseListener(LibsDisguises libsDisguises)
if (plugin.getConfig().getBoolean("NotifyUpdate")) { {
currentVersion = plugin.getDescription().getVersion(); plugin = libsDisguises;
updaterTask = Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() { if (plugin.getConfig().getBoolean("NotifyUpdate"))
@Override {
public void run() { currentVersion = plugin.getDescription().getVersion();
try { updaterTask = Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, new Runnable()
UpdateChecker updateChecker = new UpdateChecker(); {
updateChecker.checkUpdate("v" + currentVersion); @Override
latestVersion = updateChecker.getLatestVersion(); public void run()
if (latestVersion != null) { {
latestVersion = "v" + latestVersion; try
Bukkit.getScheduler().runTask(plugin, new Runnable() { {
@Override UpdateChecker updateChecker = new UpdateChecker();
public void run() { updateChecker.checkUpdate("v" + currentVersion);
for (Player p : Bukkit.getOnlinePlayers()) { latestVersion = updateChecker.getLatestVersion();
if (p.hasPermission(DisguiseConfig.getUpdateNotificationPermission())) { if (latestVersion != null)
p.sendMessage(String.format(DisguiseConfig.getUpdateMessage(), currentVersion, {
latestVersion)); latestVersion = "v" + latestVersion;
} Bukkit.getScheduler().runTask(plugin, new Runnable()
} {
} @Override
}); public void run()
} {
} catch (Exception ex) { for (Player p : Bukkit.getOnlinePlayers())
System.out.print(String.format("[LibsDisguises] Failed to check for update: %s", ex.getMessage())); {
} if (p.hasPermission(DisguiseConfig.getUpdateNotificationPermission()))
} {
}, 0, (20 * 60 * 60 * 6)); // Check every 6 hours p.sendMessage(String.format(DisguiseConfig.getUpdateMessage(), currentVersion,
// 20 ticks * 60 seconds * 60 minutes * 6 hours latestVersion));
} }
} }
}
public void cleanup() { });
for (BukkitRunnable r : disguiseRunnable.values()) { }
r.cancel(); }
} catch (Exception ex)
for (Disguise d : disguiseEntity.values()) { {
d.removeDisguise(); System.out.print(String.format("[LibsDisguises] Failed to check for update: %s", ex.getMessage()));
} }
disguiseClone.clear(); }
updaterTask.cancel(); }, 0, (20 * 60 * 60 * 6)); // Check every 6 hours
} // 20 ticks * 60 seconds * 60 minutes * 6 hours
}
private void checkPlayerCanBlowDisguise(Player entity) { }
Disguise[] disguises = DisguiseAPI.getDisguises(entity);
if (disguises.length > 0) { public void cleanup()
DisguiseAPI.undisguiseToAll(entity); {
if (DisguiseConfig.getDisguiseBlownMessage().length() > 0) { for (BukkitRunnable r : disguiseRunnable.values())
entity.sendMessage(DisguiseConfig.getDisguiseBlownMessage()); {
} r.cancel();
} }
} for (Disguise d : disguiseEntity.values())
{
private void chunkMove(Player player, Location newLoc, Location oldLoc) { d.removeDisguise();
try { }
for (PacketContainer packet : DisguiseUtilities.getBedChunkPacket(newLoc, oldLoc)) { disguiseClone.clear();
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet, false); updaterTask.cancel();
} }
if (newLoc != null) {
for (HashSet<TargetedDisguise> list : DisguiseUtilities.getDisguises().values()) { private void checkPlayerCanBlowDisguise(Player entity)
for (TargetedDisguise disguise : list) { {
if (disguise.isPlayerDisguise() && disguise.canSee(player) Disguise[] disguises = DisguiseAPI.getDisguises(entity);
&& ((PlayerDisguise) disguise).getWatcher().isSleeping() if (disguises.length > 0)
&& DisguiseUtilities.getPerverts(disguise).contains(player)) { {
PacketContainer[] packets = DisguiseUtilities.getBedPackets(player, DisguiseAPI.undisguiseToAll(entity);
disguise.getEntity() == player ? newLoc : disguise.getEntity().getLocation(), newLoc, if (DisguiseConfig.getDisguiseBlownMessage().length() > 0)
(PlayerDisguise) disguise); {
if (disguise.getEntity() == player) { entity.sendMessage(DisguiseConfig.getDisguiseBlownMessage());
for (PacketContainer packet : packets) { }
packet.getIntegers().write(0, DisguiseAPI.getSelfDisguiseId()); }
} }
}
for (PacketContainer packet : packets) { private void chunkMove(Player player, Location newLoc, Location oldLoc)
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet); {
} try
} {
} for (PacketContainer packet : DisguiseUtilities.getBedChunkPacket(newLoc, oldLoc))
} {
} ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet, false);
} catch (InvocationTargetException e) { }
e.printStackTrace(System.out);
} if (newLoc != null)
} {
for (HashSet<TargetedDisguise> list : DisguiseUtilities.getDisguises().values())
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) {
public void onAttack(EntityDamageByEntityEvent event) { for (TargetedDisguise disguise : list)
if (DisguiseConfig.isDisguiseBlownOnAttack()) { {
if (event.getEntity() instanceof Player) { if (disguise.isPlayerDisguise() && disguise.canSee(player)
checkPlayerCanBlowDisguise((Player) event.getEntity()); && ((PlayerDisguise) disguise).getWatcher().isSleeping()
} && DisguiseUtilities.getPerverts(disguise).contains(player))
if (event.getDamager() instanceof Player) { {
checkPlayerCanBlowDisguise((Player) event.getDamager()); PacketContainer[] packets = DisguiseUtilities.getBedPackets(player,
} disguise.getEntity() == player ? newLoc : disguise.getEntity().getLocation(), newLoc,
} (PlayerDisguise) disguise);
}
if (disguise.getEntity() == player)
@EventHandler {
public void onJoin(PlayerJoinEvent event) { for (PacketContainer packet : packets)
Player p = event.getPlayer(); {
if (latestVersion != null && p.hasPermission(DisguiseConfig.getUpdateNotificationPermission())) { packet.getIntegers().write(0, DisguiseAPI.getSelfDisguiseId());
p.sendMessage(String.format(DisguiseConfig.getUpdateMessage(), currentVersion, latestVersion)); }
} }
if (DisguiseConfig.isBedPacketsEnabled()) {
chunkMove(p, p.getLocation(), null); for (PacketContainer packet : packets)
} {
} ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
}
/** }
* 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()) { catch (InvocationTargetException e)
Location to = event.getTo(); {
Location from = event.getFrom(); e.printStackTrace(System.out);
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; @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
if (x1 - (x1 % 8) != x2 - (x2 % 8) || z1 - (z1 % 8) != z2 - (z2 % 8)) { public void onAttack(EntityDamageByEntityEvent event)
chunkMove(event.getPlayer(), to, from); {
} if (DisguiseConfig.isDisguiseBlownOnAttack())
} {
if (event.getEntity() instanceof Player)
if (DisguiseConfig.isStopShulkerDisguisesFromMoving()) { {
Disguise disguise; checkPlayerCanBlowDisguise((Player) event.getEntity());
if ((disguise = DisguiseAPI.getDisguise(event.getPlayer())) != null) { }
if (disguise.getType() == DisguiseType.SHULKER) { //Stop Shulker disguises from moving their coordinates
Location from = event.getFrom(); if (event.getDamager() instanceof Player)
Location to = event.getTo(); {
to.setX(from.getX()); checkPlayerCanBlowDisguise((Player) event.getDamager());
to.setZ(from.getZ()); }
event.setTo(to); }
} }
}
} @EventHandler
} public void onJoin(PlayerJoinEvent event)
{
@EventHandler Player p = event.getPlayer();
public void onQuit(PlayerQuitEvent event) { if (latestVersion != null && p.hasPermission(DisguiseConfig.getUpdateNotificationPermission()))
ReflectionManager.removePlayer(event.getPlayer()); {
} p.sendMessage(String.format(DisguiseConfig.getUpdateMessage(), currentVersion, latestVersion));
}
@EventHandler if (DisguiseConfig.isBedPacketsEnabled())
public void onRespawn(PlayerRespawnEvent event) { {
Disguise[] disguises = DisguiseAPI.getDisguises(event.getPlayer()); chunkMove(p, p.getLocation(), null);
for (Disguise disguise : disguises) { }
if (disguise.isRemoveDisguiseOnDeath()) { }
disguise.removeDisguise();
} /**
} * Most likely faster if we don't bother doing checks if he sees a player disguise
} */
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@EventHandler public void onMove(PlayerMoveEvent event)
public void onRightClick(PlayerInteractEntityEvent event) { {
if (disguiseEntity.containsKey(event.getPlayer().getName()) || disguiseClone.containsKey(event.getPlayer().getName())) { if (DisguiseConfig.isBedPacketsEnabled())
Player p = event.getPlayer(); {
event.setCancelled(true); Location to = event.getTo();
disguiseRunnable.remove(p.getName()).cancel(); Location from = event.getFrom();
Entity entity = event.getRightClicked(); int x1 = (int) Math.floor(to.getX() / 16D) - 17;
String entityName; int x2 = (int) Math.floor(from.getX() / 16D) - 17;
if (entity instanceof Player && !disguiseClone.containsKey(p.getName())) { int z1 = (int) Math.floor(to.getZ() / 16D) - 17;
entityName = entity.getName(); int z2 = (int) Math.floor(from.getZ() / 16D) - 17;
} else { if (x1 - (x1 % 8) != x2 - (x2 % 8) || z1 - (z1 % 8) != z2 - (z2 % 8))
entityName = DisguiseType.getType(entity).toReadable(); {
} chunkMove(event.getPlayer(), to, from);
if (disguiseClone.containsKey(p.getName())) { }
Boolean[] options = disguiseClone.remove(p.getName()); }
Disguise disguise = DisguiseAPI.getDisguise(p, entity);
if (disguise == null) { if (DisguiseConfig.isStopShulkerDisguisesFromMoving())
disguise = DisguiseAPI.constructDisguise(entity, options[0], options[1], options[2]); {
} else { Disguise disguise;
disguise = disguise.clone(); if ((disguise = DisguiseAPI.getDisguise(event.getPlayer())) != null)
} {
char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray(); if (disguise.getType() == DisguiseType.SHULKER)
String reference = null; { // Stop Shulker disguises from moving their coordinates
int referenceLength = Math.max(2, (int) Math.ceil((0.1D + DisguiseConfig.getMaxClonedDisguises()) / 26D)); Location from = event.getFrom();
int attempts = 0; Location to = event.getTo();
while (reference == null && attempts++ < 1000) { to.setX(from.getX());
reference = "@"; to.setZ(from.getZ());
for (int i = 0; i < referenceLength; i++) { event.setTo(to);
reference += alphabet[DisguiseUtilities.random.nextInt(alphabet.length)]; }
} }
if (DisguiseUtilities.getClonedDisguise(reference) != null) { }
reference = null; }
}
} @EventHandler
if (reference != null && DisguiseUtilities.addClonedDisguise(reference, disguise)) { public void onQuit(PlayerQuitEvent event)
p.sendMessage(ChatColor.RED + "Constructed a " + entityName + " disguise! Your reference is " + reference); {
p.sendMessage(ChatColor.RED + "Example usage: /disguise " + reference); ReflectionManager.removePlayer(event.getPlayer());
} else { }
p.sendMessage(ChatColor.RED
+ "Failed to store the reference due to lack of size. Please set this in the config"); @EventHandler
} public void onRespawn(PlayerRespawnEvent event)
} else if (disguiseEntity.containsKey(p.getName())) { {
Disguise disguise = disguiseEntity.remove(p.getName()); Disguise[] disguises = DisguiseAPI.getDisguises(event.getPlayer());
if (disguise != null) { for (Disguise disguise : disguises)
if (disguise.isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled() {
&& entity instanceof LivingEntity) { if (disguise.isRemoveDisguiseOnDeath())
p.sendMessage(ChatColor.RED {
+ "Can't disguise a living entity as a misc disguise. This has been disabled in the config!"); disguise.removeDisguise();
} else { }
if (entity instanceof Player && DisguiseConfig.isNameOfPlayerShownAboveDisguise()) { }
if (disguise.getWatcher() instanceof LivingWatcher) { }
disguise.getWatcher().setCustomName(((Player) entity).getDisplayName());
if (DisguiseConfig.isNameAboveHeadAlwaysVisible()) { @EventHandler
disguise.getWatcher().setCustomNameVisible(true); public void onRightClick(PlayerInteractEntityEvent event)
} {
} if (disguiseEntity.containsKey(event.getPlayer().getName()) || disguiseClone.containsKey(event.getPlayer().getName()))
} {
DisguiseAPI.disguiseToAll(entity, disguise); Player p = event.getPlayer();
String disguiseName = "a "; event.setCancelled(true);
if (disguise instanceof PlayerDisguise) { disguiseRunnable.remove(p.getName()).cancel();
disguiseName = "the player " + ((PlayerDisguise) disguise).getName(); Entity entity = event.getRightClicked();
} else { String entityName;
disguiseName += disguise.getType().toReadable(); if (entity instanceof Player && !disguiseClone.containsKey(p.getName()))
} {
if (disguise.isDisguiseInUse()) { entityName = entity.getName();
p.sendMessage(ChatColor.RED + "Disguised " + (entity instanceof Player ? "" : "the ") + entityName }
+ " as " + disguiseName + "!"); else
} else { {
p.sendMessage(ChatColor.RED + "Failed to disguise " + (entity instanceof Player ? "" : "the ") entityName = DisguiseType.getType(entity).toReadable();
+ entityName + " as " + disguiseName + "!"); }
} if (disguiseClone.containsKey(p.getName()))
} {
} else { Boolean[] options = disguiseClone.remove(p.getName());
if (DisguiseAPI.isDisguised(entity)) { Disguise disguise = DisguiseAPI.getDisguise(p, entity);
DisguiseAPI.undisguiseToAll(entity); if (disguise == null)
p.sendMessage(ChatColor.RED + "Undisguised " + (entity instanceof Player ? "" : "the ") + entityName); {
} else { disguise = DisguiseAPI.constructDisguise(entity, options[0], options[1], options[2]);
p.sendMessage(ChatColor.RED + (entity instanceof Player ? "" : "the") + entityName + " isn't disguised!"); }
} else
} {
} disguise = disguise.clone();
} }
} char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray();
String reference = null;
@EventHandler int referenceLength = Math.max(2, (int) Math.ceil((0.1D + DisguiseConfig.getMaxClonedDisguises()) / 26D));
public void onTarget(EntityTargetEvent event) { int attempts = 0;
if (DisguiseConfig.isMonstersIgnoreDisguises() && event.getTarget() != null && event.getTarget() instanceof Player while (reference == null && attempts++ < 1000)
&& DisguiseAPI.isDisguised(event.getTarget())) { {
switch (event.getReason()) { reference = "@";
case TARGET_ATTACKED_ENTITY: for (int i = 0; i < referenceLength; i++)
case TARGET_ATTACKED_OWNER: {
case OWNER_ATTACKED_TARGET: reference += alphabet[DisguiseUtilities.random.nextInt(alphabet.length)];
case CUSTOM: }
break; if (DisguiseUtilities.getClonedDisguise(reference) != null)
default: {
event.setCancelled(true); reference = null;
break; }
} }
} if (reference != null && DisguiseUtilities.addClonedDisguise(reference, disguise))
} {
p.sendMessage(ChatColor.RED + "Constructed a " + entityName + " disguise! Your reference is " + reference);
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) p.sendMessage(ChatColor.RED + "Example usage: /disguise " + reference);
public void onTeleport(final PlayerTeleportEvent event) { }
if (!DisguiseAPI.isDisguised(event.getPlayer())) { else
return; {
} p.sendMessage(
Location to = event.getTo(); ChatColor.RED + "Failed to store the reference due to lack of size. Please set this in the config");
Location from = event.getFrom(); }
if (DisguiseConfig.isBedPacketsEnabled()) { }
int x1 = (int) Math.floor(to.getX() / 16D) - 17; else if (disguiseEntity.containsKey(p.getName()))
int x2 = (int) Math.floor(from.getX() / 16D) - 17; {
int z1 = (int) Math.floor(to.getZ() / 16D) - 17; Disguise disguise = disguiseEntity.remove(p.getName());
int z2 = (int) Math.floor(from.getZ() / 16D) - 17; if (disguise != null)
if (x1 - (x1 % 8) != x2 - (x2 % 8) || z1 - (z1 % 8) != z2 - (z2 % 8)) { {
chunkMove(event.getPlayer(), null, from); if (disguise.isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled()
Bukkit.getScheduler().runTask(plugin, new Runnable() { && entity instanceof LivingEntity)
@Override {
public void run() { p.sendMessage(ChatColor.RED
if (!event.isCancelled()) { + "Can't disguise a living entity as a misc disguise. This has been disabled in the config!");
chunkMove(event.getPlayer(), event.getTo(), null); }
} else { else
chunkMove(event.getPlayer(), event.getPlayer().getLocation(), null); {
} if (entity instanceof Player && DisguiseConfig.isNameOfPlayerShownAboveDisguise())
} {
}); if (disguise.getWatcher() instanceof LivingWatcher)
} {
} disguise.getWatcher().setCustomName(((Player) entity).getDisplayName());
if (DisguiseConfig.isUndisguiseOnWorldChange() && to.getWorld() != null && from.getWorld() != null if (DisguiseConfig.isNameAboveHeadAlwaysVisible())
&& to.getWorld() != from.getWorld()) { {
for (Disguise disguise : DisguiseAPI.getDisguises(event.getPlayer())) { disguise.getWatcher().setCustomNameVisible(true);
disguise.removeDisguise(); }
} }
} }
} DisguiseAPI.disguiseToAll(entity, disguise);
String disguiseName = "a ";
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) if (disguise instanceof PlayerDisguise)
public void onVehicleEnter(VehicleEnterEvent event) { {
if (event.getEntered() instanceof Player && DisguiseAPI.isDisguised((Player) event.getEntered(), event.getEntered())) { disguiseName = "the player " + ((PlayerDisguise) disguise).getName();
DisguiseUtilities.removeSelfDisguise((Player) event.getEntered()); }
((Player) event.getEntered()).updateInventory(); else
} {
} disguiseName += disguise.getType().toReadable();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) if (disguise.isDisguiseInUse())
public void onVehicleLeave(VehicleExitEvent event) { {
if (event.getExited() instanceof Player) { p.sendMessage(ChatColor.RED + "Disguised " + (entity instanceof Player ? "" : "the ") + entityName
final Disguise disguise = DisguiseAPI.getDisguise((Player) event.getExited(), event.getExited()); + " as " + disguiseName + "!");
if (disguise != null) { }
Bukkit.getScheduler().runTask(plugin, new Runnable() { else
@Override {
public void run() { p.sendMessage(ChatColor.RED + "Failed to disguise " + (entity instanceof Player ? "" : "the ")
DisguiseUtilities.setupFakeDisguise(disguise); + entityName + " as " + disguiseName + "!");
((Player) disguise.getEntity()).updateInventory(); }
} }
}); }
} else
} {
} if (DisguiseAPI.isDisguised(entity))
{
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) DisguiseAPI.undisguiseToAll(entity);
public void onWorldSwitch(final PlayerChangedWorldEvent event) { p.sendMessage(ChatColor.RED + "Undisguised " + (entity instanceof Player ? "" : "the ") + entityName);
if (!DisguiseAPI.isDisguised(event.getPlayer())) { }
return; else
} {
if (DisguiseConfig.isBedPacketsEnabled()) { p.sendMessage(ChatColor.RED + (entity instanceof Player ? "" : "the") + entityName + " isn't disguised!");
chunkMove(event.getPlayer(), event.getPlayer().getLocation(), null); }
} }
if (DisguiseConfig.isUndisguiseOnWorldChange()) { }
for (Disguise disguise : DisguiseAPI.getDisguises(event.getPlayer())) { }
disguise.removeDisguise(); }
}
} else { @EventHandler
//Stupid hack to fix worldswitch invisibility bug public void onTarget(EntityTargetEvent event)
final boolean viewSelfToggled = DisguiseAPI.isViewSelfToggled(event.getPlayer()); {
if (viewSelfToggled) { if (DisguiseConfig.isMonstersIgnoreDisguises() && event.getTarget() != null && event.getTarget() instanceof Player
final Disguise disguise = DisguiseAPI.getDisguise(event.getPlayer()); && DisguiseAPI.isDisguised(event.getTarget()))
disguise.setViewSelfDisguise(false); {
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() { switch (event.getReason())
@Override {
public void run() { case TARGET_ATTACKED_ENTITY:
disguise.setViewSelfDisguise(true); case TARGET_ATTACKED_OWNER:
} case OWNER_ATTACKED_TARGET:
}, 20L); //I wish I could use lambdas here, so badly case CUSTOM:
} break;
} default:
} event.setCancelled(true);
break;
public void setDisguiseClone(final String player, Boolean[] options) { }
if (disguiseRunnable.containsKey(player)) { }
BukkitRunnable run = disguiseRunnable.remove(player); }
run.cancel();
run.run(); @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
} public void onTeleport(final PlayerTeleportEvent event)
BukkitRunnable runnable = new BukkitRunnable() { {
@Override if (!DisguiseAPI.isDisguised(event.getPlayer()))
public void run() { {
disguiseClone.remove(player); return;
disguiseRunnable.remove(player); }
} Location to = event.getTo();
}; Location from = event.getFrom();
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseCloneExpire()); if (DisguiseConfig.isBedPacketsEnabled())
disguiseRunnable.put(player, runnable); {
disguiseClone.put(player, options); 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;
public void setDisguiseEntity(final String player, Disguise disguise) { int z2 = (int) Math.floor(from.getZ() / 16D) - 17;
if (disguiseRunnable.containsKey(player)) { if (x1 - (x1 % 8) != x2 - (x2 % 8) || z1 - (z1 % 8) != z2 - (z2 % 8))
BukkitRunnable run = disguiseRunnable.remove(player); {
run.cancel(); chunkMove(event.getPlayer(), null, from);
run.run(); Bukkit.getScheduler().runTask(plugin, new Runnable()
} {
BukkitRunnable runnable = new BukkitRunnable() { @Override
@Override public void run()
public void run() { {
disguiseEntity.remove(player); if (!event.isCancelled())
disguiseRunnable.remove(player); {
} chunkMove(event.getPlayer(), event.getTo(), null);
}; }
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseEntityExpire()); else
disguiseRunnable.put(player, runnable); {
disguiseEntity.put(player, disguise); 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);
}
}

2961
src/me/libraryaddict/disguise/utilities/DisguiseUtilities.java
View File

File diff suppressed because it is too large Load Diff