1149 lines
47 KiB
Java
1149 lines
47 KiB
Java
package me.libraryaddict.disguise.utilities;
|
|
|
|
import com.comphenix.protocol.PacketType;
|
|
import com.comphenix.protocol.PacketType.Play;
|
|
import com.comphenix.protocol.PacketType.Play.Server;
|
|
import com.comphenix.protocol.ProtocolLibrary;
|
|
import com.comphenix.protocol.events.PacketContainer;
|
|
import com.comphenix.protocol.events.PacketListener;
|
|
import com.comphenix.protocol.reflect.StructureModifier;
|
|
import com.comphenix.protocol.wrappers.WrappedAttribute;
|
|
import com.comphenix.protocol.wrappers.WrappedAttribute.Builder;
|
|
import com.comphenix.protocol.wrappers.WrappedDataWatcher;
|
|
import com.comphenix.protocol.wrappers.WrappedDataWatcher.Registry;
|
|
import com.comphenix.protocol.wrappers.WrappedDataWatcher.WrappedDataWatcherObject;
|
|
import com.comphenix.protocol.wrappers.WrappedGameProfile;
|
|
import com.comphenix.protocol.wrappers.WrappedWatchableObject;
|
|
import me.libraryaddict.disguise.DisguiseAPI;
|
|
import me.libraryaddict.disguise.DisguiseConfig;
|
|
import me.libraryaddict.disguise.LibsDisguises;
|
|
import me.libraryaddict.disguise.disguisetypes.*;
|
|
import me.libraryaddict.disguise.disguisetypes.watchers.FallingBlockWatcher;
|
|
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
|
|
import me.libraryaddict.disguise.disguisetypes.watchers.PlayerWatcher;
|
|
import me.libraryaddict.disguise.utilities.packetlisteners.*;
|
|
import org.bukkit.Art;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.entity.*;
|
|
import org.bukkit.inventory.EquipmentSlot;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.metadata.FixedMetadataValue;
|
|
import org.bukkit.util.Vector;
|
|
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.util.*;
|
|
import java.util.Map.Entry;
|
|
|
|
public class PacketsManager {
|
|
public static class LibsPackets {
|
|
private ArrayList<PacketContainer> packets = new ArrayList<>();
|
|
private HashMap<Integer, ArrayList<PacketContainer>> delayedPackets = new HashMap<>();
|
|
private boolean isSpawnPacket;
|
|
private Disguise disguise;
|
|
private boolean doNothing;
|
|
|
|
public void setUnhandled() {
|
|
doNothing = true;
|
|
}
|
|
|
|
public boolean isUnhandled() {
|
|
return doNothing;
|
|
}
|
|
|
|
private LibsPackets(Disguise disguise) {
|
|
this.disguise = disguise;
|
|
}
|
|
|
|
public Disguise getDisguise() {
|
|
return disguise;
|
|
}
|
|
|
|
public void setPacketType(PacketType type) {
|
|
isSpawnPacket = type.name().contains("SPAWN") && type.name().contains("ENTITY");
|
|
}
|
|
|
|
public void addPacket(PacketContainer packet) {
|
|
packets.add(packet);
|
|
}
|
|
|
|
public void addDelayedPacket(PacketContainer packet) {
|
|
addDelayedPacket(packet, 2);
|
|
}
|
|
|
|
public void clear() {
|
|
getPackets().clear();
|
|
}
|
|
|
|
public void addDelayedPacket(PacketContainer packet, int ticksDelayed) {
|
|
if (!delayedPackets.containsKey(ticksDelayed))
|
|
delayedPackets.put(ticksDelayed, new ArrayList<PacketContainer>());
|
|
|
|
delayedPackets.get(ticksDelayed).add(packet);
|
|
}
|
|
|
|
public ArrayList<PacketContainer> getPackets() {
|
|
return packets;
|
|
}
|
|
|
|
public Collection<ArrayList<PacketContainer>> getDelayedPackets() {
|
|
return delayedPackets.values();
|
|
}
|
|
|
|
public void sendDelayed(final Player observer) {
|
|
for (final Entry<Integer, ArrayList<PacketContainer>> entry : delayedPackets.entrySet()) {
|
|
Bukkit.getScheduler().scheduleSyncDelayedTask(libsDisguises, new Runnable() {
|
|
public void run() {
|
|
try {
|
|
for (PacketContainer packet : entry.getValue()) {
|
|
ProtocolLibrary.getProtocolManager().sendServerPacket(observer, packet, false);
|
|
}
|
|
}
|
|
catch (InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (isSpawnPacket) {
|
|
PacketsManager.removeCancel(disguise, observer);
|
|
}
|
|
}
|
|
}, entry.getKey());
|
|
}
|
|
}
|
|
}
|
|
|
|
private static PacketListener clientInteractEntityListener;
|
|
private static PacketListener inventoryListener;
|
|
private static boolean inventoryModifierEnabled;
|
|
private static LibsDisguises libsDisguises;
|
|
private static PacketListener mainListener;
|
|
private static PacketListener soundsListener;
|
|
private static boolean soundsListenerEnabled;
|
|
private static PacketListener viewDisguisesListener;
|
|
private static boolean viewDisguisesListenerEnabled;
|
|
private static HashMap<Disguise, ArrayList<UUID>> cancelMeta = new HashMap<>();
|
|
|
|
public static void addPacketListeners() {
|
|
// Add a client listener to cancel them interacting with uninteractable disguised entitys.
|
|
// You ain't supposed to be allowed to 'interact' with a item that cannot be clicked.
|
|
// Because it kicks you for hacking.
|
|
|
|
clientInteractEntityListener = new PacketListenerClientInteract(libsDisguises);
|
|
PacketListener tabListListener = new PacketListenerTabList(libsDisguises);
|
|
|
|
ProtocolLibrary.getProtocolManager().addPacketListener(clientInteractEntityListener);
|
|
ProtocolLibrary.getProtocolManager().addPacketListener(tabListListener);
|
|
|
|
// Now I call this and the main listener is registered!
|
|
setupMainPacketsListener();
|
|
}
|
|
|
|
public static void removeCancel(Disguise disguise, Player observer) {
|
|
ArrayList<UUID> cancel;
|
|
|
|
if ((cancel = cancelMeta.get(disguise)) == null)
|
|
return;
|
|
|
|
cancel.remove(observer.getUniqueId());
|
|
|
|
if (!cancel.isEmpty())
|
|
return;
|
|
|
|
cancelMeta.remove(disguise);
|
|
}
|
|
|
|
/**
|
|
* Construct the packets I need to spawn in the disguise
|
|
*/
|
|
private static LibsPackets constructSpawnPackets(final Player observer, LibsPackets packets,
|
|
Entity disguisedEntity) {
|
|
Disguise disguise = packets.getDisguise();
|
|
|
|
if (disguise.getEntity() == null) {
|
|
disguise.setEntity(disguisedEntity);
|
|
}
|
|
|
|
// This sends the armor packets so that the player isn't naked.
|
|
// Please note it only sends the packets that wouldn't be sent normally
|
|
if (DisguiseConfig.isEquipmentPacketsEnabled()) {
|
|
for (EquipmentSlot slot : EquipmentSlot.values()) {
|
|
ItemStack itemstack = disguise.getWatcher().getItemStack(slot);
|
|
|
|
if (itemstack == null || itemstack.getType() == Material.AIR) {
|
|
continue;
|
|
}
|
|
|
|
if (disguisedEntity instanceof LivingEntity) {
|
|
ItemStack item = ReflectionManager.getEquipment(slot, disguisedEntity);
|
|
|
|
if (item != null && item.getType() != Material.AIR) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
PacketContainer packet = new PacketContainer(Server.ENTITY_EQUIPMENT);
|
|
|
|
StructureModifier<Object> mods = packet.getModifier();
|
|
|
|
mods.write(0, disguisedEntity.getEntityId());
|
|
mods.write(1, ReflectionManager.createEnumItemSlot(slot));
|
|
mods.write(2, ReflectionManager.getNmsItem(itemstack));
|
|
|
|
packets.addDelayedPacket(packet);
|
|
}
|
|
}
|
|
|
|
if (DisguiseConfig.isMiscDisguisesForLivingEnabled()) {
|
|
if (disguise.getWatcher() instanceof LivingWatcher) {
|
|
|
|
ArrayList<WrappedAttribute> attributes = new ArrayList<>();
|
|
|
|
Builder builder = WrappedAttribute.newBuilder().attributeKey("generic.maxHealth");
|
|
|
|
if (((LivingWatcher) disguise.getWatcher()).isMaxHealthSet()) {
|
|
builder.baseValue(((LivingWatcher) disguise.getWatcher()).getMaxHealth());
|
|
} else if (DisguiseConfig.isMaxHealthDeterminedByDisguisedEntity() &&
|
|
disguisedEntity instanceof Damageable) {
|
|
builder.baseValue(((Damageable) disguisedEntity).getMaxHealth());
|
|
} else {
|
|
builder.baseValue(DisguiseValues.getDisguiseValues(disguise.getType()).getMaxHealth());
|
|
}
|
|
|
|
PacketContainer packet = new PacketContainer(Server.UPDATE_ATTRIBUTES);
|
|
|
|
builder.packet(packet);
|
|
|
|
attributes.add(builder.build());
|
|
|
|
packet.getIntegers().write(0, disguisedEntity.getEntityId());
|
|
packet.getAttributeCollectionModifier().write(0, attributes);
|
|
|
|
packets.addPacket(packet);
|
|
}
|
|
}
|
|
|
|
Location loc = disguisedEntity.getLocation().clone().add(0, getYModifier(disguisedEntity, disguise), 0);
|
|
|
|
byte yaw = (byte) (int) (loc.getYaw() * 256.0F / 360.0F);
|
|
byte pitch = (byte) (int) (loc.getPitch() * 256.0F / 360.0F);
|
|
|
|
if (DisguiseConfig.isMovementPacketsEnabled()) {
|
|
yaw = getYaw(disguise.getType(), disguisedEntity.getType(), yaw);
|
|
pitch = getPitch(disguise.getType(), DisguiseType.getType(disguisedEntity.getType()), pitch);
|
|
}
|
|
|
|
if (disguise.getType() == DisguiseType.EXPERIENCE_ORB) {
|
|
PacketContainer spawnOrb = new PacketContainer(Server.SPAWN_ENTITY_EXPERIENCE_ORB);
|
|
packets.addPacket(spawnOrb);
|
|
|
|
StructureModifier<Object> mods = spawnOrb.getModifier();
|
|
|
|
mods.write(0, disguisedEntity.getEntityId());
|
|
mods.write(1, loc.getX());
|
|
mods.write(2, loc.getY() + 0.06);
|
|
mods.write(3, loc.getZ());
|
|
mods.write(4, 1);
|
|
} else if (disguise.getType() == DisguiseType.PAINTING) {
|
|
PacketContainer spawnPainting = new PacketContainer(Server.SPAWN_ENTITY_PAINTING);
|
|
packets.addPacket(spawnPainting);
|
|
|
|
StructureModifier<Object> mods = spawnPainting.getModifier();
|
|
|
|
mods.write(0, disguisedEntity.getEntityId());
|
|
mods.write(1, disguisedEntity.getUniqueId());
|
|
mods.write(2, ReflectionManager.getBlockPosition(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
|
|
mods.write(3, ReflectionManager.getEnumDirection(((int) loc.getYaw()) % 4));
|
|
|
|
int id = ((MiscDisguise) disguise).getData();
|
|
|
|
mods.write(4, ReflectionManager.getEnumArt(Art.values()[id]));
|
|
|
|
// Make the teleport packet to make it visible..
|
|
PacketContainer teleportPainting = new PacketContainer(Server.ENTITY_TELEPORT);
|
|
packets.addPacket(teleportPainting);
|
|
|
|
mods = teleportPainting.getModifier();
|
|
|
|
mods.write(0, disguisedEntity.getEntityId());
|
|
mods.write(1, loc.getX());
|
|
mods.write(2, loc.getY());
|
|
mods.write(3, loc.getZ());
|
|
mods.write(4, yaw);
|
|
mods.write(5, pitch);
|
|
} else if (disguise.getType().isPlayer()) {
|
|
PlayerDisguise playerDisguise = (PlayerDisguise) disguise;
|
|
|
|
String name = playerDisguise.getName();
|
|
WrappedGameProfile gameProfile = playerDisguise.getGameProfile();
|
|
|
|
int entityId = disguisedEntity.getEntityId();
|
|
|
|
// Send player info along with the disguise
|
|
PacketContainer sendTab = new PacketContainer(Server.PLAYER_INFO);
|
|
|
|
if (!((PlayerDisguise) disguise).isDisplayedInTab()) {
|
|
// Add player to the list, necessary to spawn them
|
|
sendTab.getModifier().write(0, ReflectionManager.getEnumPlayerInfoAction(0));
|
|
|
|
List playerList = Collections
|
|
.singletonList(ReflectionManager.getPlayerInfoData(sendTab.getHandle(), gameProfile));
|
|
sendTab.getModifier().write(1, playerList);
|
|
|
|
packets.addPacket(sendTab);
|
|
}
|
|
|
|
// Spawn the player
|
|
PacketContainer spawnPlayer = new PacketContainer(PacketType.Play.Server.NAMED_ENTITY_SPAWN);
|
|
|
|
spawnPlayer.getIntegers().write(0, entityId); // Id
|
|
spawnPlayer.getModifier().write(1, gameProfile.getUUID());
|
|
|
|
Location spawnAt = disguisedEntity.getLocation();
|
|
|
|
boolean selfDisguise = observer == disguisedEntity;
|
|
|
|
WrappedDataWatcher newWatcher;
|
|
|
|
if (selfDisguise) {
|
|
newWatcher = createDataWatcher(WrappedDataWatcher.getEntityWatcher(disguisedEntity),
|
|
disguise.getWatcher());
|
|
} else {
|
|
newWatcher = new WrappedDataWatcher();
|
|
|
|
spawnAt = observer.getLocation();
|
|
spawnAt.add(spawnAt.getDirection().normalize().multiply(20));
|
|
}
|
|
|
|
// Spawn him in front of the observer
|
|
StructureModifier<Double> doubles = spawnPlayer.getDoubles();
|
|
doubles.write(0, spawnAt.getX());
|
|
doubles.write(1, spawnAt.getY());
|
|
doubles.write(2, spawnAt.getZ());
|
|
|
|
StructureModifier<Byte> bytes = spawnPlayer.getBytes();
|
|
bytes.write(0, yaw);
|
|
bytes.write(1, pitch);
|
|
|
|
spawnPlayer.getDataWatcherModifier().write(0, newWatcher);
|
|
|
|
// Make him invisible
|
|
newWatcher
|
|
.setObject(new WrappedDataWatcherObject(MetaIndex.ENTITY_META.getIndex(), Registry.get(Byte.class)),
|
|
(byte) 32);
|
|
|
|
packets.addPacket(spawnPlayer);
|
|
|
|
if (DisguiseConfig.isBedPacketsEnabled() && ((PlayerWatcher) disguise.getWatcher()).isSleeping()) {
|
|
PacketContainer[] bedPackets = DisguiseUtilities.getBedPackets(
|
|
loc.clone().subtract(0, PacketsManager.getYModifier(disguisedEntity, disguise), 0),
|
|
observer.getLocation(), ((PlayerDisguise) disguise));
|
|
|
|
for (PacketContainer packet : bedPackets) {
|
|
packets.addPacket(packet);
|
|
}
|
|
} else if (!selfDisguise) {
|
|
// Teleport the player back to where he's supposed to be
|
|
PacketContainer teleportPacket = new PacketContainer(PacketType.Play.Server.ENTITY_TELEPORT);
|
|
|
|
doubles = teleportPacket.getDoubles();
|
|
|
|
teleportPacket.getIntegers().write(0, entityId); // Id
|
|
doubles.write(0, loc.getX());
|
|
doubles.write(1, loc.getY());
|
|
doubles.write(2, loc.getZ());
|
|
|
|
bytes = teleportPacket.getBytes();
|
|
bytes.write(0, yaw);
|
|
bytes.write(1, pitch);
|
|
|
|
packets.addPacket(teleportPacket);
|
|
}
|
|
|
|
if (!selfDisguise) {
|
|
// Send a metadata packet
|
|
PacketContainer metaPacket = new PacketContainer(Play.Server.ENTITY_METADATA);
|
|
|
|
newWatcher = createDataWatcher(WrappedDataWatcher.getEntityWatcher(disguisedEntity),
|
|
disguise.getWatcher());
|
|
|
|
metaPacket.getIntegers().write(0, entityId); // Id
|
|
metaPacket.getWatchableCollectionModifier().write(0, newWatcher.getWatchableObjects());
|
|
|
|
if (!cancelMeta.containsKey(disguise))
|
|
cancelMeta.put(disguise, new ArrayList<UUID>());
|
|
|
|
cancelMeta.get(disguise).add(observer.getUniqueId());
|
|
|
|
packets.addDelayedPacket(metaPacket, 4);
|
|
}
|
|
|
|
// Remove player from the list
|
|
PacketContainer deleteTab = sendTab.shallowClone();
|
|
deleteTab.getModifier().write(0, ReflectionManager.getEnumPlayerInfoAction(4));
|
|
|
|
if (!((PlayerDisguise) disguise).isDisplayedInTab()) {
|
|
packets.addDelayedPacket(deleteTab, 40);
|
|
}
|
|
} else if (disguise.getType().isMob() || disguise.getType() == DisguiseType.ARMOR_STAND) {
|
|
Vector vec = disguisedEntity.getVelocity();
|
|
|
|
PacketContainer spawnEntity = new PacketContainer(PacketType.Play.Server.SPAWN_ENTITY_LIVING);
|
|
packets.addPacket(spawnEntity);
|
|
|
|
StructureModifier<Object> mods = spawnEntity.getModifier();
|
|
|
|
mods.write(0, disguisedEntity.getEntityId());
|
|
mods.write(1, disguisedEntity.getUniqueId());
|
|
mods.write(2, disguise.getType().getTypeId());
|
|
|
|
// region Vector calculations
|
|
double d1 = 3.9D;
|
|
double d2 = vec.getX();
|
|
double d3 = vec.getY();
|
|
double d4 = vec.getZ();
|
|
if (d2 < -d1)
|
|
d2 = -d1;
|
|
if (d3 < -d1)
|
|
d3 = -d1;
|
|
if (d4 < -d1)
|
|
d4 = -d1;
|
|
if (d2 > d1)
|
|
d2 = d1;
|
|
if (d3 > d1)
|
|
d3 = d1;
|
|
if (d4 > d1)
|
|
d4 = d1;
|
|
// endregion
|
|
|
|
mods.write(3, loc.getX());
|
|
mods.write(4, loc.getY());
|
|
mods.write(5, loc.getZ());
|
|
mods.write(6, (int) (d2 * 8000.0D));
|
|
mods.write(7, (int) (d3 * 8000.0D));
|
|
mods.write(8, (int) (d4 * 8000.0D));
|
|
mods.write(9, yaw);
|
|
mods.write(10, pitch);
|
|
mods.write(11, yaw);
|
|
|
|
spawnEntity.getDataWatcherModifier().write(0,
|
|
createDataWatcher(WrappedDataWatcher.getEntityWatcher(disguisedEntity), disguise.getWatcher()));
|
|
} else if (disguise.getType().isMisc()) {
|
|
int objectId = disguise.getType().getObjectId();
|
|
int data = ((MiscDisguise) disguise).getData();
|
|
|
|
if (disguise.getType() == DisguiseType.FALLING_BLOCK) {
|
|
ItemStack block = ((FallingBlockWatcher) disguise.getWatcher()).getBlock();
|
|
|
|
data = ReflectionManager.getCombinedIdByItemStack(block);
|
|
} else if (disguise.getType() == DisguiseType.FISHING_HOOK && data == -1) {
|
|
// If the MiscDisguise data isn't set. Then no entity id was provided, so default to the owners
|
|
// entity id
|
|
data = observer.getEntityId();
|
|
} else if (disguise.getType() == DisguiseType.ITEM_FRAME) {
|
|
data = ((((int) loc.getYaw() % 360) + 720 + 45) / 90) % 4;
|
|
}
|
|
|
|
Object nmsEntity = ReflectionManager.getNmsEntity(disguisedEntity);
|
|
|
|
PacketContainer spawnEntity = ProtocolLibrary.getProtocolManager()
|
|
.createPacketConstructor(PacketType.Play.Server.SPAWN_ENTITY, nmsEntity, objectId, data)
|
|
.createPacket(nmsEntity, objectId, data);
|
|
packets.addPacket(spawnEntity);
|
|
|
|
// If it's not the same type, then highly likely they have different velocity settings which we'd want to
|
|
// cancel
|
|
if (DisguiseType.getType(disguisedEntity) != disguise.getType()) {
|
|
StructureModifier<Integer> ints = spawnEntity.getIntegers();
|
|
|
|
ints.write(1, 0);
|
|
ints.write(2, 0);
|
|
ints.write(3, 0);
|
|
}
|
|
|
|
spawnEntity.getModifier().write(8, pitch);
|
|
spawnEntity.getModifier().write(9, yaw);
|
|
|
|
if (disguise.getType() == DisguiseType.ITEM_FRAME) {
|
|
if (data % 2 == 0) {
|
|
spawnEntity.getModifier().write(4, loc.getZ() + (data == 0 ? -1 : 1));
|
|
} else {
|
|
spawnEntity.getModifier().write(2, loc.getX() + (data == 3 ? -1 : 1));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (packets.getPackets().size() <= 1 || disguise.isPlayerDisguise()) {
|
|
PacketContainer rotateHead = new PacketContainer(Server.ENTITY_HEAD_ROTATION);
|
|
packets.addPacket(rotateHead);
|
|
|
|
StructureModifier<Object> mods = rotateHead.getModifier();
|
|
|
|
mods.write(0, disguisedEntity.getEntityId());
|
|
mods.write(1, yaw);
|
|
}
|
|
|
|
if (disguise.getType() == DisguiseType.EVOKER_FANGS) {
|
|
PacketContainer newPacket = new PacketContainer(Server.ENTITY_STATUS);
|
|
|
|
StructureModifier<Object> mods = newPacket.getModifier();
|
|
mods.write(0, disguise.getEntity().getEntityId());
|
|
mods.write(1, (byte) 4);
|
|
|
|
packets.addPacket(newPacket);
|
|
}
|
|
|
|
return packets;
|
|
}
|
|
|
|
/**
|
|
* Create a new datawatcher but with the 'correct' values
|
|
*/
|
|
private static WrappedDataWatcher createDataWatcher(WrappedDataWatcher watcher, FlagWatcher flagWatcher) {
|
|
WrappedDataWatcher newWatcher = new WrappedDataWatcher();
|
|
|
|
try {
|
|
List<WrappedWatchableObject> list =
|
|
DisguiseConfig.isMetadataPacketsEnabled() ? flagWatcher.convert(watcher.getWatchableObjects()) :
|
|
flagWatcher.getWatchableObjects();
|
|
|
|
for (WrappedWatchableObject watchableObject : list) {
|
|
if (watchableObject == null)
|
|
continue;
|
|
|
|
if (watchableObject.getValue() == null)
|
|
continue;
|
|
|
|
WrappedDataWatcherObject obj = ReflectionManager
|
|
.createDataWatcherObject(watchableObject.getIndex(), watchableObject.getValue());
|
|
|
|
newWatcher.setObject(obj, watchableObject.getValue());
|
|
}
|
|
}
|
|
catch (Exception ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
|
|
return newWatcher;
|
|
}
|
|
|
|
public static byte getPitch(DisguiseType disguiseType, DisguiseType entityType, byte value) {
|
|
return getPitch(disguiseType, getPitch(entityType, value));
|
|
}
|
|
|
|
private static byte getPitch(DisguiseType disguiseType, byte value) {
|
|
switch (disguiseType) {
|
|
case MINECART:
|
|
case MINECART_CHEST:
|
|
case MINECART_FURNACE:
|
|
case MINECART_HOPPER:
|
|
case MINECART_MOB_SPAWNER:
|
|
case MINECART_TNT:
|
|
case PHANTOM:
|
|
return (byte) -value;
|
|
default:
|
|
return value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add the yaw for the disguises
|
|
*/
|
|
public static byte getYaw(DisguiseType disguiseType, EntityType entityType, byte value) {
|
|
switch (disguiseType) {
|
|
case MINECART:
|
|
case MINECART_CHEST:
|
|
case MINECART_COMMAND:
|
|
case MINECART_FURNACE:
|
|
case MINECART_HOPPER:
|
|
case MINECART_MOB_SPAWNER:
|
|
case MINECART_TNT:
|
|
value += 64;
|
|
break;
|
|
case BOAT:
|
|
case ENDER_DRAGON:
|
|
case WITHER_SKULL:
|
|
value -= 128;
|
|
break;
|
|
case ARROW:
|
|
case TIPPED_ARROW:
|
|
case SPECTRAL_ARROW:
|
|
value = (byte) -value;
|
|
break;
|
|
case PAINTING:
|
|
case ITEM_FRAME:
|
|
value = (byte) -(value + 128);
|
|
break;
|
|
default:
|
|
if (disguiseType.isMisc() && disguiseType != DisguiseType.ARMOR_STAND) {
|
|
value -= 64;
|
|
}
|
|
|
|
break;
|
|
}
|
|
switch (entityType) {
|
|
case MINECART:
|
|
case MINECART_CHEST:
|
|
case MINECART_FURNACE:
|
|
case MINECART_HOPPER:
|
|
case MINECART_MOB_SPAWNER:
|
|
case MINECART_TNT:
|
|
value -= 64;
|
|
break;
|
|
case ENDER_DRAGON:
|
|
case WITHER_SKULL:
|
|
value += 128;
|
|
break;
|
|
case ARROW:
|
|
value = (byte) -value;
|
|
break;
|
|
case PAINTING:
|
|
case ITEM_FRAME:
|
|
value = (byte) -(value - 128);
|
|
break;
|
|
default:
|
|
if (!entityType.isAlive()) {
|
|
value += 64;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Get the Y level to add to the disguise for realism.
|
|
*/
|
|
public static double getYModifier(Entity entity, Disguise disguise) {
|
|
double yMod = 0;
|
|
|
|
if ((disguise.getType() != DisguiseType.PLAYER || !((PlayerWatcher) disguise.getWatcher()).isSleeping()) &&
|
|
entity.getType() == EntityType.DROPPED_ITEM) {
|
|
yMod -= 0.13;
|
|
}
|
|
|
|
switch (disguise.getType()) {
|
|
case BAT:
|
|
if (entity instanceof LivingEntity)
|
|
return yMod + ((LivingEntity) entity).getEyeHeight();
|
|
case MINECART:
|
|
case MINECART_COMMAND:
|
|
case MINECART_CHEST:
|
|
case MINECART_FURNACE:
|
|
case MINECART_HOPPER:
|
|
case MINECART_MOB_SPAWNER:
|
|
case MINECART_TNT:
|
|
switch (entity.getType()) {
|
|
case MINECART:
|
|
case MINECART_CHEST:
|
|
case MINECART_FURNACE:
|
|
case MINECART_HOPPER:
|
|
case MINECART_MOB_SPAWNER:
|
|
case MINECART_TNT:
|
|
return yMod;
|
|
default:
|
|
return yMod + 0.4;
|
|
}
|
|
case TIPPED_ARROW:
|
|
case SPECTRAL_ARROW:
|
|
case BOAT:
|
|
case EGG:
|
|
case ENDER_PEARL:
|
|
case ENDER_SIGNAL:
|
|
case FIREWORK:
|
|
case PAINTING:
|
|
case SMALL_FIREBALL:
|
|
case SNOWBALL:
|
|
case SPLASH_POTION:
|
|
case THROWN_EXP_BOTTLE:
|
|
case WITHER_SKULL:
|
|
return yMod + 0.7;
|
|
case PLAYER:
|
|
if (DisguiseConfig.isBedPacketsEnabled() && ((PlayerWatcher) disguise.getWatcher()).isSleeping()) {
|
|
return yMod + 0.35;
|
|
}
|
|
|
|
break;
|
|
case DROPPED_ITEM:
|
|
return yMod + 0.13;
|
|
default:
|
|
break;
|
|
}
|
|
return yMod;
|
|
}
|
|
|
|
/**
|
|
* Creates the packet listeners
|
|
*/
|
|
public static void init(LibsDisguises plugin) {
|
|
libsDisguises = plugin;
|
|
soundsListener = new PacketListenerSounds(libsDisguises);
|
|
|
|
// Self disguise (/vsd) listener
|
|
viewDisguisesListener = new PacketListenerViewDisguises(libsDisguises);
|
|
|
|
inventoryListener = new PacketListenerInventory(libsDisguises);
|
|
}
|
|
|
|
public static boolean isHearDisguisesEnabled() {
|
|
return soundsListenerEnabled;
|
|
}
|
|
|
|
public static boolean isInventoryListenerEnabled() {
|
|
return inventoryModifierEnabled;
|
|
}
|
|
|
|
public static boolean isViewDisguisesListenerEnabled() {
|
|
return viewDisguisesListenerEnabled;
|
|
}
|
|
|
|
public static void setHearDisguisesListener(boolean enabled) {
|
|
if (soundsListenerEnabled != enabled) {
|
|
soundsListenerEnabled = enabled;
|
|
|
|
if (soundsListenerEnabled) {
|
|
ProtocolLibrary.getProtocolManager().addPacketListener(soundsListener);
|
|
} else {
|
|
ProtocolLibrary.getProtocolManager().removePacketListener(soundsListener);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void setInventoryListenerEnabled(boolean enabled) {
|
|
if (inventoryModifierEnabled != enabled) {
|
|
inventoryModifierEnabled = enabled;
|
|
|
|
if (inventoryModifierEnabled) {
|
|
ProtocolLibrary.getProtocolManager().addPacketListener(inventoryListener);
|
|
} else {
|
|
ProtocolLibrary.getProtocolManager().removePacketListener(inventoryListener);
|
|
}
|
|
|
|
for (Player player : Bukkit.getOnlinePlayers()) {
|
|
Disguise disguise = DisguiseAPI.getDisguise(player, player);
|
|
|
|
if (disguise != null) {
|
|
if (viewDisguisesListenerEnabled && disguise.isSelfDisguiseVisible() &&
|
|
(disguise.isHidingArmorFromSelf() || disguise.isHidingHeldItemFromSelf())) {
|
|
player.updateInventory();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void setupMainPacketsListener() {
|
|
if (clientInteractEntityListener != null) {
|
|
if (mainListener != null) {
|
|
ProtocolLibrary.getProtocolManager().removePacketListener(mainListener);
|
|
}
|
|
|
|
ArrayList<PacketType> packetsToListen = new ArrayList<>();
|
|
// Add spawn packets
|
|
{
|
|
packetsToListen.add(Server.NAMED_ENTITY_SPAWN);
|
|
packetsToListen.add(Server.SPAWN_ENTITY_EXPERIENCE_ORB);
|
|
packetsToListen.add(Server.SPAWN_ENTITY);
|
|
packetsToListen.add(Server.SPAWN_ENTITY_LIVING);
|
|
packetsToListen.add(Server.SPAWN_ENTITY_PAINTING);
|
|
}
|
|
|
|
// Add packets that always need to be enabled to ensure safety
|
|
{
|
|
packetsToListen.add(Server.ENTITY_METADATA);
|
|
}
|
|
|
|
if (DisguiseConfig.isCollectPacketsEnabled()) {
|
|
packetsToListen.add(Server.COLLECT);
|
|
}
|
|
|
|
if (DisguiseConfig.isMiscDisguisesForLivingEnabled()) {
|
|
packetsToListen.add(Server.UPDATE_ATTRIBUTES);
|
|
}
|
|
|
|
// The bed packet.
|
|
if (DisguiseConfig.isBedPacketsEnabled()) {
|
|
packetsToListen.add(Server.BED);
|
|
}
|
|
|
|
// Add movement packets
|
|
if (DisguiseConfig.isMovementPacketsEnabled()) {
|
|
packetsToListen.add(Server.ENTITY_LOOK);
|
|
packetsToListen.add(Server.REL_ENTITY_MOVE_LOOK);
|
|
packetsToListen.add(Server.ENTITY_HEAD_ROTATION);
|
|
packetsToListen.add(Server.ENTITY_TELEPORT);
|
|
packetsToListen.add(Server.REL_ENTITY_MOVE);
|
|
packetsToListen.add(Server.ENTITY_VELOCITY);
|
|
}
|
|
|
|
// Add equipment packet
|
|
if (DisguiseConfig.isEquipmentPacketsEnabled()) {
|
|
packetsToListen.add(Server.ENTITY_EQUIPMENT);
|
|
}
|
|
|
|
// Add the packet that ensures if they are sleeping or not
|
|
if (DisguiseConfig.isAnimationPacketsEnabled()) {
|
|
packetsToListen.add(Server.ANIMATION);
|
|
}
|
|
|
|
// Add the packet that makes sure that entities with armor do not send unpickupable armor on death
|
|
if (DisguiseConfig.isEntityStatusPacketsEnabled()) {
|
|
packetsToListen.add(Server.ENTITY_STATUS);
|
|
}
|
|
|
|
mainListener = new PacketListenerMain(libsDisguises, packetsToListen);
|
|
|
|
ProtocolLibrary.getProtocolManager().addPacketListener(mainListener);
|
|
}
|
|
}
|
|
|
|
public static void setViewDisguisesListener(boolean enabled) {
|
|
if (viewDisguisesListenerEnabled != enabled) {
|
|
viewDisguisesListenerEnabled = enabled;
|
|
|
|
if (viewDisguisesListenerEnabled) {
|
|
ProtocolLibrary.getProtocolManager().addPacketListener(viewDisguisesListener);
|
|
} else {
|
|
ProtocolLibrary.getProtocolManager().removePacketListener(viewDisguisesListener);
|
|
}
|
|
|
|
for (Player player : Bukkit.getOnlinePlayers()) {
|
|
Disguise disguise = DisguiseAPI.getDisguise(player, player);
|
|
|
|
if (disguise != null) {
|
|
if (disguise.isSelfDisguiseVisible()) {
|
|
if (enabled) {
|
|
DisguiseUtilities.setupFakeDisguise(disguise);
|
|
} else {
|
|
DisguiseUtilities.removeSelfDisguise(player);
|
|
}
|
|
|
|
if (inventoryModifierEnabled &&
|
|
(disguise.isHidingArmorFromSelf() || disguise.isHidingHeldItemFromSelf())) {
|
|
player.updateInventory();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Transform the packet magically into the one I have always dreamed off. My true luv!!! This will return null if
|
|
* its not
|
|
* transformed
|
|
*/
|
|
public static LibsPackets transformPacket(PacketContainer sentPacket, Disguise disguise, Player observer,
|
|
Entity entity) {
|
|
LibsPackets packets = new LibsPackets(disguise);
|
|
|
|
try {
|
|
packets.addPacket(sentPacket);
|
|
|
|
// This packet sends attributes
|
|
if (sentPacket.getType() == Server.UPDATE_ATTRIBUTES) {
|
|
if (disguise.isMiscDisguise()) {
|
|
packets.clear();
|
|
} else {
|
|
List<WrappedAttribute> attributes = new ArrayList<>();
|
|
|
|
for (WrappedAttribute attribute : sentPacket.getAttributeCollectionModifier().read(0)) {
|
|
if (attribute.getAttributeKey().equals("generic.maxHealth")) {
|
|
packets.clear();
|
|
|
|
PacketContainer updateAttributes = new PacketContainer(Server.UPDATE_ATTRIBUTES);
|
|
packets.addPacket(updateAttributes);
|
|
|
|
Builder builder;
|
|
|
|
if (((LivingWatcher) disguise.getWatcher()).isMaxHealthSet()) {
|
|
builder = WrappedAttribute.newBuilder();
|
|
builder.attributeKey("generic.maxHealth");
|
|
builder.baseValue(((LivingWatcher) disguise.getWatcher()).getMaxHealth());
|
|
} else if (DisguiseConfig.isMaxHealthDeterminedByDisguisedEntity()) {
|
|
builder = WrappedAttribute.newBuilder(attribute);
|
|
} else {
|
|
builder = WrappedAttribute.newBuilder();
|
|
builder.attributeKey("generic.maxHealth");
|
|
builder.baseValue(DisguiseValues.getDisguiseValues(disguise.getType()).getMaxHealth());
|
|
}
|
|
|
|
builder.packet(updateAttributes);
|
|
|
|
attributes.add(builder.build());
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!attributes.isEmpty()) {
|
|
packets.getPackets().get(0).getIntegers().write(0, entity.getEntityId());
|
|
packets.getPackets().get(0).getAttributeCollectionModifier().write(0, attributes);
|
|
} else {
|
|
packets.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Else if the packet is sending entity metadata
|
|
else if (sentPacket.getType() == Server.ENTITY_METADATA) {
|
|
packets.clear();
|
|
|
|
if (DisguiseConfig.isMetadataPacketsEnabled() && (!cancelMeta.containsKey(disguise) ||
|
|
!cancelMeta.get(disguise).contains(observer.getUniqueId()))) {
|
|
List<WrappedWatchableObject> watchableObjects = disguise.getWatcher()
|
|
.convert(sentPacket.getWatchableCollectionModifier().read(0));
|
|
|
|
PacketContainer metaPacket = new PacketContainer(Server.ENTITY_METADATA);
|
|
|
|
packets.addPacket(metaPacket);
|
|
|
|
StructureModifier<Object> newMods = metaPacket.getModifier();
|
|
|
|
newMods.write(0, entity.getEntityId());
|
|
|
|
metaPacket.getWatchableCollectionModifier().write(0, watchableObjects);
|
|
}
|
|
}
|
|
|
|
// Else if the packet is spawning..
|
|
else if (sentPacket.getType() == Server.NAMED_ENTITY_SPAWN ||
|
|
sentPacket.getType() == Server.SPAWN_ENTITY_LIVING ||
|
|
sentPacket.getType() == Server.SPAWN_ENTITY_EXPERIENCE_ORB ||
|
|
sentPacket.getType() == Server.SPAWN_ENTITY ||
|
|
sentPacket.getType() == Server.SPAWN_ENTITY_PAINTING) {
|
|
packets.clear();
|
|
|
|
constructSpawnPackets(observer, packets, entity);
|
|
}
|
|
|
|
// Else if the disguise is attempting to send players a forbidden packet
|
|
else if (sentPacket.getType() == Server.ANIMATION) {
|
|
if (disguise.getType().isMisc() || (sentPacket.getIntegers().read(1) == 2 &&
|
|
(!disguise.getType().isPlayer() || (DisguiseConfig.isBedPacketsEnabled() &&
|
|
((PlayerWatcher) disguise.getWatcher()).isSleeping())))) {
|
|
packets.clear();
|
|
}
|
|
}
|
|
|
|
// Else if the disguise is collecting stuff
|
|
else if (sentPacket.getType() == Server.COLLECT) {
|
|
if (disguise.getType().isMisc()) {
|
|
packets.clear();
|
|
} else if (DisguiseConfig.isBedPacketsEnabled() && disguise.getType().isPlayer() &&
|
|
((PlayerWatcher) disguise.getWatcher()).isSleeping()) {
|
|
PacketContainer newPacket = new PacketContainer(Server.ANIMATION);
|
|
|
|
StructureModifier<Integer> mods = newPacket.getIntegers();
|
|
mods.write(0, disguise.getEntity().getEntityId());
|
|
mods.write(1, 3);
|
|
|
|
packets.clear();
|
|
|
|
packets.addPacket(newPacket);
|
|
packets.addPacket(sentPacket);
|
|
}
|
|
}
|
|
|
|
// Else if the disguise is moving.
|
|
else if (sentPacket.getType() == Server.REL_ENTITY_MOVE_LOOK ||
|
|
sentPacket.getType() == Server.ENTITY_LOOK || sentPacket.getType() == Server.ENTITY_TELEPORT ||
|
|
sentPacket.getType() == Server.REL_ENTITY_MOVE) {
|
|
if (disguise.getType() == DisguiseType.RABBIT && (sentPacket.getType() == Server.REL_ENTITY_MOVE ||
|
|
sentPacket.getType() == Server.REL_ENTITY_MOVE_LOOK)) {
|
|
// Rabbit robbing...
|
|
if (entity.getMetadata("LibsRabbitHop").isEmpty() ||
|
|
System.currentTimeMillis() - entity.getMetadata("LibsRabbitHop").get(0).asLong() < 100 ||
|
|
System.currentTimeMillis() - entity.getMetadata("LibsRabbitHop").get(0).asLong() > 500) {
|
|
if (entity.getMetadata("LibsRabbitHop").isEmpty() ||
|
|
System.currentTimeMillis() - entity.getMetadata("LibsRabbitHop").get(0).asLong() >
|
|
500) {
|
|
entity.removeMetadata("LibsRabbitHop", libsDisguises);
|
|
entity.setMetadata("LibsRabbitHop",
|
|
new FixedMetadataValue(libsDisguises, System.currentTimeMillis()));
|
|
}
|
|
|
|
PacketContainer statusPacket = new PacketContainer(Server.ENTITY_STATUS);
|
|
packets.addPacket(statusPacket);
|
|
|
|
statusPacket.getIntegers().write(0, entity.getEntityId());
|
|
statusPacket.getBytes().write(0, (byte) 1);
|
|
}
|
|
}
|
|
|
|
// Stop wither skulls from looking
|
|
if (sentPacket.getType() == Server.ENTITY_LOOK && disguise.getType() == DisguiseType.WITHER_SKULL) {
|
|
packets.clear();
|
|
} else if (sentPacket.getType() != Server.REL_ENTITY_MOVE) {
|
|
packets.clear();
|
|
|
|
PacketContainer movePacket = sentPacket.shallowClone();
|
|
|
|
packets.addPacket(movePacket);
|
|
|
|
StructureModifier<Byte> bytes = movePacket.getBytes();
|
|
|
|
byte yawValue = bytes.read(0);
|
|
byte pitchValue = bytes.read(1);
|
|
|
|
bytes.write(0, getYaw(disguise.getType(), entity.getType(), yawValue));
|
|
bytes.write(1, getPitch(disguise.getType(), DisguiseType.getType(entity.getType()), pitchValue));
|
|
|
|
if (sentPacket.getType() == Server.ENTITY_TELEPORT &&
|
|
disguise.getType() == DisguiseType.ITEM_FRAME) {
|
|
StructureModifier<Double> doubles = movePacket.getDoubles();
|
|
|
|
Location loc = entity.getLocation();
|
|
|
|
double data = (((loc.getYaw() % 360) + 720 + 45) / 90) % 4;
|
|
|
|
if (data % 2 == 0) {
|
|
if (data % 2 == 0) {
|
|
doubles.write(3, loc.getZ());
|
|
} else {
|
|
doubles.write(1, loc.getZ());
|
|
}
|
|
}
|
|
|
|
double y = getYModifier(entity, disguise);
|
|
|
|
if (y != 0) {
|
|
doubles.write(2, doubles.read(2) + y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Else if the disguise is updating equipment
|
|
else if (sentPacket.getType() == Server.ENTITY_EQUIPMENT) {
|
|
EquipmentSlot slot = ReflectionManager
|
|
.createEquipmentSlot(packets.getPackets().get(0).getModifier().read(1));
|
|
|
|
org.bukkit.inventory.ItemStack itemStack = disguise.getWatcher().getItemStack(slot);
|
|
|
|
if (itemStack != null) {
|
|
packets.clear();
|
|
|
|
PacketContainer equipPacket = sentPacket.shallowClone();
|
|
|
|
packets.addPacket(equipPacket);
|
|
|
|
equipPacket.getModifier().write(2,
|
|
ReflectionManager.getNmsItem(itemStack.getType() == Material.AIR ? null : itemStack));
|
|
}
|
|
|
|
if (disguise.getWatcher().isRightClicking() && slot == EquipmentSlot.HAND) {
|
|
ItemStack heldItem = packets.getPackets().get(0).getItemModifier().read(0);
|
|
|
|
if (heldItem != null && heldItem.getType() != Material.AIR) {
|
|
// Convert the datawatcher
|
|
List<WrappedWatchableObject> list = new ArrayList<>();
|
|
|
|
if (DisguiseConfig.isMetadataPacketsEnabled()) {
|
|
WrappedWatchableObject watch = ReflectionManager
|
|
.createWatchable(0, WrappedDataWatcher.getEntityWatcher(entity).getByte(0));
|
|
|
|
if (watch != null)
|
|
list.add(watch);
|
|
|
|
list = disguise.getWatcher().convert(list);
|
|
} else {
|
|
for (WrappedWatchableObject obj : disguise.getWatcher().getWatchableObjects()) {
|
|
if (obj.getIndex() == 0) {
|
|
list.add(obj);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Construct the packets to return
|
|
PacketContainer packetBlock = new PacketContainer(Server.ENTITY_METADATA);
|
|
|
|
packetBlock.getModifier().write(0, entity.getEntityId());
|
|
packetBlock.getWatchableCollectionModifier().write(0, list);
|
|
|
|
PacketContainer packetUnblock = packetBlock.deepClone();
|
|
// Make a packet to send the 'unblock'
|
|
for (WrappedWatchableObject watcher : packetUnblock.getWatchableCollectionModifier().read(0)) {
|
|
watcher.setValue((byte) ((byte) watcher.getValue() & ~(1 << 4)));
|
|
}
|
|
|
|
// Send the unblock before the itemstack change so that the 2nd metadata packet works. Why?
|
|
// Scheduler
|
|
// delay.
|
|
|
|
PacketContainer packet1 = packets.getPackets().get(0);
|
|
|
|
packets.clear();
|
|
|
|
packets.addPacket(packetUnblock);
|
|
packets.addPacket(packet1);
|
|
packets.addPacket(packetBlock);
|
|
// Silly mojang made the right clicking datawatcher value only valid for one use. So I have
|
|
// to reset
|
|
// it.
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the entity is going into a bed, stop everything but players from doing this
|
|
else if (sentPacket.getType() == Server.BED) {
|
|
if (!disguise.getType().isPlayer()) {
|
|
packets.clear();
|
|
}
|
|
}
|
|
|
|
// If the entity is updating their Facebook status, stop them from showing death
|
|
else if (sentPacket.getType() == Server.ENTITY_STATUS) {
|
|
if (packets.getPackets().get(0).getBytes().read(0) == (byte) 3) {
|
|
packets.clear();
|
|
}
|
|
}
|
|
|
|
// If the entity is sending velocity and its a falling block
|
|
else if (sentPacket.getType() == Server.ENTITY_VELOCITY) {
|
|
// If the disguise is a misc and the disguised is not the same type
|
|
if (disguise.getType().isMisc() && DisguiseType.getType(entity) != disguise.getType()) {
|
|
packets.clear();
|
|
}
|
|
}
|
|
|
|
// If the entity is rotating his head
|
|
else if (sentPacket.getType() == Server.ENTITY_HEAD_ROTATION) {
|
|
if (disguise.getType().isPlayer() && entity.getType() != EntityType.PLAYER) {
|
|
Location loc = entity.getLocation();
|
|
|
|
byte pitch = getPitch(disguise.getType(), DisguiseType.getType(entity.getType()),
|
|
(byte) (int) (loc.getPitch() * 256.0F / 360.0F));
|
|
byte yaw = getYaw(disguise.getType(), entity.getType(), sentPacket.getBytes().read(0));
|
|
|
|
PacketContainer rotation = new PacketContainer(Server.ENTITY_HEAD_ROTATION);
|
|
|
|
StructureModifier<Object> mods = rotation.getModifier();
|
|
|
|
mods.write(0, entity.getEntityId());
|
|
mods.write(1, yaw);
|
|
|
|
PacketContainer look = new PacketContainer(Server.ENTITY_LOOK);
|
|
|
|
look.getIntegers().write(0, entity.getEntityId());
|
|
look.getBytes().write(0, yaw);
|
|
look.getBytes().write(1, pitch);
|
|
|
|
packets.clear();
|
|
|
|
packets.addPacket(look);
|
|
packets.addPacket(rotation);
|
|
}
|
|
} else {
|
|
packets.setUnhandled();
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return packets;
|
|
}
|
|
}
|