2016-05-11 23:47:08 +02:00
|
|
|
package me.libraryaddict.disguise;
|
|
|
|
|
2017-06-02 15:51:03 +02:00
|
|
|
import com.comphenix.protocol.PacketType;
|
|
|
|
import com.comphenix.protocol.ProtocolLibrary;
|
|
|
|
import com.comphenix.protocol.events.PacketContainer;
|
|
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.NativeGameMode;
|
|
|
|
import com.comphenix.protocol.wrappers.EnumWrappers.PlayerInfoAction;
|
|
|
|
import com.comphenix.protocol.wrappers.PlayerInfoData;
|
|
|
|
import com.comphenix.protocol.wrappers.WrappedChatComponent;
|
2017-05-28 00:23:15 +02:00
|
|
|
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
2017-08-06 02:23:47 +02:00
|
|
|
import me.libraryaddict.disguise.disguisetypes.Disguise;
|
|
|
|
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
|
|
|
|
import me.libraryaddict.disguise.disguisetypes.PlayerDisguise;
|
|
|
|
import me.libraryaddict.disguise.disguisetypes.TargetedDisguise;
|
2017-06-02 15:51:03 +02:00
|
|
|
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
|
|
|
import me.libraryaddict.disguise.utilities.DisguiseUtilities;
|
|
|
|
import me.libraryaddict.disguise.utilities.UpdateChecker;
|
2018-09-07 04:35:38 +02:00
|
|
|
import me.libraryaddict.disguise.utilities.parser.DisguiseParseException;
|
|
|
|
import me.libraryaddict.disguise.utilities.parser.DisguiseParser;
|
2018-10-05 01:04:30 +02:00
|
|
|
import me.libraryaddict.disguise.utilities.parser.DisguisePerm;
|
2018-10-23 23:13:13 +02:00
|
|
|
import me.libraryaddict.disguise.utilities.parser.DisguisePermissions;
|
2019-01-12 05:07:54 +01:00
|
|
|
import me.libraryaddict.disguise.utilities.translations.LibsMsg;
|
2016-05-11 23:47:08 +02:00
|
|
|
import org.bukkit.Bukkit;
|
|
|
|
import org.bukkit.Location;
|
2017-06-02 15:51:03 +02:00
|
|
|
import org.bukkit.World;
|
2018-12-16 02:47:42 +01:00
|
|
|
import org.bukkit.command.CommandSender;
|
2016-05-11 23:47:08 +02:00
|
|
|
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;
|
2017-06-02 15:51:03 +02:00
|
|
|
import org.bukkit.event.player.*;
|
2016-05-11 23:47:08 +02:00
|
|
|
import org.bukkit.event.vehicle.VehicleEnterEvent;
|
|
|
|
import org.bukkit.event.vehicle.VehicleExitEvent;
|
2017-05-28 00:23:15 +02:00
|
|
|
import org.bukkit.event.world.ChunkLoadEvent;
|
|
|
|
import org.bukkit.event.world.ChunkUnloadEvent;
|
2017-06-02 15:51:03 +02:00
|
|
|
import org.bukkit.event.world.WorldLoadEvent;
|
|
|
|
import org.bukkit.event.world.WorldUnloadEvent;
|
2016-05-11 23:47:08 +02:00
|
|
|
import org.bukkit.scheduler.BukkitRunnable;
|
|
|
|
import org.bukkit.scheduler.BukkitTask;
|
2017-08-06 02:23:47 +02:00
|
|
|
import org.bukkit.scoreboard.Team;
|
2016-05-11 23:47:08 +02:00
|
|
|
|
2017-06-02 15:51:03 +02:00
|
|
|
import java.lang.reflect.InvocationTargetException;
|
2019-03-05 05:46:47 +01:00
|
|
|
import java.util.*;
|
2018-12-16 02:47:42 +01:00
|
|
|
import java.util.concurrent.TimeUnit;
|
2016-05-11 23:47:08 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
public class DisguiseListener implements Listener {
|
2016-05-11 23:47:08 +02:00
|
|
|
private String currentVersion;
|
|
|
|
private HashMap<String, Boolean[]> disguiseClone = new HashMap<>();
|
2019-03-05 05:46:47 +01:00
|
|
|
private HashMap<String, String[]> disguiseEntity = new HashMap<>();
|
2017-02-19 15:53:03 +01:00
|
|
|
private HashMap<String, String[]> disguiseModify = new HashMap<>();
|
2016-05-11 23:47:08 +02:00
|
|
|
private HashMap<String, BukkitRunnable> disguiseRunnable = new HashMap<>();
|
|
|
|
private String latestVersion;
|
2018-12-16 02:47:42 +01:00
|
|
|
private LibsMsg updateMessage;
|
2016-05-11 23:47:08 +02:00
|
|
|
private LibsDisguises plugin;
|
|
|
|
private BukkitTask updaterTask;
|
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
public DisguiseListener(LibsDisguises libsDisguises) {
|
2016-05-11 23:47:08 +02:00
|
|
|
plugin = libsDisguises;
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2018-12-16 02:47:42 +01:00
|
|
|
runUpdateScheduler();
|
2017-06-02 15:51:03 +02:00
|
|
|
|
|
|
|
if (!DisguiseConfig.isSaveEntityDisguises())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (World world : Bukkit.getWorlds()) {
|
|
|
|
for (Entity entity : world.getEntities()) {
|
|
|
|
Disguise[] disguises = DisguiseUtilities.getSavedDisguises(entity.getUniqueId(), true);
|
|
|
|
|
|
|
|
if (disguises.length <= 0)
|
|
|
|
continue;
|
|
|
|
|
2017-06-22 18:14:19 +02:00
|
|
|
DisguiseUtilities.resetPluginTimer();
|
|
|
|
|
2017-06-02 15:51:03 +02:00
|
|
|
for (Disguise disguise : disguises) {
|
|
|
|
disguise.setEntity(entity);
|
|
|
|
disguise.startDisguise();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
|
2018-12-16 02:47:42 +01:00
|
|
|
private boolean isCheckReleases() {
|
|
|
|
if (DisguiseConfig.getUpdatesBranch() == DisguiseConfig.UpdatesBranch.RELEASES) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DisguiseConfig.getUpdatesBranch() == DisguiseConfig.UpdatesBranch.SAME_BUILDS && plugin.isReleaseBuild()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If build number is null, or not a number. Then we can't check snapshots regardless
|
2019-05-18 08:54:51 +02:00
|
|
|
return !plugin.isNumberedBuild();
|
2018-12-16 02:47:42 +01:00
|
|
|
|
|
|
|
// Check snapshots
|
|
|
|
}
|
|
|
|
|
|
|
|
private void runUpdateScheduler() {
|
|
|
|
if (!plugin.getConfig().getBoolean("NotifyUpdate")) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
updaterTask = Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
UpdateChecker updateChecker = new UpdateChecker("32453");
|
|
|
|
boolean checkReleases = isCheckReleases();
|
|
|
|
|
|
|
|
if (checkReleases) {
|
|
|
|
currentVersion = plugin.getDescription().getVersion();
|
|
|
|
updateChecker.checkOfficialUpdate(currentVersion);
|
|
|
|
String version = updateChecker.getLatestVersion();
|
|
|
|
|
|
|
|
if (version == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
latestVersion = version;
|
|
|
|
updateMessage = LibsMsg.UPDATE_READY;
|
|
|
|
} else {
|
|
|
|
updateChecker.checkSnapshotUpdate(Integer.parseInt(plugin.getBuildNo()));
|
|
|
|
|
|
|
|
if (updateChecker.getLatestSnapshot() <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
currentVersion = plugin.getBuildNo();
|
|
|
|
latestVersion = "" + updateChecker.getLatestSnapshot();
|
|
|
|
updateMessage = LibsMsg.UPDATE_READY_SNAPSHOT;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bukkit.getScheduler().runTask(plugin, new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
notifyUpdate(Bukkit.getConsoleSender());
|
|
|
|
|
|
|
|
for (Player p : Bukkit.getOnlinePlayers()) {
|
|
|
|
notifyUpdate(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
catch (Exception ex) {
|
|
|
|
DisguiseUtilities.getLogger()
|
|
|
|
.warning(String.format("Failed to check for update: %s", ex.getMessage()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, 0, (20 * TimeUnit.HOURS.toSeconds(6))); // Check every 6 hours
|
|
|
|
}
|
|
|
|
|
|
|
|
private void notifyUpdate(CommandSender player) {
|
|
|
|
if (!player.hasPermission(DisguiseConfig.getUpdateNotificationPermission())) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (latestVersion == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
player.sendMessage(updateMessage.get(currentVersion, latestVersion));
|
|
|
|
}
|
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
public void cleanup() {
|
|
|
|
for (BukkitRunnable r : disguiseRunnable.values()) {
|
2016-05-11 23:47:08 +02:00
|
|
|
r.cancel();
|
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
disguiseClone.clear();
|
|
|
|
updaterTask.cancel();
|
|
|
|
}
|
|
|
|
|
2017-06-22 13:58:48 +02:00
|
|
|
private void checkPlayerCanBlowDisguise(Player player) {
|
|
|
|
Disguise[] disguises = DisguiseAPI.getDisguises(player);
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if (disguises.length > 0) {
|
2017-06-22 13:58:48 +02:00
|
|
|
DisguiseAPI.undisguiseToAll(player);
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-06-19 19:06:35 +02:00
|
|
|
String blown = LibsMsg.BLOWN_DISGUISE.get();
|
|
|
|
|
|
|
|
if (blown.length() > 0) {
|
2017-06-22 13:58:48 +02:00
|
|
|
player.sendMessage(blown);
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-16 07:58:53 +01:00
|
|
|
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
|
|
|
public void onVelocity(PlayerVelocityEvent event) {
|
|
|
|
DisguiseUtilities.setPlayerVelocity(event.getPlayer());
|
|
|
|
}
|
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onAttack(EntityDamageByEntityEvent event) {
|
2017-06-22 13:58:48 +02:00
|
|
|
if (DisguiseConfig.isDisguiseBlownWhenAttacked() && event.getEntity() instanceof Player) {
|
|
|
|
checkPlayerCanBlowDisguise((Player) event.getEntity());
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
|
2017-06-22 13:58:48 +02:00
|
|
|
if (DisguiseConfig.isDisguiseBlownWhenAttacking() && event.getDamager() instanceof Player) {
|
|
|
|
checkPlayerCanBlowDisguise((Player) event.getDamager());
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-28 00:23:15 +02:00
|
|
|
@EventHandler
|
|
|
|
public void onChunkUnload(ChunkUnloadEvent event) {
|
|
|
|
if (!DisguiseConfig.isSaveEntityDisguises())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (Entity entity : event.getChunk().getEntities()) {
|
|
|
|
Disguise[] disguises = DisguiseAPI.getDisguises(entity);
|
|
|
|
|
|
|
|
if (disguises.length <= 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
DisguiseUtilities.saveDisguises(entity.getUniqueId(), disguises);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-02 15:51:03 +02:00
|
|
|
@EventHandler
|
|
|
|
public void onChunkUnload(WorldUnloadEvent event) {
|
|
|
|
if (!DisguiseConfig.isSaveEntityDisguises())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (Entity entity : event.getWorld().getEntities()) {
|
|
|
|
if (entity instanceof Player)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Disguise[] disguises = DisguiseAPI.getDisguises(entity);
|
|
|
|
|
|
|
|
if (disguises.length <= 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
DisguiseUtilities.saveDisguises(entity.getUniqueId(), disguises);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-28 00:23:15 +02:00
|
|
|
@EventHandler
|
|
|
|
public void onChunkLoad(ChunkLoadEvent event) {
|
|
|
|
if (!DisguiseConfig.isSaveEntityDisguises())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (Entity entity : event.getChunk().getEntities()) {
|
2017-06-02 15:51:03 +02:00
|
|
|
Disguise[] disguises = DisguiseUtilities.getSavedDisguises(entity.getUniqueId(), true);
|
|
|
|
|
|
|
|
if (disguises.length <= 0)
|
|
|
|
continue;
|
|
|
|
|
2017-06-22 18:14:19 +02:00
|
|
|
DisguiseUtilities.resetPluginTimer();
|
|
|
|
|
2017-06-02 15:51:03 +02:00
|
|
|
for (Disguise disguise : disguises) {
|
|
|
|
disguise.setEntity(entity);
|
|
|
|
disguise.startDisguise();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
|
|
|
public void onWorldLoad(WorldLoadEvent event) {
|
|
|
|
if (!DisguiseConfig.isSaveEntityDisguises())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (Entity entity : event.getWorld().getEntities()) {
|
|
|
|
Disguise[] disguises = DisguiseUtilities.getSavedDisguises(entity.getUniqueId(), true);
|
2017-05-28 00:23:15 +02:00
|
|
|
|
|
|
|
if (disguises.length <= 0)
|
|
|
|
continue;
|
|
|
|
|
2017-06-22 18:14:19 +02:00
|
|
|
DisguiseUtilities.resetPluginTimer();
|
|
|
|
|
2017-05-28 00:23:15 +02:00
|
|
|
for (Disguise disguise : disguises) {
|
|
|
|
disguise.setEntity(entity);
|
|
|
|
disguise.startDisguise();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
@EventHandler
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onJoin(PlayerJoinEvent event) {
|
2016-05-11 23:47:08 +02:00
|
|
|
Player p = event.getPlayer();
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2018-12-16 02:47:42 +01:00
|
|
|
notifyUpdate(p);
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2018-02-14 08:15:56 +01:00
|
|
|
if (DisguiseConfig.isSaveGameProfiles() && DisguiseConfig.isUpdateGameProfiles() &&
|
|
|
|
DisguiseUtilities.hasGameProfile(p.getName())) {
|
2017-05-28 00:23:15 +02:00
|
|
|
WrappedGameProfile profile = WrappedGameProfile.fromPlayer(p);
|
|
|
|
|
|
|
|
if (!profile.getProperties().isEmpty()) {
|
|
|
|
DisguiseUtilities.addGameProfile(p.getName(), profile);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DisguiseConfig.isSavePlayerDisguises()) {
|
2017-06-02 15:51:03 +02:00
|
|
|
Disguise[] disguises = DisguiseUtilities.getSavedDisguises(p.getUniqueId(), true);
|
2017-05-28 00:23:15 +02:00
|
|
|
|
2017-06-22 18:14:19 +02:00
|
|
|
if (disguises.length > 0) {
|
|
|
|
DisguiseUtilities.resetPluginTimer();
|
|
|
|
}
|
|
|
|
|
2017-05-28 00:23:15 +02:00
|
|
|
for (Disguise disguise : disguises) {
|
|
|
|
disguise.setEntity(p);
|
|
|
|
disguise.startDisguise();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
for (HashSet<TargetedDisguise> disguiseList : DisguiseUtilities.getDisguises().values()) {
|
|
|
|
for (TargetedDisguise targetedDisguise : disguiseList) {
|
|
|
|
if (targetedDisguise.getEntity() == null)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!targetedDisguise.canSee(p))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!(targetedDisguise instanceof PlayerDisguise))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
PlayerDisguise disguise = (PlayerDisguise) targetedDisguise;
|
|
|
|
|
|
|
|
if (disguise.isDisplayedInTab()) {
|
|
|
|
try {
|
|
|
|
PacketContainer addTab = new PacketContainer(PacketType.Play.Server.PLAYER_INFO);
|
|
|
|
|
|
|
|
addTab.getPlayerInfoAction().write(0, PlayerInfoAction.ADD_PLAYER);
|
2018-02-14 08:15:56 +01:00
|
|
|
addTab.getPlayerInfoDataLists().write(0, Collections.singletonList(
|
2017-05-28 00:23:15 +02:00
|
|
|
new PlayerInfoData(disguise.getGameProfile(), 0, NativeGameMode.SURVIVAL,
|
|
|
|
WrappedChatComponent.fromText(disguise.getGameProfile().getName()))));
|
2016-11-30 05:08:12 +01:00
|
|
|
|
|
|
|
ProtocolLibrary.getProtocolManager().sendServerPacket(p, addTab);
|
|
|
|
}
|
|
|
|
catch (InvocationTargetException e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Most likely faster if we don't bother doing checks if he sees a player disguise
|
|
|
|
*/
|
|
|
|
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onMove(PlayerMoveEvent event) {
|
2019-01-12 05:07:54 +01:00
|
|
|
// If the bounding boxes are modified and the player moved more than a little
|
|
|
|
// The runnable in Disguise also calls it, so we should ignore smaller movements
|
|
|
|
if (DisguiseConfig.isModifyBoundingBox() && event.getFrom().distanceSquared(event.getTo()) > 0.2) {
|
|
|
|
// Only fetching one disguise as we cannot modify the bounding box of multiple disguises
|
|
|
|
Disguise disguise = DisguiseAPI.getDisguise(event.getPlayer());
|
|
|
|
|
|
|
|
// If disguise doesn't exist, or doesn't modify bounding box
|
|
|
|
if (disguise == null || !disguise.isModifyBoundingBox()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Modify bounding box
|
|
|
|
DisguiseUtilities.doBoundingBox((TargetedDisguise) disguise);
|
|
|
|
}
|
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if (DisguiseConfig.isStopShulkerDisguisesFromMoving()) {
|
2016-05-11 23:47:08 +02:00
|
|
|
Disguise disguise;
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if ((disguise = DisguiseAPI.getDisguise(event.getPlayer())) != null) {
|
2018-02-14 08:15:56 +01:00
|
|
|
if (disguise.getType() ==
|
|
|
|
DisguiseType.SHULKER) { // Stop Shulker disguises from moving their coordinates
|
2016-05-11 23:47:08 +02:00
|
|
|
Location from = event.getFrom();
|
|
|
|
Location to = event.getTo();
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
to.setX(from.getX());
|
|
|
|
to.setZ(from.getZ());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
event.setTo(to);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onQuit(PlayerQuitEvent event) {
|
2018-08-24 00:01:01 +02:00
|
|
|
Player player = event.getPlayer();
|
|
|
|
|
|
|
|
DisguiseUtilities.removeSelfDisguiseScoreboard(player);
|
|
|
|
|
2017-05-28 00:23:15 +02:00
|
|
|
if (!DisguiseConfig.isSavePlayerDisguises())
|
|
|
|
return;
|
|
|
|
|
|
|
|
Disguise[] disguises = DisguiseAPI.getDisguises(player);
|
|
|
|
|
|
|
|
if (disguises.length <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
DisguiseUtilities.saveDisguises(player.getUniqueId(), disguises);
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onRightClick(PlayerInteractEntityEvent event) {
|
2017-06-27 04:45:42 +02:00
|
|
|
Player p = event.getPlayer();
|
|
|
|
|
2018-02-14 08:15:56 +01:00
|
|
|
if (!disguiseEntity.containsKey(p.getName()) && !disguiseClone.containsKey(p.getName()) &&
|
|
|
|
!disguiseModify.containsKey(p.getName())) {
|
2017-02-19 15:53:03 +01:00
|
|
|
return;
|
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
event.setCancelled(true);
|
|
|
|
disguiseRunnable.remove(p.getName()).cancel();
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
Entity entity = event.getRightClicked();
|
|
|
|
String entityName;
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
if (entity instanceof Player && !disguiseClone.containsKey(p.getName())) {
|
|
|
|
entityName = entity.getName();
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2017-02-19 15:53:03 +01:00
|
|
|
entityName = DisguiseType.getType(entity).toReadable();
|
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
if (disguiseClone.containsKey(p.getName())) {
|
|
|
|
Boolean[] options = disguiseClone.remove(p.getName());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
DisguiseUtilities.createClonedDisguise(p, entity, options);
|
2017-05-28 00:23:15 +02:00
|
|
|
} else if (disguiseEntity.containsKey(p.getName())) {
|
2019-03-05 05:46:47 +01:00
|
|
|
String[] disguiseArgs = disguiseEntity.remove(p.getName());
|
|
|
|
|
|
|
|
if (disguiseArgs != null) {
|
|
|
|
Disguise disguise;
|
|
|
|
|
|
|
|
try {
|
|
|
|
disguise = DisguiseParser.parseDisguise(p, entity, "disguiseentity", disguiseArgs,
|
|
|
|
DisguiseParser.getPermissions(p, "disguiseentity"));
|
|
|
|
}
|
|
|
|
catch (DisguiseParseException e) {
|
|
|
|
if (e.getMessage() != null) {
|
|
|
|
p.sendMessage(e.getMessage());
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
catch (Exception e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
return;
|
|
|
|
}
|
2017-02-19 15:53:03 +01:00
|
|
|
|
2018-02-14 08:15:56 +01:00
|
|
|
if (disguise.isMiscDisguise() && !DisguiseConfig.isMiscDisguisesForLivingEnabled() &&
|
|
|
|
entity instanceof LivingEntity) {
|
2017-06-19 19:06:35 +02:00
|
|
|
p.sendMessage(LibsMsg.DISABLED_LIVING_TO_MISC.get());
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2017-02-19 15:53:03 +01:00
|
|
|
if (entity instanceof Player && DisguiseConfig.isNameOfPlayerShownAboveDisguise()) {
|
|
|
|
if (disguise.getWatcher() instanceof LivingWatcher) {
|
2017-08-06 02:23:47 +02:00
|
|
|
Team team = ((Player) entity).getScoreboard().getEntryTeam(entity.getName());
|
|
|
|
|
|
|
|
disguise.getWatcher().setCustomName(
|
2018-02-14 08:15:56 +01:00
|
|
|
(team == null ? "" : team.getPrefix()) + entity.getName() +
|
|
|
|
(team == null ? "" : team.getSuffix()));
|
2017-02-19 15:53:03 +01:00
|
|
|
|
|
|
|
if (DisguiseConfig.isNameAboveHeadAlwaysVisible()) {
|
|
|
|
disguise.getWatcher().setCustomNameVisible(true);
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
}
|
2017-02-19 15:53:03 +01:00
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2018-02-14 06:49:10 +01:00
|
|
|
DisguiseAPI.disguiseEntity(entity, disguise);
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-06-19 19:06:35 +02:00
|
|
|
String disguiseName;
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
if (disguise instanceof PlayerDisguise) {
|
2017-06-19 19:06:35 +02:00
|
|
|
disguiseName = ((PlayerDisguise) disguise).getName();
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2017-06-19 19:06:35 +02:00
|
|
|
disguiseName = disguise.getType().toReadable();
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2017-06-19 19:06:35 +02:00
|
|
|
// Jeez, maybe I should redo my messages here
|
2017-02-19 15:53:03 +01:00
|
|
|
if (disguise.isDisguiseInUse()) {
|
2017-06-19 19:06:35 +02:00
|
|
|
if (disguise.isPlayerDisguise()) {
|
|
|
|
if (entity instanceof Player) {
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_ENTITY_PLAYER_DISG_PLAYER.get(entityName, disguiseName));
|
|
|
|
} else {
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_ENTITY_ENTITY_DISG_PLAYER.get(entityName, disguiseName));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (entity instanceof Player) {
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_ENTITY_PLAYER_DISG_ENTITY.get(entityName, disguiseName));
|
|
|
|
} else {
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_ENTITY_ENTITY_DISG_ENTITY.get(entityName, disguiseName));
|
|
|
|
}
|
|
|
|
}
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2017-06-19 19:06:35 +02:00
|
|
|
if (disguise.isPlayerDisguise()) {
|
|
|
|
if (entity instanceof Player) {
|
|
|
|
p.sendMessage(
|
|
|
|
LibsMsg.LISTEN_ENTITY_PLAYER_DISG_PLAYER_FAIL.get(entityName, disguiseName));
|
|
|
|
} else {
|
|
|
|
p.sendMessage(
|
|
|
|
LibsMsg.LISTEN_ENTITY_ENTITY_DISG_PLAYER_FAIL.get(entityName, disguiseName));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (entity instanceof Player) {
|
|
|
|
p.sendMessage(
|
|
|
|
LibsMsg.LISTEN_ENTITY_PLAYER_DISG_ENTITY_FAIL.get(entityName, disguiseName));
|
|
|
|
} else {
|
|
|
|
p.sendMessage(
|
|
|
|
LibsMsg.LISTEN_ENTITY_ENTITY_DISG_ENTITY_FAIL.get(entityName, disguiseName));
|
|
|
|
}
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
}
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2017-02-19 15:53:03 +01:00
|
|
|
if (DisguiseAPI.isDisguised(entity)) {
|
|
|
|
DisguiseAPI.undisguiseToAll(entity);
|
|
|
|
|
2017-06-19 19:06:35 +02:00
|
|
|
if (entity instanceof Player)
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_UNDISG_PLAYER.get(entityName));
|
|
|
|
else
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_UNDISG_ENT.get(entityName));
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2017-06-19 19:06:35 +02:00
|
|
|
if (entity instanceof Player)
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_UNDISG_PLAYER_FAIL.get(entityName));
|
|
|
|
else
|
|
|
|
p.sendMessage(LibsMsg.LISTEN_UNDISG_ENT_FAIL.get(entityName));
|
2017-02-19 15:53:03 +01:00
|
|
|
}
|
|
|
|
}
|
2017-05-28 00:23:15 +02:00
|
|
|
} else if (disguiseModify.containsKey(p.getName())) {
|
2017-02-19 15:53:03 +01:00
|
|
|
String[] options = disguiseModify.remove(p.getName());
|
|
|
|
|
|
|
|
Disguise disguise = DisguiseAPI.getDisguise(p, entity);
|
|
|
|
|
|
|
|
if (disguise == null) {
|
2017-06-19 19:06:35 +02:00
|
|
|
p.sendMessage(LibsMsg.UNDISG_PLAYER_FAIL.get(entityName));
|
2017-02-19 15:53:03 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-05 05:46:47 +01:00
|
|
|
options = DisguiseParser
|
|
|
|
.parsePlaceholders(options, p.getName(), DisguiseParser.getSkin(p), DisguiseParser.getName(entity),
|
|
|
|
DisguiseParser.getSkin(entity));
|
|
|
|
|
2018-10-23 23:13:13 +02:00
|
|
|
DisguisePermissions perms = DisguiseParser.getPermissions(p, "disguiseentitymodify");
|
|
|
|
DisguisePerm disguisePerm = new DisguisePerm(disguise.getType());
|
2017-02-19 15:53:03 +01:00
|
|
|
|
2018-10-23 23:13:13 +02:00
|
|
|
if (!perms.isAllowedDisguise(disguisePerm, Arrays.asList(options))) {
|
2017-06-19 19:06:35 +02:00
|
|
|
p.sendMessage(LibsMsg.DMODPLAYER_NOPERM.get());
|
2017-02-19 15:53:03 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
2019-03-05 05:46:47 +01:00
|
|
|
DisguiseParser.callMethods(p, disguise, perms, disguisePerm, new ArrayList<>(Arrays.asList(options)),
|
|
|
|
options);
|
2017-06-19 19:06:35 +02:00
|
|
|
p.sendMessage(LibsMsg.LISTENER_MODIFIED_DISG.get());
|
2017-02-19 15:53:03 +01:00
|
|
|
}
|
|
|
|
catch (DisguiseParseException ex) {
|
|
|
|
if (ex.getMessage() != null) {
|
|
|
|
p.sendMessage(ex.getMessage());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (Exception ex) {
|
|
|
|
ex.printStackTrace();
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onTarget(EntityTargetEvent event) {
|
2018-02-14 08:15:56 +01:00
|
|
|
if (DisguiseConfig.isMonstersIgnoreDisguises() && event.getTarget() != null &&
|
|
|
|
event.getTarget() instanceof Player && DisguiseAPI.isDisguised(event.getTarget())) {
|
2016-11-30 05:08:12 +01:00
|
|
|
switch (event.getReason()) {
|
2017-05-28 00:23:15 +02:00
|
|
|
case TARGET_ATTACKED_ENTITY:
|
|
|
|
case TARGET_ATTACKED_OWNER:
|
|
|
|
case OWNER_ATTACKED_TARGET:
|
|
|
|
case CUSTOM:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
event.setCancelled(true);
|
|
|
|
break;
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onTeleport(PlayerTeleportEvent event) {
|
2016-06-13 22:55:30 +02:00
|
|
|
final Player player = event.getPlayer();
|
2016-05-11 23:47:08 +02:00
|
|
|
Location to = event.getTo();
|
|
|
|
Location from = event.getFrom();
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if (!DisguiseAPI.isDisguised(player)) {
|
2016-06-13 22:55:30 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-14 08:15:56 +01:00
|
|
|
if (DisguiseConfig.isUndisguiseOnWorldChange() && to.getWorld() != null && from.getWorld() != null &&
|
|
|
|
to.getWorld() != from.getWorld()) {
|
2016-11-30 05:08:12 +01:00
|
|
|
for (Disguise disguise : DisguiseAPI.getDisguises(event.getPlayer())) {
|
2016-05-11 23:47:08 +02:00
|
|
|
disguise.removeDisguise();
|
|
|
|
}
|
|
|
|
}
|
2018-11-23 01:29:02 +01:00
|
|
|
|
2019-02-04 05:20:03 +01:00
|
|
|
if (DisguiseAPI.isSelfDisguised(player) && to.getWorld() == from.getWorld()) {
|
2018-11-23 01:29:02 +01:00
|
|
|
Disguise disguise = DisguiseAPI.getDisguise(player, player);
|
|
|
|
|
|
|
|
// If further than 64 blocks, resend the self disguise
|
|
|
|
if (disguise != null && disguise.isSelfDisguiseVisible() && from.distanceSquared(to) > 4096) {
|
|
|
|
// Send a packet to destroy the fake entity so that we can resend it without glitches
|
|
|
|
PacketContainer packet = DisguiseUtilities.getDestroyPacket(DisguiseAPI.getSelfDisguiseId());
|
|
|
|
|
|
|
|
try {
|
|
|
|
ProtocolLibrary.getProtocolManager().sendServerPacket(player, packet);
|
|
|
|
}
|
|
|
|
catch (Exception ex) {
|
|
|
|
ex.printStackTrace();
|
|
|
|
}
|
|
|
|
|
|
|
|
new BukkitRunnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (event.isCancelled() || !disguise.isDisguiseInUse()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
DisguiseUtilities.sendSelfDisguise(player, (TargetedDisguise) disguise);
|
|
|
|
}
|
|
|
|
}.runTaskLater(LibsDisguises.getInstance(), 4);
|
|
|
|
}
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onVehicleEnter(VehicleEnterEvent event) {
|
2018-02-14 08:15:56 +01:00
|
|
|
if (event.getEntered() instanceof Player &&
|
|
|
|
DisguiseAPI.isDisguised((Player) event.getEntered(), event.getEntered())) {
|
2016-05-11 23:47:08 +02:00
|
|
|
DisguiseUtilities.removeSelfDisguise((Player) event.getEntered());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
((Player) event.getEntered()).updateInventory();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onVehicleLeave(VehicleExitEvent event) {
|
|
|
|
if (event.getExited() instanceof Player) {
|
2016-05-11 23:47:08 +02:00
|
|
|
final Disguise disguise = DisguiseAPI.getDisguise((Player) event.getExited(), event.getExited());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if (disguise != null) {
|
|
|
|
Bukkit.getScheduler().runTask(plugin, new Runnable() {
|
2016-05-11 23:47:08 +02:00
|
|
|
@Override
|
2016-11-30 05:08:12 +01:00
|
|
|
public void run() {
|
2016-05-11 23:47:08 +02:00
|
|
|
DisguiseUtilities.setupFakeDisguise(disguise);
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
((Player) disguise.getEntity()).updateInventory();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
|
2016-11-30 05:08:12 +01:00
|
|
|
public void onWorldSwitch(final PlayerChangedWorldEvent event) {
|
|
|
|
if (!DisguiseAPI.isDisguised(event.getPlayer())) {
|
2016-06-13 22:55:30 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if (DisguiseConfig.isUndisguiseOnWorldChange()) {
|
|
|
|
for (Disguise disguise : DisguiseAPI.getDisguises(event.getPlayer())) {
|
2016-05-11 23:47:08 +02:00
|
|
|
disguise.removeDisguise();
|
|
|
|
}
|
2017-05-28 00:23:15 +02:00
|
|
|
} else {
|
2016-05-11 23:47:08 +02:00
|
|
|
// Stupid hack to fix worldswitch invisibility bug
|
|
|
|
final boolean viewSelfToggled = DisguiseAPI.isViewSelfToggled(event.getPlayer());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
if (viewSelfToggled) {
|
2016-05-11 23:47:08 +02:00
|
|
|
final Disguise disguise = DisguiseAPI.getDisguise(event.getPlayer());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
disguise.setViewSelfDisguise(false);
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
|
2016-05-11 23:47:08 +02:00
|
|
|
@Override
|
2016-11-30 05:08:12 +01:00
|
|
|
public void run() {
|
2016-05-11 23:47:08 +02:00
|
|
|
disguise.setViewSelfDisguise(true);
|
|
|
|
}
|
|
|
|
}, 20L); // I wish I could use lambdas here, so badly
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
public void setDisguiseClone(final String player, Boolean[] options) {
|
|
|
|
if (disguiseRunnable.containsKey(player)) {
|
2016-05-11 23:47:08 +02:00
|
|
|
BukkitRunnable run = disguiseRunnable.remove(player);
|
|
|
|
run.cancel();
|
|
|
|
run.run();
|
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
BukkitRunnable runnable = new BukkitRunnable() {
|
2016-05-11 23:47:08 +02:00
|
|
|
@Override
|
2016-11-30 05:08:12 +01:00
|
|
|
public void run() {
|
2016-05-11 23:47:08 +02:00
|
|
|
disguiseClone.remove(player);
|
|
|
|
disguiseRunnable.remove(player);
|
|
|
|
}
|
|
|
|
};
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseCloneExpire());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
disguiseRunnable.put(player, runnable);
|
|
|
|
disguiseClone.put(player, options);
|
|
|
|
}
|
|
|
|
|
2019-03-05 05:46:47 +01:00
|
|
|
public void setDisguiseEntity(final String player, String[] disguise) {
|
2016-11-30 05:08:12 +01:00
|
|
|
if (disguiseRunnable.containsKey(player)) {
|
2016-05-11 23:47:08 +02:00
|
|
|
BukkitRunnable run = disguiseRunnable.remove(player);
|
|
|
|
run.cancel();
|
|
|
|
run.run();
|
|
|
|
}
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-11-30 05:08:12 +01:00
|
|
|
BukkitRunnable runnable = new BukkitRunnable() {
|
2016-05-11 23:47:08 +02:00
|
|
|
@Override
|
2016-11-30 05:08:12 +01:00
|
|
|
public void run() {
|
2016-05-11 23:47:08 +02:00
|
|
|
disguiseEntity.remove(player);
|
|
|
|
disguiseRunnable.remove(player);
|
|
|
|
}
|
|
|
|
};
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseEntityExpire());
|
2016-06-13 22:55:30 +02:00
|
|
|
|
2016-05-11 23:47:08 +02:00
|
|
|
disguiseRunnable.put(player, runnable);
|
|
|
|
disguiseEntity.put(player, disguise);
|
|
|
|
}
|
|
|
|
|
2017-02-19 15:53:03 +01:00
|
|
|
public void setDisguiseModify(final String player, String[] args) {
|
|
|
|
if (disguiseRunnable.containsKey(player)) {
|
|
|
|
BukkitRunnable run = disguiseRunnable.remove(player);
|
|
|
|
run.cancel();
|
|
|
|
run.run();
|
|
|
|
}
|
|
|
|
|
|
|
|
BukkitRunnable runnable = new BukkitRunnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
disguiseModify.remove(player);
|
|
|
|
disguiseRunnable.remove(player);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
runnable.runTaskLater(plugin, 20 * DisguiseConfig.getDisguiseEntityExpire());
|
|
|
|
|
|
|
|
disguiseRunnable.put(player, runnable);
|
|
|
|
disguiseModify.put(player, args);
|
|
|
|
}
|
2016-05-11 23:47:08 +02:00
|
|
|
}
|