353 Zeilen
15 KiB
Java
353 Zeilen
15 KiB
Java
package de.steamwar.fightsystem.utils;
|
|
|
|
import com.comphenix.protocol.PacketType;
|
|
import com.comphenix.protocol.ProtocolLibrary;
|
|
import com.comphenix.protocol.events.PacketAdapter;
|
|
import com.comphenix.protocol.events.PacketContainer;
|
|
import com.comphenix.protocol.events.PacketEvent;
|
|
import com.comphenix.protocol.reflect.StructureModifier;
|
|
import com.comphenix.protocol.wrappers.BlockPosition;
|
|
import com.comphenix.protocol.wrappers.ChunkCoordIntPair;
|
|
import com.comphenix.protocol.wrappers.MultiBlockChangeInfo;
|
|
import com.comphenix.protocol.wrappers.WrappedBlockData;
|
|
import com.comphenix.protocol.wrappers.nbt.NbtCompound;
|
|
import com.comphenix.protocol.wrappers.nbt.NbtFactory;
|
|
import com.google.common.primitives.Bytes;
|
|
import de.steamwar.fightsystem.FightSystem;
|
|
import de.steamwar.fightsystem.fight.Fight;
|
|
import de.steamwar.fightsystem.fight.FightTeam;
|
|
import javafx.util.Pair;
|
|
import net.minecraft.server.v1_12_R1.PacketPlayOutMapChunk;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.GameMode;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.craftbukkit.v1_12_R1.CraftChunk;
|
|
import org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer;
|
|
import org.bukkit.entity.Player;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public class TechHider {
|
|
|
|
private TechHider(){}
|
|
|
|
private static int arenaMinX;
|
|
private static int arenaMaxX;
|
|
private static int arenaMinZ;
|
|
private static int arenaMaxZ;
|
|
private static int blueMinX;
|
|
private static int blueMaxX;
|
|
private static int blueMinZ;
|
|
private static int blueMaxZ;
|
|
private static int redMinX;
|
|
private static int redMaxX;
|
|
private static int redMinZ;
|
|
private static int redMaxZ;
|
|
private static short obfuscateShift4;
|
|
private static final short BITMASK = 0x1FF;
|
|
private static Material obfuscateMaterial;
|
|
|
|
public static void init(){
|
|
arenaMinX = posToChunk(Config.ArenaMinX);
|
|
arenaMinZ = posToChunk(Config.ArenaMinZ);
|
|
blueMinX = posToChunk(Config.TeamBlueCornerX);
|
|
blueMinZ = posToChunk(Config.TeamBlueCornerZ);
|
|
redMinX = posToChunk(Config.TeamRedCornerX);
|
|
redMinZ = posToChunk(Config.TeamRedCornerZ);
|
|
|
|
arenaMaxX = posToChunk(Config.ArenaMaxX) + 1;
|
|
arenaMaxZ = posToChunk(Config.ArenaMaxZ) + 1;
|
|
blueMaxX = posToChunk(Config.TeamBlueCornerX + Config.SchemsizeX) + 1;
|
|
blueMaxZ = posToChunk(Config.TeamBlueCornerZ + Config.SchemsizeZ) + 1;
|
|
redMaxX = posToChunk(Config.TeamRedCornerX + Config.SchemsizeX) + 1;
|
|
redMaxZ = posToChunk(Config.TeamRedCornerZ + Config.SchemsizeZ) + 1;
|
|
|
|
obfuscateShift4 = (short)(Config.ObfuscateWith << 4);
|
|
obfuscateMaterial = Material.getMaterial(Config.ObfuscateWith);
|
|
|
|
int threadMultiplier = 1;
|
|
if(Config.event())
|
|
threadMultiplier = 4;
|
|
|
|
ProtocolLibrary.getProtocolManager().getAsynchronousManager().registerAsyncHandler(new PacketAdapter(FightSystem.getPlugin(), PacketType.Play.Server.MAP_CHUNK) {
|
|
@Override
|
|
public void onPacketSending(PacketEvent e) {
|
|
PacketContainer packet = e.getPacket();
|
|
StructureModifier<Integer> ints = packet.getIntegers();
|
|
|
|
int chunkX = ints.read(0);
|
|
int chunkZ = ints.read(1);
|
|
Player p = e.getPlayer();
|
|
if(bypass(p, chunkX, chunkZ))
|
|
return;
|
|
|
|
packet = packet.deepClone();
|
|
e.setPacket(packet);
|
|
StructureModifier<byte[]> byteArray = packet.getByteArrays();
|
|
StructureModifier<List> list = packet.getSpecificModifier(List.class);
|
|
List nmsTags = list.read(0);
|
|
boolean changed = false;
|
|
for(int i = nmsTags.size() - 1; i >= 0; i--){
|
|
NbtCompound nbt = NbtFactory.fromNMSCompound(nmsTags.get(i));
|
|
if(Config.HiddenBlockEntities.contains(nbt.getString("id"))){
|
|
nmsTags.remove(i);
|
|
changed = true;
|
|
}
|
|
}
|
|
if(changed){
|
|
list.write(0, nmsTags);
|
|
}
|
|
|
|
changed = false;
|
|
byte [] data = byteArray.read(0);
|
|
List<Byte> newData = new ArrayList<>(Bytes.asList(data));
|
|
int i = 0;
|
|
|
|
while(i < newData.size()){
|
|
byte bitsPerBlock = newData.get(i++);
|
|
if(bitsPerBlock < 4)
|
|
bitsPerBlock = 4;
|
|
else if(bitsPerBlock > 8){
|
|
bitsPerBlock = 13;
|
|
i++;
|
|
}
|
|
|
|
if(bitsPerBlock != 13){
|
|
int paletteLength = readVarInt(Bytes.toArray(newData), i);
|
|
i += readVarIntLength(Bytes.toArray(newData), i);
|
|
for(int actPaletteId = 0; actPaletteId < paletteLength; actPaletteId++){
|
|
int actPalette = readVarInt(Bytes.toArray(newData), i);
|
|
int actPaletteLength = readVarIntLength(Bytes.toArray(newData), i);
|
|
|
|
int blockId = actPalette >> 4;
|
|
if(Config.HiddenBlocks.contains(blockId)){
|
|
byte[] a = writeVarInt(obfuscateShift4);
|
|
for(int j = 0; j < actPaletteLength; j++){
|
|
newData.remove(i);
|
|
}
|
|
for(byte b : a){
|
|
newData.add(i++, b);
|
|
}
|
|
changed = true;
|
|
}else{
|
|
i += actPaletteLength;
|
|
}
|
|
}
|
|
int dataArrayLength = readVarInt(Bytes.toArray(newData), i);
|
|
i += readVarIntLength(Bytes.toArray(newData), i);
|
|
i += dataArrayLength * 8;
|
|
}else{
|
|
int dataArrayLength = readVarInt(Bytes.toArray(newData), i);
|
|
i += readVarIntLength(Bytes.toArray(newData), i);
|
|
/*int arrayEnd = dataArrayLength * 8 + i;
|
|
int bitsOver = 8; //9 bits (id) + 4 bits (metadata)
|
|
while(i < arrayEnd){
|
|
int blockId = (newData.get(i++) & (BITMASK >> 9 - bitsOver)) << 9-bitsOver;
|
|
blockId += newData.get(i) >> bitsOver-1;
|
|
if(Config.HiddenBlocks.contains(blockId)){
|
|
final short debug = 44;
|
|
newData.set(i-1, (byte)(newData.get(i-1) & -(BITMASK >> 9-bitsOver) | debug >> 9-bitsOver));
|
|
newData.set(i, (byte)(newData.get(i) & -(BITMASK << bitsOver-1) | debug << bitsOver-1));
|
|
System.out.println(blockId + " replaced at " + chunkX + " " + chunkZ + " i:" + i + " " + String.format("%8s", Integer.toBinaryString(newData.get(i-1) & 0xFF)).replace(' ', '0') + String.format("%8s", Integer.toBinaryString(newData.get(i) & 0xFF)).replace(' ', '0') + " " + bitsOver);
|
|
changed = true;
|
|
}
|
|
bitsOver -= 5; // 13-8
|
|
if(bitsOver < 1){
|
|
i++;
|
|
bitsOver += 8;
|
|
}
|
|
}*/
|
|
i += dataArrayLength * 8;
|
|
}
|
|
|
|
i += 4096; //Skylight (Not in Nether/End!!!) 2048 + Blocklight 2048
|
|
}
|
|
|
|
if(changed){
|
|
byteArray.write(0, Bytes.toArray(newData));
|
|
}
|
|
}
|
|
}).start(4 * threadMultiplier);
|
|
ProtocolLibrary.getProtocolManager().getAsynchronousManager().registerAsyncHandler(new PacketAdapter(FightSystem.getPlugin(), PacketType.Play.Server.BLOCK_CHANGE) {
|
|
@Override
|
|
public void onPacketSending(PacketEvent e) {
|
|
PacketContainer packet = e.getPacket();
|
|
BlockPosition pos = packet.getBlockPositionModifier().read(0);
|
|
|
|
Player p = e.getPlayer();
|
|
if(bypass(p, posToChunk(pos.getX()), posToChunk(pos.getZ())))
|
|
return;
|
|
|
|
packet = packet.deepClone();
|
|
e.setPacket(packet);
|
|
StructureModifier<WrappedBlockData> blockStructure = packet.getBlockData();
|
|
WrappedBlockData block = blockStructure.read(0);
|
|
if(Config.HiddenBlocks.contains(block.getType().getId())){
|
|
block.setType(obfuscateMaterial);
|
|
blockStructure.write(0, block);
|
|
}
|
|
}
|
|
}).start(threadMultiplier);
|
|
ProtocolLibrary.getProtocolManager().getAsynchronousManager().registerAsyncHandler(new PacketAdapter(FightSystem.getPlugin(), PacketType.Play.Server.MULTI_BLOCK_CHANGE) {
|
|
@Override
|
|
public void onPacketSending(PacketEvent e) {
|
|
PacketContainer packet = e.getPacket();
|
|
|
|
Player p = e.getPlayer();
|
|
ChunkCoordIntPair pos = packet.getChunkCoordIntPairs().read(0);
|
|
if(bypass(p, pos.getChunkX(), pos.getChunkZ()))
|
|
return;
|
|
|
|
packet = packet.shallowClone();
|
|
e.setPacket(packet);
|
|
StructureModifier<MultiBlockChangeInfo[]> blockStructure = packet.getMultiBlockChangeInfoArrays();
|
|
MultiBlockChangeInfo[] changes = blockStructure.read(0).clone();
|
|
boolean changed = false;
|
|
for(MultiBlockChangeInfo mbci : changes){
|
|
WrappedBlockData block = mbci.getData();
|
|
if(Config.HiddenBlocks.contains(block.getType().getId())){
|
|
changed = true;
|
|
block.setType(obfuscateMaterial);
|
|
mbci.setData(block);
|
|
}
|
|
}
|
|
|
|
if(changed){
|
|
blockStructure.write(0, changes);
|
|
}
|
|
}
|
|
}).start(threadMultiplier);
|
|
ProtocolLibrary.getProtocolManager().getAsynchronousManager().registerAsyncHandler(new PacketAdapter(FightSystem.getPlugin(), PacketType.Play.Server.BLOCK_ACTION) {
|
|
@Override
|
|
public void onPacketSending(PacketEvent e) {
|
|
PacketContainer packet = e.getPacket();
|
|
BlockPosition pos = packet.getBlockPositionModifier().read(0);
|
|
|
|
Player p = e.getPlayer();
|
|
if(bypass(p, posToChunk(pos.getX()), posToChunk(pos.getZ())))
|
|
return;
|
|
|
|
e.setCancelled(true);
|
|
}
|
|
}).start();
|
|
ProtocolLibrary.getProtocolManager().getAsynchronousManager().registerAsyncHandler(new PacketAdapter(FightSystem.getPlugin(), PacketType.Play.Client.USE_ITEM) {
|
|
@Override
|
|
public void onPacketReceiving(PacketEvent e) {
|
|
Player p = e.getPlayer();
|
|
|
|
if(p.getGameMode() == GameMode.SPECTATOR){
|
|
e.setCancelled(true);
|
|
}
|
|
}
|
|
}).start(threadMultiplier);
|
|
ProtocolLibrary.getProtocolManager().getAsynchronousManager().registerAsyncHandler(new PacketAdapter(FightSystem.getPlugin(), PacketType.Play.Client.USE_ENTITY) {
|
|
@Override
|
|
public void onPacketReceiving(PacketEvent e) {
|
|
Player p = e.getPlayer();
|
|
|
|
if(p.getGameMode() == GameMode.SPECTATOR){
|
|
e.setCancelled(true);
|
|
}
|
|
}
|
|
}).start(threadMultiplier);
|
|
}
|
|
|
|
private static boolean bypass(Player p, int chunkX, int chunkZ){
|
|
if(p == FightSystem.getEventLeiter())
|
|
return true;
|
|
|
|
FightTeam ft = Fight.getPlayerTeam(p);
|
|
if(ft == null){
|
|
//Außerhalb der Arena
|
|
return arenaMinX > chunkX ||
|
|
chunkX > arenaMaxX ||
|
|
arenaMinZ > chunkZ ||
|
|
chunkZ > arenaMaxZ;
|
|
}else if(ft.isBlue()){
|
|
return FightSystem.isEntern() ||
|
|
redMinX > chunkX ||
|
|
chunkX > redMaxX ||
|
|
redMinZ > chunkZ ||
|
|
chunkZ > redMaxZ;
|
|
}else{
|
|
return FightSystem.isEntern() ||
|
|
blueMinX > chunkX ||
|
|
chunkX > blueMaxX ||
|
|
blueMinZ > chunkZ ||
|
|
chunkZ > blueMaxZ;
|
|
}
|
|
}
|
|
|
|
public static List<Pair<Integer, Integer>> prepareChunkReload(Player p){
|
|
List<Pair<Integer, Integer>> chunksToReload = new ArrayList<>();
|
|
for(int x = arenaMinX; x <= arenaMaxX; x++)
|
|
for(int z = arenaMinZ; z <= arenaMaxZ; z++)
|
|
if(!bypass(p, x, z))
|
|
chunksToReload.add(new Pair<>(x, z));
|
|
return chunksToReload;
|
|
}
|
|
|
|
public static void reloadChunks(Player p, List<Pair<Integer, Integer>> chunksToReload){
|
|
Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> {
|
|
for(Pair<Integer, Integer> chunk : chunksToReload){
|
|
if(bypass(p, chunk.getKey(), chunk.getValue()))
|
|
((CraftPlayer)p).getHandle().playerConnection.sendPacket(new PacketPlayOutMapChunk(((CraftChunk)p.getWorld().getChunkAt(chunk.getKey(), chunk.getValue())).getHandle(), 65535));
|
|
}
|
|
}, 40);
|
|
}
|
|
|
|
private static int posToChunk(int c){
|
|
int chunk = c / 16;
|
|
if(c<0)
|
|
chunk--;
|
|
return chunk;
|
|
}
|
|
|
|
private static int readVarInt(byte[] array, int startPos) {
|
|
int numRead = 0;
|
|
int result = 0;
|
|
byte read;
|
|
do {
|
|
read = array[startPos + numRead];
|
|
int value = (read & 0b01111111);
|
|
result |= (value << (7 * numRead));
|
|
|
|
numRead++;
|
|
if (numRead > 5) {
|
|
break;
|
|
}
|
|
} while ((read & 0b10000000) != 0);
|
|
|
|
return result;
|
|
}
|
|
|
|
private static int readVarIntLength(byte[] array, int startPos) {
|
|
int numRead = 0;
|
|
byte read;
|
|
do {
|
|
read = array[startPos + numRead];
|
|
numRead++;
|
|
if (numRead > 5) {
|
|
break;
|
|
}
|
|
} while ((read & 0b10000000) != 0);
|
|
|
|
return numRead;
|
|
}
|
|
|
|
private static byte[] writeVarInt(int value) {
|
|
ArrayList<Byte> buffer = new ArrayList<>();
|
|
do {
|
|
byte temp = (byte)(value & 0b01111111);
|
|
// Note: >>> means that the sign bit is shifted with the rest of the number rather than being left alone
|
|
value >>>= 7;
|
|
if (value != 0) {
|
|
temp |= 0b10000000;
|
|
}
|
|
buffer.add(temp);
|
|
} while (value != 0);
|
|
return Bytes.toArray(buffer);
|
|
}
|
|
}
|