├── .gitignore ├── src └── main │ ├── resources │ ├── resources │ │ ├── icon.png │ │ ├── config.json │ │ ├── effect.json │ │ ├── enchant.json │ │ └── entity.json │ └── log4j2.xml │ └── java │ └── me │ └── liuli │ └── ez4h │ ├── managers │ ├── command │ │ ├── CommandBase.java │ │ └── commands │ │ │ ├── VersionCommand.java │ │ │ ├── GcCommand.java │ │ │ ├── HelpCommand.java │ │ │ ├── SayCommand.java │ │ │ └── StatusCommand.java │ ├── DebugManager.java │ ├── CommandManager.java │ ├── ConverterManager.java │ ├── AuthManager.java │ ├── LocaleManager.java │ ├── ConfigManager.java │ └── TranslatorManager.java │ ├── utils │ ├── nukkit │ │ ├── BitArray.java │ │ ├── BitArrayVersion.java │ │ ├── PaddedBitArray.java │ │ └── Pow2BitArray.java │ ├── RandUtil.java │ ├── AuthUtil.java │ ├── BedrockUtil.java │ ├── OtherUtil.java │ └── FileUtil.java │ ├── translators │ ├── BedrockTranslator.java │ ├── JavaTranslator.java │ ├── bedrock │ │ ├── connect │ │ │ ├── DisconnectPacketTranslator.java │ │ │ ├── ResourcePackStackPacketTranslator.java │ │ │ ├── ResourcePacksInfoPacketTranslator.java │ │ │ └── ServerToClientHandshakePacketTranslator.java │ │ ├── play │ │ │ ├── SetTimePacketTranslator.java │ │ │ ├── ModalFormRequestPacketTranslator.java │ │ │ ├── RemoveObjectivePacketTranslator.java │ │ │ ├── UpdatePlayerGameTypePacketTranslator.java │ │ │ ├── SetPlayerGameTypePacketTranslator.java │ │ │ ├── SetTitlePacketTranslator.java │ │ │ ├── AdventureSettingsPacketTranslator.java │ │ │ ├── SetScorePacketTranslator.java │ │ │ ├── TextPacketTranslator.java │ │ │ ├── SetDisplayObjectivePacketTranslator.java │ │ │ ├── PlayerListPacketTranslator.java │ │ │ ├── RespawnPacketTranslator.java │ │ │ ├── UpdateAttributesPacketTranslator.java │ │ │ └── StartGamePacketTranslator.java │ │ ├── entity │ │ │ ├── SetEntityDataPacketTranslator.java │ │ │ ├── RemoveEntityPacketTranslator.java │ │ │ ├── SetEntityMotionPacketTranslator.java │ │ │ ├── EntityEventPacketTranslator.java │ │ │ ├── TakeItemEntityPacketTranslator.java │ │ │ ├── MoveEntityAbsolutePacketTranslator.java │ │ │ ├── MobEquipmentPacketTranslator.java │ │ │ ├── AnimatePacketTranslator.java │ │ │ ├── MobArmorEquipmentPacketTranslator.java │ │ │ ├── MovePlayerPacketTranslator.java │ │ │ ├── AddItemEntityPacketTranslator.java │ │ │ ├── AddPlayerPacketTranslator.java │ │ │ └── MobEffectPacketTranslator.java │ │ ├── window │ │ │ ├── ContainerClosePacketTranslator.java │ │ │ ├── ContainerOpenPacketTranslator.java │ │ │ ├── InventorySlotPacketTranslator.java │ │ │ └── InventoryContentPacketTranslator.java │ │ └── world │ │ │ ├── UpdateBlockPacketTranslator.java │ │ │ ├── BlockEventPacketTranslator.java │ │ │ ├── LevelEventPacketTranslator.java │ │ │ ├── BossEventPacketTranslator.java │ │ │ └── BlockEntityDataPacketTranslator.java │ ├── java │ │ ├── play │ │ │ ├── ClientPlayerSwingArmPacketTranslator.java │ │ │ ├── ClientSettingsPacketTranslator.java │ │ │ ├── ClientPlayerChangeHeldItemPacketTranslator.java │ │ │ ├── ClientRequestPacketTranslator.java │ │ │ ├── ClientPlayerRotationPacketTranslator.java │ │ │ ├── ClientPlayerPositionPacketTranslator.java │ │ │ ├── ClientPlayerPlaceBlockPacketTranslator.java │ │ │ ├── ClientPlayerInteractEntityPacketTranslator.java │ │ │ ├── ClientChatPacketTranslator.java │ │ │ ├── ClientPlayerPositionRotationPacketTranslator.java │ │ │ ├── ClientPlayerStatePacketTranslator.java │ │ │ └── ClientPlayerUseItemPacketTranslator.java │ │ └── window │ │ │ ├── ClientCloseWindowPacketTranslator.java │ │ │ ├── ClientCreativeInventoryActionPacketTranslator.java │ │ │ └── ClientWindowActionPacketTranslator.java │ └── converters │ │ ├── BlockConverter.java │ │ └── MetadataConverter.java │ └── minecraft │ ├── data │ ├── world │ │ ├── ChestData.java │ │ ├── Location.java │ │ └── Weather.java │ ├── play │ │ ├── Form.java │ │ ├── ClientData.java │ │ └── MCLocale.java │ └── entity │ │ ├── Entity.java │ │ ├── PlayerData.java │ │ └── Inventory.java │ ├── BedrockBatchHandler.java │ ├── JavaPacketHandler.java │ ├── auth │ ├── JoseStuff.java │ ├── XboxLogin.java │ └── fakeAuthServer │ │ └── FakeServer.java │ ├── Ping.java │ └── JavaServer.java ├── LICENSE └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | target 3 | test 4 | dependency-reduced-pom.xml -------------------------------------------------------------------------------- /src/main/resources/resources/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/opZywl/EZ4H/HEAD/src/main/resources/resources/icon.png -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/command/CommandBase.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers.command; 2 | 3 | import me.liuli.ez4h.minecraft.Client; 4 | 5 | public interface CommandBase { 6 | String getCommandName(); 7 | 8 | String getHelpMessage(); 9 | 10 | void exec(String[] args, Client client); 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/nukkit/BitArray.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils.nukkit; 2 | 3 | public interface BitArray { 4 | 5 | void set(int index, int value); 6 | 7 | int get(int index); 8 | 9 | int size(); 10 | 11 | int[] getWords(); 12 | 13 | BitArrayVersion getVersion(); 14 | 15 | BitArray copy(); 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/BedrockTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import me.liuli.ez4h.minecraft.Client; 5 | 6 | public interface BedrockTranslator { 7 | 8 | default boolean needOrder() { 9 | return false; 10 | } 11 | 12 | void translate(BedrockPacket inPacket, Client client); 13 | 14 | Class getPacketClass(); 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/world/ChestData.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.world; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.window.WindowType; 4 | 5 | public class ChestData { 6 | public String name; 7 | public WindowType type; 8 | public int id; 9 | 10 | public ChestData(int id, String name, WindowType type) { 11 | this.name = name; 12 | this.id = id; 13 | this.type = type; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/play/Form.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.play; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | 5 | public class Form { 6 | public Type type; 7 | public int array; 8 | public JSONObject data; 9 | 10 | public Form(Type type, int array, JSONObject data) { 11 | this.type = type; 12 | this.array = array; 13 | this.data = data; 14 | } 15 | 16 | public enum Type { 17 | SIMPLE, MODAL, CUSTOM 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/JavaTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.packetlib.packet.Packet; 5 | import me.liuli.ez4h.minecraft.Client; 6 | 7 | public interface JavaTranslator { 8 | 9 | default boolean needOrder() { 10 | return false; 11 | } 12 | 13 | void translate(Packet inPacket, Client client); 14 | 15 | Class getPacketClass(); 16 | } 17 | -------------------------------------------------------------------------------- /src/main/resources/resources/config.json: -------------------------------------------------------------------------------- 1 | { 2 | "je-host": "127.0.0.1", 3 | "je-port": 25565, 4 | "be-host": "127.0.0.1", 5 | "be-port": 19132, 6 | "player-list": "A §bEZ§94§bH§f§r Proxyed Server!\nhttps://github.com/Project-EZ4H/EZ4H", 7 | "auth": { 8 | "auto-login": false, 9 | "xbox-auth": true 10 | }, 11 | "debug": { 12 | "all-packet": false, 13 | "unknown-packet": false, 14 | "out-packet": false, 15 | "other": false 16 | }, 17 | "advanced": { 18 | "update-locale": true 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/connect/DisconnectPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.connect; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.packet.DisconnectPacket; 5 | import me.liuli.ez4h.minecraft.Client; 6 | import me.liuli.ez4h.translators.BedrockTranslator; 7 | 8 | public class DisconnectPacketTranslator implements BedrockTranslator { 9 | @Override 10 | public void translate(BedrockPacket inPacket, Client client) { 11 | DisconnectPacket packet = (DisconnectPacket) inPacket; 12 | client.disconnectJava(packet.getKickMessage()); 13 | } 14 | 15 | @Override 16 | public Class getPacketClass() { 17 | return DisconnectPacket.class; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/BedrockBatchHandler.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.BedrockSession; 5 | import com.nukkitx.protocol.bedrock.handler.BatchHandler; 6 | import io.netty.buffer.ByteBuf; 7 | 8 | import java.util.Collection; 9 | 10 | public class BedrockBatchHandler implements BatchHandler { 11 | private final Client client; 12 | 13 | public BedrockBatchHandler(Client client) { 14 | this.client = client; 15 | } 16 | 17 | @Override 18 | public void handle(BedrockSession bedrockSession, ByteBuf byteBuf, Collection collection) { 19 | for (BedrockPacket packet : collection) { 20 | client.addPacket(packet); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/command/commands/VersionCommand.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers.command.commands; 2 | 3 | import me.liuli.ez4h.EZ4H; 4 | import me.liuli.ez4h.managers.command.CommandBase; 5 | import me.liuli.ez4h.minecraft.Client; 6 | 7 | public class VersionCommand implements CommandBase { 8 | @Override 9 | public String getCommandName() { 10 | return "version"; 11 | } 12 | 13 | @Override 14 | public String getHelpMessage() { 15 | return "Show Version of EZ4H"; 16 | } 17 | 18 | @Override 19 | public void exec(String[] args, Client client) { 20 | client.sendAlert("CURRENT RUNNING EZ4H v" + EZ4H.getVersion() + " for Minecraft:BE v" + EZ4H.getBedrockCodec().getMinecraftVersion() + " (Protocol" + EZ4H.getBedrockCodec().getProtocolVersion() + ")."); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/command/commands/GcCommand.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers.command.commands; 2 | 3 | import me.liuli.ez4h.managers.command.CommandBase; 4 | import me.liuli.ez4h.minecraft.Client; 5 | 6 | public class GcCommand implements CommandBase { 7 | @Override 8 | public String getCommandName() { 9 | return "gc"; 10 | } 11 | 12 | @Override 13 | public String getHelpMessage() { 14 | return "Garbage Collection"; 15 | } 16 | 17 | @Override 18 | public void exec(String[] args, Client client) { 19 | long memory = Runtime.getRuntime().freeMemory(); 20 | System.gc(); 21 | long freedMemory = Runtime.getRuntime().freeMemory() - memory; 22 | client.sendAlert("§eMemory freed: §c" + Math.round(freedMemory / 1024d / 1024d) + " MB"); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/RandUtil.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils; 2 | 3 | import java.util.SplittableRandom; 4 | 5 | public class RandUtil { 6 | 7 | public static final SplittableRandom random = new SplittableRandom(); 8 | 9 | public static int rand(int min, int max) { 10 | if (min == max) { 11 | return max; 12 | } 13 | return random.nextInt(max + 1 - min) + min; 14 | } 15 | 16 | public static double rand(double min, double max) { 17 | if (min == max) { 18 | return max; 19 | } 20 | return min + Math.random() * (max - min); 21 | } 22 | 23 | public static float rand(float min, float max) { 24 | if (min == max) { 25 | return max; 26 | } 27 | return min + (float) Math.random() * (max - min); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/DebugManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import lombok.Getter; 5 | 6 | public class DebugManager { 7 | @Getter 8 | private final boolean allPackets; 9 | @Getter 10 | private final boolean unknownPackets; 11 | @Getter 12 | private final boolean outPackets; 13 | @Getter 14 | private final boolean other; 15 | 16 | public DebugManager(JSONObject data) { 17 | this.allPackets = data.getBoolean("all-packet"); 18 | this.unknownPackets = data.getBoolean("unknown-packet"); 19 | this.outPackets = data.getBoolean("out-packet"); 20 | this.other = data.getBoolean("other"); 21 | } 22 | 23 | public boolean enableDebug() { 24 | return allPackets || unknownPackets || outPackets || other; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/SetTimePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerUpdateTimePacket; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.SetTimePacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class SetTimePacketTranslator implements BedrockTranslator { 10 | @Override 11 | public void translate(BedrockPacket inPacket, Client client) { 12 | SetTimePacket packet = (SetTimePacket) inPacket; 13 | client.sendPacket(new ServerUpdateTimePacket(0, packet.getTime())); 14 | } 15 | 16 | @Override 17 | public Class getPacketClass() { 18 | return SetTimePacket.class; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/SetEntityDataPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.packet.SetEntityDataPacket; 5 | import me.liuli.ez4h.EZ4H; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class SetEntityDataPacketTranslator implements BedrockTranslator { 10 | @Override 11 | public void translate(BedrockPacket inPacket, Client client) { 12 | SetEntityDataPacket packet = (SetEntityDataPacket) inPacket; 13 | EZ4H.getConverterManager().getMetadataConverter().convert(packet.getMetadata(), client, (int) packet.getRuntimeEntityId()); 14 | } 15 | 16 | @Override 17 | public Class getPacketClass() { 18 | return SetEntityDataPacket.class; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/ModalFormRequestPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.packet.ModalFormRequestPacket; 5 | import me.liuli.ez4h.EZ4H; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class ModalFormRequestPacketTranslator implements BedrockTranslator { 10 | @Override 11 | public void translate(BedrockPacket inPacket, Client client) { 12 | ModalFormRequestPacket packet = (ModalFormRequestPacket) inPacket; 13 | EZ4H.getConverterManager().getFormConverter().showForm(client, packet.getFormData(), packet.getFormId()); 14 | } 15 | 16 | @Override 17 | public Class getPacketClass() { 18 | return ModalFormRequestPacket.class; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/main/resources/log4j2.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/RemoveObjectivePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.scoreboard.ServerScoreboardObjectivePacket; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.RemoveObjectivePacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class RemoveObjectivePacketTranslator implements BedrockTranslator { 10 | @Override 11 | public void translate(BedrockPacket inPacket, Client client) { 12 | RemoveObjectivePacket packet = (RemoveObjectivePacket) inPacket; 13 | client.sendPacket(new ServerScoreboardObjectivePacket(packet.getObjectiveId())); 14 | } 15 | 16 | @Override 17 | public Class getPacketClass() { 18 | return RemoveObjectivePacket.class; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/main/resources/resources/effect.json: -------------------------------------------------------------------------------- 1 | {"bedrock": {"1":"speed","2":"slowness","3":"haste","4":"mining_fatigue","5":"strength","6":"instant_health","7":"instant_damage","8":"jump_boost","9":"nausea","10":"regeneration","11":"resistance","12":"fire_resistance","13":"water_breathing","14":"invisibility","15":"blindness","16":"night_vision","17":"hunger","18":"weakness","19":"poison","20":"wither","21":"health_boost","22":"absorption","23":"saturation","24":"levitation","25":"fatal_poison","26":"conduit_power","27":"slow_falling","28":"bad_omen","29":"village_hero"},"java": {"speed":"1","slowness":"2","haste":"3","mining_fatigue":"4","strength":"5","instant_health":"6","instant_damage":"7","jump_boost":"8","nausea":"9","regeneration":"10","resistance":"11","fire_resistance":"12","water_breathing":"13","invisibility":"14","blindness":"15","night_vision":"16","hunger":"17","weakness":"18","poison":"19","wither":"20","health_boost":"21","absorption":"22","saturation":"23","glowing":"24","levitation":"25","luck":"26","unluck":"27"}} -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/window/ContainerClosePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.window; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.window.ServerCloseWindowPacket; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.ContainerClosePacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class ContainerClosePacketTranslator implements BedrockTranslator { 10 | @Override 11 | public boolean needOrder() { 12 | return true; 13 | } 14 | 15 | @Override 16 | public void translate(BedrockPacket inPacket, Client client) { 17 | ContainerClosePacket packet = (ContainerClosePacket) inPacket; 18 | 19 | client.sendPacket(new ServerCloseWindowPacket(packet.getId())); 20 | } 21 | 22 | @Override 23 | public Class getPacketClass() { 24 | return ContainerClosePacket.class; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/command/commands/HelpCommand.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers.command.commands; 2 | 3 | import me.liuli.ez4h.EZ4H; 4 | import me.liuli.ez4h.managers.command.CommandBase; 5 | import me.liuli.ez4h.minecraft.Client; 6 | 7 | import java.util.Map; 8 | import java.util.Set; 9 | 10 | public class HelpCommand implements CommandBase { 11 | @Override 12 | public String getCommandName() { 13 | return "help"; 14 | } 15 | 16 | @Override 17 | public String getHelpMessage() { 18 | return "Show a list of commands"; 19 | } 20 | 21 | @Override 22 | public void exec(String[] args, Client client) { 23 | Set> entrySet = EZ4H.getCommandManager().getCommandMap().entrySet(); 24 | client.sendAlert("EZ4H COMMANDS(" + entrySet.size() + " TOTAL)"); 25 | for (Map.Entry entry : entrySet) { 26 | client.sendMessage("`" + entry.getKey() + " - " + entry.getValue().getHelpMessage()); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/RemoveEntityPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityDestroyPacket; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.RemoveEntityPacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class RemoveEntityPacketTranslator implements BedrockTranslator { 10 | @Override 11 | public void translate(BedrockPacket inPacket, Client client) { 12 | RemoveEntityPacket packet = (RemoveEntityPacket) inPacket; 13 | int[] entityIds = new int[1]; 14 | entityIds[0] = (int) packet.getUniqueEntityId(); 15 | client.getData().removeEntity((int) packet.getUniqueEntityId()); 16 | client.sendPacket(new ServerEntityDestroyPacket(entityIds)); 17 | } 18 | 19 | @Override 20 | public Class getPacketClass() { 21 | return RemoveEntityPacket.class; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/SetEntityMotionPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityVelocityPacket; 4 | import com.nukkitx.math.vector.Vector3f; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.SetEntityMotionPacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | 10 | public class SetEntityMotionPacketTranslator implements BedrockTranslator { 11 | @Override 12 | public void translate(BedrockPacket inPacket, Client client) { 13 | SetEntityMotionPacket packet = (SetEntityMotionPacket) inPacket; 14 | Vector3f motion = packet.getMotion(); 15 | client.sendPacket(new ServerEntityVelocityPacket((int) packet.getRuntimeEntityId(), motion.getX(), motion.getY(), motion.getZ())); 16 | } 17 | 18 | @Override 19 | public Class getPacketClass() { 20 | return SetEntityMotionPacket.class; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Project-EZ4H 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/main/resources/resources/enchant.json: -------------------------------------------------------------------------------- 1 | {"bedrock":{"0":"protection","1":"fire_protection","2":"feather_falling","3":"blast_protection","4":"projectile_protection","5":"thorns","6":"respiration","7":"depth_strider","8":"aqua_affinity","9":"sharpness","10":"smite","11":"bane_of_arthropods","12":"knockback","13":"fire_aspect","14":"looting","15":"efficiency","16":"silk_touch","17":"unbreaking","18":"fortune","19":"power","20":"punch","21":"flame","22":"infinity","23":"luck_of_the_sea","24":"lure","25":"frost_walker","26":"mending","27":"binding_curse","28":"vanishing_curse","29":"impaling","30":"riptide","31":"loyalty","32":"channeling","33":"multishot","34":"piercing","35":"quick_charge"},"java":{"protection":0,"fire_protection":1,"feather_falling":2,"blast_protection":3,"projectile_protection":4,"respiration":5,"aqua_affinity":6,"thorns":7,"depth_strider":8,"frost_walker":9,"binding_curse":10,"sharpness":16,"smite":17,"bane_of_arthropods":18,"knockback":19,"fire_aspect":20,"looting":21,"sweeping":22,"efficiency":32,"silk_touch":33,"unbreaking":34,"fortune":35,"power":48,"punch":49,"flame":50,"infinity":51,"luck_of_the_sea":61,"lure":62,"mending":70,"vanishing_curse":71}} -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/CommandManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import lombok.Getter; 4 | import me.liuli.ez4h.managers.command.CommandBase; 5 | import me.liuli.ez4h.minecraft.Client; 6 | 7 | import java.util.HashMap; 8 | import java.util.Map; 9 | 10 | public class CommandManager { 11 | @Getter 12 | private final Map commandMap = new HashMap<>(); 13 | 14 | public void runCommand(String commandName, String[] args, Client client) { 15 | CommandBase commandBase = commandMap.get(commandName.toLowerCase()); 16 | if (commandBase != null) { 17 | try { 18 | commandBase.exec(args, client); 19 | } catch (Throwable throwable) { 20 | client.sendAlert("An error occurred while running this command."); 21 | throwable.printStackTrace(); 22 | } 23 | } else { 24 | client.sendAlert("Command Not Found!Type `help for help"); 25 | } 26 | } 27 | 28 | public void registerCommand(CommandBase command) { 29 | commandMap.put(command.getCommandName().toLowerCase(), command); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/EntityEventPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.player.Animation; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityAnimationPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.EntityEventPacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | 10 | public class EntityEventPacketTranslator implements BedrockTranslator { 11 | @Override 12 | public void translate(BedrockPacket inPacket, Client client) { 13 | EntityEventPacket packet = (EntityEventPacket) inPacket; 14 | switch (packet.getType()) { 15 | case HURT: { 16 | client.sendPacket(new ServerEntityAnimationPacket((int) packet.getRuntimeEntityId(), Animation.DAMAGE)); 17 | break; 18 | } 19 | } 20 | } 21 | 22 | @Override 23 | public Class getPacketClass() { 24 | return EntityEventPacket.class; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerSwingArmPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerSwingArmPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.protocol.bedrock.packet.AnimatePacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.JavaTranslator; 9 | 10 | public class ClientPlayerSwingArmPacketTranslator implements JavaTranslator { 11 | @Override 12 | public void translate(Packet inPacket, Client client) { 13 | ClientPlayerSwingArmPacket packet = (ClientPlayerSwingArmPacket) inPacket; 14 | AnimatePacket animatePacket = new AnimatePacket(); 15 | animatePacket.setAction(AnimatePacket.Action.SWING_ARM); 16 | animatePacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 17 | client.sendPacket(animatePacket); 18 | } 19 | 20 | @Override 21 | public Class getPacketClass() { 22 | return ClientPlayerSwingArmPacket.class; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientSettingsPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.ClientSettingsPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.protocol.bedrock.packet.RequestChunkRadiusPacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.JavaTranslator; 9 | 10 | public class ClientSettingsPacketTranslator implements JavaTranslator { 11 | @Override 12 | public void translate(Packet inPacket, Client client) { 13 | ClientSettingsPacket packet = (ClientSettingsPacket) inPacket; 14 | RequestChunkRadiusPacket requestChunkRadiusPacket = new RequestChunkRadiusPacket(); 15 | requestChunkRadiusPacket.setRadius(packet.getRenderDistance()); 16 | client.sendPacket(requestChunkRadiusPacket); 17 | client.updateLocale(packet.getLocale().toLowerCase()); 18 | } 19 | 20 | @Override 21 | public Class getPacketClass() { 22 | return ClientSettingsPacket.class; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/connect/ResourcePackStackPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.connect; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.packet.ResourcePackClientResponsePacket; 5 | import com.nukkitx.protocol.bedrock.packet.ResourcePackStackPacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class ResourcePackStackPacketTranslator implements BedrockTranslator { 10 | @Override 11 | public boolean needOrder() { 12 | return true; 13 | } 14 | 15 | @Override 16 | public void translate(BedrockPacket inPacket, Client client) { 17 | ResourcePackStackPacket packet = (ResourcePackStackPacket) inPacket; 18 | ResourcePackClientResponsePacket resourcePackClientResponsePacket = new ResourcePackClientResponsePacket(); 19 | resourcePackClientResponsePacket.setStatus(ResourcePackClientResponsePacket.Status.COMPLETED); 20 | client.sendPacket(resourcePackClientResponsePacket); 21 | } 22 | 23 | @Override 24 | public Class getPacketClass() { 25 | return ResourcePackStackPacket.class; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/connect/ResourcePacksInfoPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.connect; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.packet.ResourcePackClientResponsePacket; 5 | import com.nukkitx.protocol.bedrock.packet.ResourcePacksInfoPacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class ResourcePacksInfoPacketTranslator implements BedrockTranslator { 10 | @Override 11 | public boolean needOrder() { 12 | return true; 13 | } 14 | 15 | @Override 16 | public void translate(BedrockPacket inPacket, Client client) { 17 | ResourcePacksInfoPacket packet = (ResourcePacksInfoPacket) inPacket; 18 | ResourcePackClientResponsePacket resourcePackClientResponsePacket = new ResourcePackClientResponsePacket(); 19 | resourcePackClientResponsePacket.setStatus(ResourcePackClientResponsePacket.Status.HAVE_ALL_PACKS); 20 | client.sendPacket(resourcePackClientResponsePacket); 21 | } 22 | 23 | @Override 24 | public Class getPacketClass() { 25 | return ResourcePacksInfoPacket.class; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/UpdatePlayerGameTypePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.world.notify.ClientNotification; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerNotifyClientPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.UpdatePlayerGameTypePacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | import me.liuli.ez4h.utils.BedrockUtil; 10 | 11 | public class UpdatePlayerGameTypePacketTranslator implements BedrockTranslator { 12 | @Override 13 | public void translate(BedrockPacket inPacket, Client client) { 14 | UpdatePlayerGameTypePacket packet = (UpdatePlayerGameTypePacket) inPacket; 15 | if (packet.getEntityId() == client.getPlayer().getEntityId()) { 16 | client.sendPacket(new ServerNotifyClientPacket(ClientNotification.CHANGE_GAMEMODE, BedrockUtil.convertGameModeToJE(packet.getGameType()))); 17 | } 18 | } 19 | 20 | @Override 21 | public Class getPacketClass() { 22 | return UpdatePlayerGameTypePacket.class; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/window/ClientCloseWindowPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.window; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.window.ClientCloseWindowPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.protocol.bedrock.packet.ContainerClosePacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.JavaTranslator; 9 | 10 | public class ClientCloseWindowPacketTranslator implements JavaTranslator { 11 | @Override 12 | public void translate(Packet inPacket, Client client) { 13 | ClientCloseWindowPacket packet = (ClientCloseWindowPacket) inPacket; 14 | 15 | if ((!client.getInventory().isOpen()) && packet.getWindowId() == 0) 16 | return; 17 | 18 | ContainerClosePacket containerClosePacket = new ContainerClosePacket(); 19 | containerClosePacket.setUnknownBool0(false); 20 | containerClosePacket.setId((byte) packet.getWindowId()); 21 | client.sendPacket(containerClosePacket); 22 | } 23 | 24 | @Override 25 | public Class getPacketClass() { 26 | return ClientCloseWindowPacket.class; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/entity/Entity.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.entity; 2 | 3 | import com.nukkitx.protocol.bedrock.data.entity.EntityFlag; 4 | import lombok.Getter; 5 | import lombok.Setter; 6 | import me.liuli.ez4h.minecraft.data.world.Location; 7 | 8 | import java.util.HashMap; 9 | import java.util.Map; 10 | 11 | public class Entity extends Location { 12 | @Getter 13 | private final int id; 14 | @Getter 15 | private final Type type; 16 | @Getter 17 | private final Map metadata; 18 | @Getter 19 | @Setter 20 | private Pose pose; 21 | 22 | public Entity(float x, float y, float z, int id, Type type) { 23 | super(x, y, z); 24 | 25 | this.id = id; 26 | this.type = type; 27 | this.pose = Pose.NONE; 28 | metadata = new HashMap<>(); 29 | metadata.put(EntityFlag.CAN_SHOW_NAME, false); 30 | metadata.put(EntityFlag.HAS_GRAVITY, false); 31 | // this.scoretag=null; 32 | } 33 | 34 | public enum Pose { 35 | NONE((byte) 0), FIRE((byte) 1), SNEAK((byte) 2); 36 | 37 | public byte data; 38 | 39 | Pose(byte data) { 40 | this.data = data; 41 | } 42 | } 43 | // private String scoretag; 44 | 45 | public enum Type { 46 | ITEM_ENTITY, ENTITY, PLAYER 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/TakeItemEntityPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityCollectItemPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityDestroyPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.TakeItemEntityPacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | 10 | public class TakeItemEntityPacketTranslator implements BedrockTranslator { 11 | @Override 12 | public void translate(BedrockPacket inPacket, Client client) { 13 | TakeItemEntityPacket packet = (TakeItemEntityPacket) inPacket; 14 | int[] entityIds = new int[1]; 15 | entityIds[0] = (int) packet.getItemRuntimeEntityId(); 16 | client.getData().removeEntity((int) packet.getItemRuntimeEntityId()); 17 | client.sendPacket(new ServerEntityDestroyPacket(entityIds)); 18 | client.sendPacket(new ServerEntityCollectItemPacket((int) packet.getItemRuntimeEntityId(), (int) packet.getRuntimeEntityId(), 1)); 19 | } 20 | 21 | @Override 22 | public Class getPacketClass() { 23 | return TakeItemEntityPacket.class; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/window/ContainerOpenPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.window; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.window.WindowType; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.ContainerOpenPacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.minecraft.data.world.ChestData; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | 10 | public class ContainerOpenPacketTranslator implements BedrockTranslator { 11 | @Override 12 | public boolean needOrder() { 13 | return true; 14 | } 15 | 16 | @Override 17 | public void translate(BedrockPacket inPacket, Client client) { 18 | ContainerOpenPacket packet = (ContainerOpenPacket) inPacket; 19 | if (packet.getId() == 0) return; 20 | switch (packet.getType()) { 21 | case CONTAINER: { 22 | //bedrock dont send slots data in this packet.slot count send to client in InventoryContentPacket 23 | client.getData().setQueueChest(new ChestData(packet.getId(), "{}", WindowType.CHEST)); 24 | break; 25 | } 26 | } 27 | } 28 | 29 | @Override 30 | public Class getPacketClass() { 31 | return ContainerOpenPacket.class; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerChangeHeldItemPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerChangeHeldItemPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.protocol.bedrock.packet.PlayerHotbarPacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.JavaTranslator; 9 | 10 | public class ClientPlayerChangeHeldItemPacketTranslator implements JavaTranslator { 11 | @Override 12 | public void translate(Packet inPacket, Client client) { 13 | ClientPlayerChangeHeldItemPacket packet = (ClientPlayerChangeHeldItemPacket) inPacket; 14 | PlayerHotbarPacket playerHotbarPacket = new PlayerHotbarPacket(); 15 | playerHotbarPacket.setContainerId(0); 16 | playerHotbarPacket.setSelectedHotbarSlot(packet.getSlot()); 17 | playerHotbarPacket.setSelectHotbarSlot(true); 18 | client.sendPacket(playerHotbarPacket); 19 | client.getInventory().setHandSlot(packet.getSlot()); 20 | client.getPlayer().setUsingItem(false); 21 | } 22 | 23 | @Override 24 | public Class getPacketClass() { 25 | return ClientPlayerChangeHeldItemPacket.class; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/SetPlayerGameTypePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 4 | import com.github.steveice10.mc.protocol.data.game.world.notify.ClientNotification; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerNotifyClientPacket; 6 | import com.nukkitx.protocol.bedrock.BedrockPacket; 7 | import com.nukkitx.protocol.bedrock.data.GameType; 8 | import com.nukkitx.protocol.bedrock.packet.SetPlayerGameTypePacket; 9 | import me.liuli.ez4h.minecraft.Client; 10 | import me.liuli.ez4h.translators.BedrockTranslator; 11 | import me.liuli.ez4h.utils.BedrockUtil; 12 | 13 | public class SetPlayerGameTypePacketTranslator implements BedrockTranslator { 14 | @Override 15 | public void translate(BedrockPacket inPacket, Client client) { 16 | SetPlayerGameTypePacket packet = (SetPlayerGameTypePacket) inPacket; 17 | 18 | GameMode gameMode = BedrockUtil.convertGameModeToJE(GameType.from(packet.getGamemode())); 19 | client.getPlayer().setGameMode(gameMode); 20 | client.sendPacket(new ServerNotifyClientPacket(ClientNotification.CHANGE_GAMEMODE, gameMode)); 21 | } 22 | 23 | @Override 24 | public Class getPacketClass() { 25 | return SetPlayerGameTypePacket.class; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/SetTitlePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerTitlePacket; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.SetTitlePacket; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | 9 | public class SetTitlePacketTranslator implements BedrockTranslator { 10 | @Override 11 | public void translate(BedrockPacket inPacket, Client client) { 12 | SetTitlePacket packet = (SetTitlePacket) inPacket; 13 | switch (packet.getType()) { 14 | case TITLE: { 15 | client.sendPacket(new ServerTitlePacket(packet.getText(), false)); 16 | break; 17 | } 18 | case SUBTITLE: { 19 | client.sendPacket(new ServerTitlePacket(packet.getText(), true)); 20 | break; 21 | } 22 | case RESET: { 23 | client.sendPacket(new ServerTitlePacket("", true)); 24 | client.sendPacket(new ServerTitlePacket("", false)); 25 | break; 26 | } 27 | } 28 | } 29 | 30 | @Override 31 | public Class getPacketClass() { 32 | return SetTitlePacket.class; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/MoveEntityAbsolutePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityHeadLookPacket; 4 | import com.nukkitx.math.vector.Vector3f; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.MoveEntityAbsolutePacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.minecraft.data.entity.Entity; 9 | import me.liuli.ez4h.translators.BedrockTranslator; 10 | 11 | public class MoveEntityAbsolutePacketTranslator implements BedrockTranslator { 12 | @Override 13 | public void translate(BedrockPacket inPacket, Client client) { 14 | MoveEntityAbsolutePacket packet = (MoveEntityAbsolutePacket) inPacket; 15 | Vector3f position = packet.getPosition(), rotation = packet.getRotation(); 16 | Entity entity = client.getData().getEntity(packet.getRuntimeEntityId()); 17 | if (entity != null) { 18 | client.getData().moveEntity(entity, position, rotation, packet.isOnGround()); 19 | client.sendPacket(new ServerEntityHeadLookPacket((int) packet.getRuntimeEntityId(), rotation.getZ())); 20 | } 21 | } 22 | 23 | @Override 24 | public Class getPacketClass() { 25 | return MoveEntityAbsolutePacket.class; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientRequestPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.ClientRequestPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.protocol.bedrock.packet.RespawnPacket; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.JavaTranslator; 10 | 11 | public class ClientRequestPacketTranslator implements JavaTranslator { 12 | @Override 13 | public void translate(Packet inPacket, Client client) { 14 | ClientRequestPacket packet = (ClientRequestPacket) inPacket; 15 | switch (packet.getRequest()) { 16 | case RESPAWN: { 17 | RespawnPacket respawnPacket = new RespawnPacket(); 18 | respawnPacket.setPosition(Vector3f.from(0, 0, 0)); 19 | respawnPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 20 | respawnPacket.setState(RespawnPacket.State.CLIENT_READY); 21 | client.sendPacket(respawnPacket); 22 | break; 23 | } 24 | } 25 | } 26 | 27 | @Override 28 | public Class getPacketClass() { 29 | return ClientRequestPacket.class; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/ConverterManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import com.alibaba.fastjson.JSONArray; 4 | import com.alibaba.fastjson.JSONObject; 5 | import lombok.Getter; 6 | import me.liuli.ez4h.translators.converters.BlockConverter; 7 | import me.liuli.ez4h.translators.converters.FormConverter; 8 | import me.liuli.ez4h.translators.converters.ItemConverter; 9 | import me.liuli.ez4h.translators.converters.MetadataConverter; 10 | import me.liuli.ez4h.utils.FileUtil; 11 | 12 | public class ConverterManager { 13 | @Getter 14 | private final BlockConverter blockConverter; 15 | @Getter 16 | private final FormConverter formConverter; 17 | @Getter 18 | private final ItemConverter itemConverter; 19 | @Getter 20 | private final MetadataConverter metadataConverter; 21 | 22 | public ConverterManager() { 23 | blockConverter = new BlockConverter(JSONArray.parseArray(FileUtil.getTextFromResource("resources/blocks.json")), JSONObject.parseObject(FileUtil.getTextFromResource("resources/block_runtime.json"))); 24 | formConverter = new FormConverter(); 25 | itemConverter = new ItemConverter(JSONObject.parseObject(FileUtil.getTextFromResource("resources/bedrock_items.json")), JSONObject.parseObject(FileUtil.getTextFromResource("resources/java_items.json")), JSONObject.parseObject(FileUtil.getTextFromResource("resources/enchant.json"))); 26 | metadataConverter = new MetadataConverter(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/entity/PlayerData.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 4 | import com.github.steveice10.mc.protocol.data.game.setting.Difficulty; 5 | import lombok.Getter; 6 | import lombok.Setter; 7 | import me.liuli.ez4h.minecraft.data.world.Location; 8 | 9 | import java.util.UUID; 10 | 11 | public class PlayerData extends Location { 12 | @Getter 13 | @Setter 14 | private long entityId; 15 | @Getter 16 | @Setter 17 | private String name; 18 | @Getter 19 | @Setter 20 | private UUID uuid; 21 | @Getter 22 | @Setter 23 | private String xuid; 24 | @Getter 25 | @Setter 26 | private int dimension; 27 | @Getter 28 | @Setter 29 | private Difficulty difficulty; 30 | @Getter 31 | @Setter 32 | private GameMode gameMode = GameMode.SURVIVAL; 33 | @Getter 34 | @Setter 35 | private float health = 20; 36 | @Getter 37 | @Setter 38 | private float exp = 0; 39 | @Getter 40 | @Setter 41 | private float expLevel = 0; 42 | @Getter 43 | @Setter 44 | private int food = 20; 45 | @Getter 46 | @Setter 47 | private boolean flyable = false; 48 | @Getter 49 | @Setter 50 | private float walkSpeed = 0.7F; 51 | @Getter 52 | @Setter 53 | private boolean usingItem = false; 54 | 55 | public PlayerData() { 56 | super(); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/command/commands/SayCommand.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers.command.commands; 2 | 3 | import com.nukkitx.protocol.bedrock.packet.TextPacket; 4 | import me.liuli.ez4h.managers.command.CommandBase; 5 | import me.liuli.ez4h.minecraft.Client; 6 | 7 | import java.util.ArrayList; 8 | import java.util.List; 9 | 10 | public class SayCommand implements CommandBase { 11 | @Override 12 | public String getCommandName() { 13 | return "say"; 14 | } 15 | 16 | @Override 17 | public String getHelpMessage() { 18 | return "Send Messages To Server."; 19 | } 20 | 21 | @Override 22 | public void exec(String[] args, Client client) { 23 | if (args.length == 0) { 24 | client.sendAlert("`say "); 25 | return; 26 | } 27 | StringBuilder sayMessage = new StringBuilder(); 28 | for (String partMessage : args) { 29 | sayMessage.append(partMessage); 30 | sayMessage.append(" "); 31 | } 32 | TextPacket textPacket = new TextPacket(); 33 | textPacket.setMessage(sayMessage.toString()); 34 | textPacket.setType(TextPacket.Type.CHAT); 35 | textPacket.setNeedsTranslation(false); 36 | textPacket.setXuid(client.getPlayer().getXuid()); 37 | textPacket.setPlatformChatId(""); 38 | List para = new ArrayList<>(); 39 | textPacket.setParameters(para); 40 | textPacket.setSourceName(client.getPlayer().getName()); 41 | client.sendPacket(textPacket); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/world/UpdateBlockPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.world; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.Position; 4 | import com.github.steveice10.mc.protocol.data.game.world.block.BlockChangeRecord; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerBlockChangePacket; 6 | import com.nukkitx.math.vector.Vector3i; 7 | import com.nukkitx.protocol.bedrock.BedrockPacket; 8 | import com.nukkitx.protocol.bedrock.packet.UpdateBlockPacket; 9 | import me.liuli.ez4h.EZ4H; 10 | import me.liuli.ez4h.minecraft.Client; 11 | import me.liuli.ez4h.translators.BedrockTranslator; 12 | import me.liuli.ez4h.translators.converters.BlockConverter; 13 | 14 | public class UpdateBlockPacketTranslator implements BedrockTranslator { 15 | @Override 16 | public void translate(BedrockPacket inPacket, Client client) { 17 | UpdateBlockPacket packet = (UpdateBlockPacket) inPacket; 18 | if (packet.getDataLayer() == 0) {//layer 1 for waterlogging,and you know mc1.12 not support this.... 19 | Vector3i pos = packet.getBlockPosition(); 20 | BlockConverter blockConverter = EZ4H.getConverterManager().getBlockConverter(); 21 | 22 | client.sendPacket(new ServerBlockChangePacket(new BlockChangeRecord(new Position(pos.getX(), pos.getY(), pos.getZ()), blockConverter.getBlockByName(blockConverter.getBedrockNameByRuntime(packet.getRuntimeId()))))); 23 | } 24 | } 25 | 26 | @Override 27 | public Class getPacketClass() { 28 | return UpdateBlockPacket.class; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/AdventureSettingsPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.player.ServerPlayerAbilitiesPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.data.AdventureSetting; 7 | import com.nukkitx.protocol.bedrock.packet.AdventureSettingsPacket; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.BedrockTranslator; 10 | 11 | public class AdventureSettingsPacketTranslator implements BedrockTranslator { 12 | @Override 13 | public void translate(BedrockPacket inPacket, Client client) { 14 | AdventureSettingsPacket packet = (AdventureSettingsPacket) inPacket; 15 | boolean flyable = false; 16 | if (packet.getSettings().contains(AdventureSetting.MAY_FLY)) { 17 | flyable = true; 18 | } 19 | if (client.getPlayer().isFlyable() != flyable) { 20 | client.getPlayer().setFlyable(flyable); 21 | boolean creativeMode = false; 22 | if (client.getPlayer().getGameMode().equals(GameMode.CREATIVE)) { 23 | creativeMode = true; 24 | } 25 | client.sendPacket(new ServerPlayerAbilitiesPacket(false, flyable, flyable, creativeMode, client.getPlayer().getWalkSpeed(), client.getPlayer().getWalkSpeed())); 26 | } 27 | } 28 | 29 | @Override 30 | public Class getPacketClass() { 31 | return AdventureSettingsPacket.class; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/world/Location.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.world; 2 | 3 | import com.nukkitx.math.vector.Vector3f; 4 | import lombok.Getter; 5 | import lombok.Setter; 6 | 7 | public class Location { 8 | @Getter 9 | @Setter 10 | private float x, y, z, yaw, pitch; 11 | 12 | public Location() { 13 | this.x = 0; 14 | this.y = 0; 15 | this.z = 0; 16 | this.yaw = 0; 17 | this.pitch = 0; 18 | } 19 | 20 | public Location(float x, float y, float z) { 21 | this.x = x; 22 | this.y = y; 23 | this.z = z; 24 | this.yaw = 0; 25 | this.pitch = 0; 26 | } 27 | 28 | public Location(float x, float y, float z, float yaw, float pitch) { 29 | this.x = x; 30 | this.y = y; 31 | this.z = z; 32 | this.yaw = yaw; 33 | this.pitch = pitch; 34 | } 35 | 36 | public void setRotation(float yaw, float pitch) { 37 | this.yaw = yaw; 38 | this.pitch = pitch; 39 | } 40 | 41 | public void setRotation(double yaw, double pitch) { 42 | setRotation((float) yaw, (float) pitch); 43 | } 44 | 45 | public void setPosition(float x, float y, float z) { 46 | this.x = x; 47 | this.y = y; 48 | this.z = z; 49 | } 50 | 51 | public void setPosition(double x, double y, double z) { 52 | setPosition((float) x, (float) y, (float) z); 53 | } 54 | 55 | public Vector3f getVec3Location() { 56 | return Vector3f.from(x, y + 1.62, z); 57 | } 58 | 59 | public Vector3f getHeadRotation() { 60 | return Vector3f.from(pitch, yaw, yaw); 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/MobEquipmentPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.EquipmentSlot; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityEquipmentPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.MobEquipmentPacket; 7 | import me.liuli.ez4h.EZ4H; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.BedrockTranslator; 10 | 11 | public class MobEquipmentPacketTranslator implements BedrockTranslator { 12 | @Override 13 | public void translate(BedrockPacket inPacket, Client client) { 14 | MobEquipmentPacket packet = (MobEquipmentPacket) inPacket; 15 | if (packet.getRuntimeEntityId() == client.getPlayer().getEntityId()) { 16 | return; 17 | } 18 | switch (packet.getContainerId()) { 19 | case 0: { 20 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.MAIN_HAND, EZ4H.getConverterManager().getItemConverter().convertToJE(packet.getItem()))); 21 | break; 22 | } 23 | case 119: { 24 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.OFF_HAND, EZ4H.getConverterManager().getItemConverter().convertToJE(packet.getItem()))); 25 | break; 26 | } 27 | } 28 | } 29 | 30 | @Override 31 | public Class getPacketClass() { 32 | return MobEquipmentPacket.class; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/AuthUtil.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils; 2 | 3 | import com.alibaba.fastjson.JSONArray; 4 | import me.liuli.ez4h.minecraft.auth.JoseStuff; 5 | 6 | import java.security.KeyPair; 7 | import java.security.KeyPairGenerator; 8 | import java.security.Signature; 9 | import java.security.interfaces.ECPrivateKey; 10 | import java.security.spec.ECGenParameterSpec; 11 | import java.util.Base64; 12 | 13 | public class AuthUtil { 14 | private static KeyPairGenerator KEY_PAIR_GEN; 15 | 16 | public static void load() { 17 | try { 18 | KEY_PAIR_GEN = KeyPairGenerator.getInstance("EC"); 19 | KEY_PAIR_GEN.initialize(new ECGenParameterSpec("secp256r1"));//use P-256 20 | } catch (Exception e) { 21 | throw new AssertionError("Unable to initialize required encryption", e); 22 | } 23 | } 24 | 25 | public static KeyPair createKeyPair() { 26 | return KEY_PAIR_GEN.generateKeyPair(); 27 | } 28 | 29 | public static JSONArray addChainToBeginning(String chain, JSONArray chainArray) { 30 | JSONArray newArray = new JSONArray(); 31 | newArray.add(chain); 32 | newArray.addAll(chainArray); 33 | return newArray; 34 | } 35 | 36 | public static String signBytes(byte[] dataToSign, ECPrivateKey privateKey) throws Exception { 37 | Signature signature = Signature.getInstance("SHA384withECDSA"); 38 | signature.initSign(privateKey); 39 | signature.update(dataToSign); 40 | byte[] signatureBytes = JoseStuff.DERToJOSE(signature.sign(), JoseStuff.AlgorithmType.ECDSA384); 41 | return Base64.getUrlEncoder().withoutPadding().encodeToString(signatureBytes); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/SetScorePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.scoreboard.ServerUpdateScorePacket; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.data.ScoreInfo; 6 | import com.nukkitx.protocol.bedrock.packet.SetScorePacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | import me.liuli.ez4h.utils.BedrockUtil; 10 | 11 | import java.util.List; 12 | 13 | public class SetScorePacketTranslator implements BedrockTranslator { 14 | @Override 15 | public boolean needOrder() { 16 | return true; 17 | } 18 | 19 | @Override 20 | public void translate(BedrockPacket inPacket, Client client) { 21 | SetScorePacket packet = (SetScorePacket) inPacket; 22 | List infos = packet.getInfos(); 23 | for (ScoreInfo scoreInfo : infos) { 24 | switch (scoreInfo.getType()) { 25 | default: { 26 | int score = scoreInfo.getScore(); 27 | //JE dont support sortorder :sadface: 28 | if (client.getData().getScoreSortorder() == 0) { 29 | score = -score; 30 | } 31 | client.sendPacket(new ServerUpdateScorePacket(BedrockUtil.lengthCutter(scoreInfo.getName(), 40), scoreInfo.getObjectiveId(), score)); 32 | break; 33 | } 34 | } 35 | } 36 | } 37 | 38 | @Override 39 | public Class getPacketClass() { 40 | return SetScorePacket.class; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerRotationPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerRotationPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.JavaTranslator; 10 | 11 | public class ClientPlayerRotationPacketTranslator implements JavaTranslator { 12 | @Override 13 | public void translate(Packet inPacket, Client client) { 14 | ClientPlayerRotationPacket packet = (ClientPlayerRotationPacket) inPacket; 15 | MovePlayerPacket movePlayerPacket = new MovePlayerPacket(); 16 | movePlayerPacket.setMode(MovePlayerPacket.Mode.HEAD_ROTATION); 17 | movePlayerPacket.setOnGround(packet.isOnGround()); 18 | movePlayerPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 19 | movePlayerPacket.setRidingRuntimeEntityId(0); 20 | movePlayerPacket.setPosition(client.getPlayer().getVec3Location()); 21 | movePlayerPacket.setRotation(Vector3f.from(packet.getPitch(), packet.getYaw(), 0)); 22 | movePlayerPacket.setTeleportationCause(MovePlayerPacket.TeleportationCause.UNKNOWN); 23 | movePlayerPacket.setEntityType(0); 24 | client.getPlayer().setRotation(packet.getYaw(), packet.getPitch()); 25 | client.sendPacket(movePlayerPacket); 26 | } 27 | 28 | @Override 29 | public Class getPacketClass() { 30 | return ClientPlayerRotationPacket.class; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/world/BlockEventPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.world; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.Position; 4 | import com.github.steveice10.mc.protocol.data.game.world.block.value.ChestValue; 5 | import com.github.steveice10.mc.protocol.data.game.world.block.value.ChestValueType; 6 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerBlockValuePacket; 7 | import com.nukkitx.math.vector.Vector3i; 8 | import com.nukkitx.protocol.bedrock.BedrockPacket; 9 | import com.nukkitx.protocol.bedrock.packet.BlockEventPacket; 10 | import me.liuli.ez4h.minecraft.Client; 11 | import me.liuli.ez4h.translators.BedrockTranslator; 12 | 13 | public class BlockEventPacketTranslator implements BedrockTranslator { 14 | @Override 15 | public void translate(BedrockPacket inPacket, Client client) { 16 | BlockEventPacket packet = (BlockEventPacket) inPacket; 17 | switch (packet.getEventType()) { 18 | case 1: { 19 | Vector3i pos = packet.getBlockPosition(); 20 | Position blockPos = new Position(pos.getX(), pos.getY(), pos.getZ()); 21 | if (packet.getEventData() == 2) { 22 | client.sendPacket(new ServerBlockValuePacket(blockPos, ChestValueType.VIEWING_PLAYER_COUNT, new ChestValue(1), 54)); 23 | } else { 24 | client.sendPacket(new ServerBlockValuePacket(blockPos, ChestValueType.VIEWING_PLAYER_COUNT, new ChestValue(0), 54)); 25 | } 26 | break; 27 | } 28 | } 29 | } 30 | 31 | @Override 32 | public Class getPacketClass() { 33 | return BlockEventPacket.class; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/TextPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.github.steveice10.mc.protocol.data.game.MessageType; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerChatPacket; 6 | import com.nukkitx.protocol.bedrock.BedrockPacket; 7 | import com.nukkitx.protocol.bedrock.packet.TextPacket; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.BedrockTranslator; 10 | import me.liuli.ez4h.utils.FileUtil; 11 | 12 | public class TextPacketTranslator implements BedrockTranslator { 13 | @Override 14 | public boolean needOrder() { 15 | return true; 16 | } 17 | 18 | @Override 19 | public void translate(BedrockPacket inPacket, Client client) { 20 | TextPacket packet = (TextPacket) inPacket; 21 | switch (packet.getType()) { 22 | case TIP: 23 | case POPUP: { 24 | client.sendPacket(new ServerChatPacket(packet.getMessage(), MessageType.NOTIFICATION)); 25 | break; 26 | } 27 | case SYSTEM: { 28 | client.sendPacket(new ServerChatPacket(packet.getMessage(), MessageType.SYSTEM)); 29 | break; 30 | } 31 | case CHAT: { 32 | client.sendMessage("[" + packet.getSourceName() + "] " + packet.getMessage()); 33 | break; 34 | } 35 | default: { 36 | client.sendMessage(client.getMcLocale().translateMessage(packet)); 37 | break; 38 | } 39 | } 40 | } 41 | @Override 42 | public Class getPacketClass() { 43 | return TextPacket.class; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/AnimatePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.player.Animation; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityAnimationPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.AnimatePacket; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.translators.BedrockTranslator; 9 | 10 | public class AnimatePacketTranslator implements BedrockTranslator { 11 | @Override 12 | public void translate(BedrockPacket inPacket, Client client) { 13 | AnimatePacket packet = (AnimatePacket) inPacket; 14 | switch (packet.getAction()) { 15 | case SWING_ARM: { 16 | client.sendPacket(new ServerEntityAnimationPacket((int) packet.getRuntimeEntityId(), Animation.SWING_ARM)); 17 | break; 18 | } 19 | case WAKE_UP: { 20 | client.sendPacket(new ServerEntityAnimationPacket((int) packet.getRuntimeEntityId(), Animation.LEAVE_BED)); 21 | break; 22 | } 23 | case CRITICAL_HIT: { 24 | client.sendPacket(new ServerEntityAnimationPacket((int) packet.getRuntimeEntityId(), Animation.CRITICAL_HIT)); 25 | break; 26 | } 27 | case MAGIC_CRITICAL_HIT: { 28 | client.sendPacket(new ServerEntityAnimationPacket((int) packet.getRuntimeEntityId(), Animation.ENCHANTMENT_CRITICAL_HIT)); 29 | break; 30 | } 31 | } 32 | } 33 | 34 | @Override 35 | public Class getPacketClass() { 36 | return AnimatePacket.class; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/MobArmorEquipmentPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.EquipmentSlot; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityEquipmentPacket; 5 | import com.nukkitx.protocol.bedrock.BedrockPacket; 6 | import com.nukkitx.protocol.bedrock.packet.MobArmorEquipmentPacket; 7 | import me.liuli.ez4h.EZ4H; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.BedrockTranslator; 10 | import me.liuli.ez4h.translators.converters.ItemConverter; 11 | 12 | public class MobArmorEquipmentPacketTranslator implements BedrockTranslator { 13 | @Override 14 | public void translate(BedrockPacket inPacket, Client client) { 15 | MobArmorEquipmentPacket packet = (MobArmorEquipmentPacket) inPacket; 16 | 17 | ItemConverter itemConverter = EZ4H.getConverterManager().getItemConverter(); 18 | 19 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.HELMET, itemConverter.convertToJE(packet.getHelmet()))); 20 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.CHESTPLATE, itemConverter.convertToJE(packet.getChestplate()))); 21 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.LEGGINGS, itemConverter.convertToJE(packet.getLeggings()))); 22 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.BOOTS, itemConverter.convertToJE(packet.getBoots()))); 23 | } 24 | 25 | @Override 26 | public Class getPacketClass() { 27 | return MobArmorEquipmentPacket.class; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/entity/Inventory.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.ItemStack; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.window.ServerSetSlotPacket; 5 | import com.nukkitx.protocol.bedrock.data.inventory.ItemData; 6 | import lombok.Getter; 7 | import lombok.Setter; 8 | import me.liuli.ez4h.EZ4H; 9 | import me.liuli.ez4h.minecraft.Client; 10 | 11 | public class Inventory { 12 | private final Client client; 13 | @Getter 14 | private final ItemStack[] javaInventory = new ItemStack[46]; 15 | @Getter 16 | private final ItemData[] bedrockInventory = new ItemData[46]; 17 | @Getter 18 | @Setter 19 | private int handSlot = 0; 20 | @Getter 21 | @Setter 22 | private boolean open = false; 23 | 24 | public Inventory(Client client) { 25 | this.client = client; 26 | } 27 | 28 | public ItemData getBedrockItemInHand() { 29 | return bedrockInventory[36 + handSlot]; 30 | } 31 | 32 | public ItemStack getJavaItemInHand() { 33 | return javaInventory[36 + handSlot]; 34 | } 35 | 36 | public void updateHand(int hand) { 37 | this.handSlot = hand; 38 | } 39 | 40 | public ItemStack getJavaItem(int slot) { 41 | return javaInventory[slot]; 42 | } 43 | 44 | public ItemData getBedrockItem(int slot) { 45 | return bedrockInventory[slot]; 46 | } 47 | 48 | public void updateItem(ItemData itemData, int slot, boolean packet) { 49 | ItemStack itemStack = EZ4H.getConverterManager().getItemConverter().convertToJE(itemData); 50 | javaInventory[slot] = itemStack; 51 | bedrockInventory[slot] = itemData; 52 | if (packet) { 53 | client.sendPacket(new ServerSetSlotPacket(0, slot, itemStack)); 54 | } 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/window/InventorySlotPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.window; 2 | 3 | import com.nukkitx.protocol.bedrock.BedrockPacket; 4 | import com.nukkitx.protocol.bedrock.packet.InventorySlotPacket; 5 | import me.liuli.ez4h.EZ4H; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | import me.liuli.ez4h.translators.converters.ItemConverter; 9 | 10 | public class InventorySlotPacketTranslator implements BedrockTranslator { 11 | @Override 12 | public boolean needOrder() { 13 | return true; 14 | } 15 | 16 | @Override 17 | public void translate(BedrockPacket inPacket, Client client) { 18 | InventorySlotPacket packet = (InventorySlotPacket) inPacket; 19 | 20 | ItemConverter itemConverter = EZ4H.getConverterManager().getItemConverter(); 21 | 22 | switch (packet.getContainerId()) { 23 | case 0: { 24 | if (client.getPlayer().isUsingItem() && packet.getSlot() == (client.getInventory().getHandSlot() + 36)) { 25 | return; 26 | } 27 | client.getInventory().updateItem(packet.getItem(), itemConverter.inventoryIndex(packet.getSlot(), false), true); 28 | break; 29 | } 30 | case 119: { 31 | client.getInventory().updateItem(packet.getItem(), 45, true); 32 | break; 33 | } 34 | case 120: { 35 | client.getInventory().updateItem(packet.getItem(), packet.getSlot() + 5, true); 36 | break; 37 | } 38 | default: { 39 | break; 40 | } 41 | } 42 | } 43 | 44 | @Override 45 | public Class getPacketClass() { 46 | return InventorySlotPacket.class; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerPositionPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerPositionPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.JavaTranslator; 10 | 11 | public class ClientPlayerPositionPacketTranslator implements JavaTranslator { 12 | @Override 13 | public void translate(Packet inPacket, Client client) { 14 | ClientPlayerPositionPacket packet = (ClientPlayerPositionPacket) inPacket; 15 | MovePlayerPacket movePlayerPacket = new MovePlayerPacket(); 16 | client.getPlayer().setPosition(packet.getX(), packet.getY(), packet.getZ()); 17 | movePlayerPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 18 | movePlayerPacket.setPosition(client.getPlayer().getVec3Location()); 19 | movePlayerPacket.setRotation(Vector3f.from(client.getPlayer().getPitch(), client.getPlayer().getYaw(), client.getPlayer().getYaw())); 20 | movePlayerPacket.setMode(MovePlayerPacket.Mode.NORMAL); 21 | movePlayerPacket.setOnGround(packet.isOnGround()); 22 | movePlayerPacket.setRidingRuntimeEntityId(0); 23 | movePlayerPacket.setTeleportationCause(MovePlayerPacket.TeleportationCause.UNKNOWN); 24 | movePlayerPacket.setEntityType(0); 25 | client.sendPacket(movePlayerPacket); 26 | ClientPlayerPositionRotationPacketTranslator.playerGround(client, packet.isOnGround()); 27 | } 28 | 29 | @Override 30 | public Class getPacketClass() { 31 | return ClientPlayerPositionPacket.class; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/MovePlayerPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityHeadLookPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.player.ServerPlayerPositionRotationPacket; 5 | import com.nukkitx.math.vector.Vector3f; 6 | import com.nukkitx.protocol.bedrock.BedrockPacket; 7 | import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.minecraft.data.entity.Entity; 10 | import me.liuli.ez4h.translators.BedrockTranslator; 11 | 12 | public class MovePlayerPacketTranslator implements BedrockTranslator { 13 | @Override 14 | public void translate(BedrockPacket inPacket, Client client) { 15 | MovePlayerPacket packet = (MovePlayerPacket) inPacket; 16 | Vector3f position = packet.getPosition(), rotation = packet.getRotation(); 17 | if (packet.getRuntimeEntityId() == client.getPlayer().getEntityId()) { 18 | ServerPlayerPositionRotationPacket serverPlayerPositionRotationPacket = new ServerPlayerPositionRotationPacket(position.getX(), position.getY() - 1.62, position.getZ(), rotation.getY(), rotation.getX(), 1); 19 | client.sendPacket(serverPlayerPositionRotationPacket); 20 | client.getPlayer().setPosition(position.getX(), position.getY() - 1.62, position.getZ()); 21 | } else { 22 | Entity entity = client.getData().getEntity((int) packet.getRuntimeEntityId()); 23 | client.getData().moveEntity(entity, position, rotation, packet.isOnGround()); 24 | client.sendPacket(new ServerEntityHeadLookPacket((int) packet.getRuntimeEntityId(), rotation.getZ())); 25 | } 26 | } 27 | 28 | @Override 29 | public Class getPacketClass() { 30 | return MovePlayerPacket.class; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/SetDisplayObjectivePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.scoreboard.ObjectiveAction; 4 | import com.github.steveice10.mc.protocol.data.game.scoreboard.ScoreType; 5 | import com.github.steveice10.mc.protocol.data.game.scoreboard.ScoreboardPosition; 6 | import com.github.steveice10.mc.protocol.packet.ingame.server.scoreboard.ServerDisplayScoreboardPacket; 7 | import com.github.steveice10.mc.protocol.packet.ingame.server.scoreboard.ServerScoreboardObjectivePacket; 8 | import com.nukkitx.protocol.bedrock.BedrockPacket; 9 | import com.nukkitx.protocol.bedrock.packet.SetDisplayObjectivePacket; 10 | import me.liuli.ez4h.minecraft.Client; 11 | import me.liuli.ez4h.translators.BedrockTranslator; 12 | import me.liuli.ez4h.utils.BedrockUtil; 13 | 14 | public class SetDisplayObjectivePacketTranslator implements BedrockTranslator { 15 | @Override 16 | public boolean needOrder() { 17 | return true; 18 | } 19 | 20 | @Override 21 | public void translate(BedrockPacket inPacket, Client client) { 22 | SetDisplayObjectivePacket packet = (SetDisplayObjectivePacket) inPacket; 23 | 24 | String name = BedrockUtil.lengthCutter(packet.getDisplayName(), 32); 25 | 26 | switch (packet.getDisplaySlot()) { 27 | case "sidebar": { 28 | client.getData().setScoreSortorder(packet.getSortOrder()); 29 | client.sendPacket(new ServerScoreboardObjectivePacket(packet.getObjectiveId(), ObjectiveAction.ADD, name, ScoreType.INTEGER)); 30 | client.sendPacket(new ServerDisplayScoreboardPacket(ScoreboardPosition.SIDEBAR, packet.getObjectiveId())); 31 | break; 32 | } 33 | } 34 | } 35 | 36 | @Override 37 | public Class getPacketClass() { 38 | return SetDisplayObjectivePacket.class; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/AuthManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import lombok.Getter; 5 | import me.liuli.ez4h.EZ4H; 6 | import me.liuli.ez4h.minecraft.auth.XboxLogin; 7 | import me.liuli.ez4h.utils.FileUtil; 8 | import me.liuli.ez4h.utils.OtherUtil; 9 | 10 | import java.io.File; 11 | import java.util.HashMap; 12 | import java.util.Map; 13 | 14 | public class AuthManager { 15 | @Getter 16 | private final XboxLogin xboxLogin; 17 | @Getter 18 | private final Map accessTokens = new HashMap<>(); 19 | private JSONObject accounts = null; 20 | 21 | public AuthManager() { 22 | xboxLogin = new XboxLogin(); 23 | if (EZ4H.getConfigManager().isAutoLogin()) { 24 | if (!new File("./data/accounts.json").exists()) { 25 | FileUtil.writeFile("./data/accounts.json", "{}"); 26 | } 27 | accounts = JSONObject.parseObject(FileUtil.readFile(new File("./data/accounts.json"))); 28 | } 29 | } 30 | 31 | public JSONObject getAccount(String mcUsername) { 32 | if (EZ4H.getConfigManager().isAutoLogin() && accounts.containsKey(mcUsername)) { 33 | return JSONObject.parseObject(OtherUtil.base64Decode((String) accounts.get(mcUsername))); 34 | } 35 | return null; 36 | } 37 | 38 | public void saveAccount(String mcUsername, String username, String password) { 39 | if (EZ4H.getConfigManager().isAutoLogin()) { 40 | JSONObject account = new JSONObject(); 41 | account.put("username", username); 42 | account.put("password", password); 43 | accounts.put(mcUsername, OtherUtil.base64Encode(account.toJSONString())); 44 | saveAccountsToFile(); 45 | } 46 | } 47 | 48 | public void removeAccount(String mcUsername) { 49 | if (EZ4H.getConfigManager().isAutoLogin()) { 50 | accounts.remove(mcUsername); 51 | saveAccountsToFile(); 52 | } 53 | } 54 | 55 | public void saveAccountsToFile() { 56 | FileUtil.writeFile("./data/accounts.json", accounts.toJSONString()); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/AddItemEntityPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.EntityMetadata; 4 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.MetadataType; 5 | import com.github.steveice10.mc.protocol.data.game.entity.type.object.ObjectType; 6 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityMetadataPacket; 7 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.spawn.ServerSpawnObjectPacket; 8 | import com.nukkitx.math.vector.Vector3f; 9 | import com.nukkitx.protocol.bedrock.BedrockPacket; 10 | import com.nukkitx.protocol.bedrock.packet.AddItemEntityPacket; 11 | import me.liuli.ez4h.EZ4H; 12 | import me.liuli.ez4h.minecraft.Client; 13 | import me.liuli.ez4h.minecraft.data.entity.Entity; 14 | import me.liuli.ez4h.translators.BedrockTranslator; 15 | 16 | import java.util.UUID; 17 | 18 | public class AddItemEntityPacketTranslator implements BedrockTranslator { 19 | @Override 20 | public void translate(BedrockPacket inPacket, Client client) { 21 | AddItemEntityPacket packet = (AddItemEntityPacket) inPacket; 22 | Vector3f position = packet.getPosition(); 23 | client.getData().addEntity((int) packet.getRuntimeEntityId(), new Entity(position.getX(), (float) (position.getY() - 1.62), position.getZ(), (int) packet.getRuntimeEntityId(), Entity.Type.ITEM_ENTITY)); 24 | EntityMetadata[] metadata = new EntityMetadata[1]; 25 | metadata[0] = new EntityMetadata(6, MetadataType.ITEM, EZ4H.getConverterManager().getItemConverter().convertToJE(packet.getItemInHand())); 26 | client.sendPacket(new ServerSpawnObjectPacket((int) packet.getRuntimeEntityId(), UUID.nameUUIDFromBytes(String.valueOf(packet.getRuntimeEntityId()).getBytes()), ObjectType.ITEM, position.getX(), position.getY(), position.getZ(), 0, 0)); 27 | client.sendPacket(new ServerEntityMetadataPacket((int) packet.getRuntimeEntityId(), metadata)); 28 | } 29 | 30 | @Override 31 | public Class getPacketClass() { 32 | return AddItemEntityPacket.class; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/connect/ServerToClientHandshakePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.connect; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import com.nukkitx.protocol.bedrock.packet.ClientToServerHandshakePacket; 6 | import com.nukkitx.protocol.bedrock.packet.ServerToClientHandshakePacket; 7 | import com.nukkitx.protocol.bedrock.util.EncryptionUtils; 8 | import me.liuli.ez4h.minecraft.Client; 9 | import me.liuli.ez4h.translators.BedrockTranslator; 10 | 11 | import javax.crypto.SecretKey; 12 | import java.security.interfaces.ECPublicKey; 13 | import java.util.Base64; 14 | 15 | public class ServerToClientHandshakePacketTranslator implements BedrockTranslator { 16 | @Override 17 | public boolean needOrder() { 18 | return true; 19 | } 20 | 21 | @Override 22 | public void translate(BedrockPacket inPacket, Client client) { 23 | ServerToClientHandshakePacket packet = (ServerToClientHandshakePacket) inPacket; 24 | try { 25 | String[] jwtSplit = packet.getJwt().split("\\."); 26 | String header = new String(Base64.getDecoder().decode(jwtSplit[0])); 27 | JSONObject headerObject = JSONObject.parseObject(header); 28 | 29 | String payload = new String(Base64.getDecoder().decode(jwtSplit[1])); 30 | JSONObject payloadObject = JSONObject.parseObject(payload); 31 | 32 | ECPublicKey serverKey = EncryptionUtils.generateKey(headerObject.getString("x5u")); 33 | SecretKey key = EncryptionUtils.getSecretKey(client.getPrivateKey(), serverKey, Base64.getDecoder().decode(payloadObject.getString("salt"))); 34 | client.getBedrockSession().enableEncryption(key); 35 | } catch (Exception e) { 36 | e.printStackTrace(); 37 | } 38 | 39 | ClientToServerHandshakePacket clientToServerHandshake = new ClientToServerHandshakePacket(); 40 | client.sendPacket(clientToServerHandshake); 41 | } 42 | 43 | @Override 44 | public Class getPacketClass() { 45 | return ServerToClientHandshakePacket.class; 46 | } 47 | } 48 | 49 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/world/LevelEventPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.world; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.Position; 4 | import com.github.steveice10.mc.protocol.data.game.entity.player.BlockBreakStage; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerBlockBreakAnimPacket; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.protocol.bedrock.BedrockPacket; 8 | import com.nukkitx.protocol.bedrock.packet.LevelEventPacket; 9 | import me.liuli.ez4h.minecraft.Client; 10 | import me.liuli.ez4h.translators.BedrockTranslator; 11 | 12 | public class LevelEventPacketTranslator implements BedrockTranslator { 13 | @Override 14 | public void translate(BedrockPacket inPacket, Client client) { 15 | LevelEventPacket packet = (LevelEventPacket) inPacket; 16 | //TODO:PARTICLES 17 | switch (packet.getType()) { 18 | case BLOCK_START_BREAK: { 19 | Vector3f pos = packet.getPosition(); 20 | client.sendPacket(new ServerBlockBreakAnimPacket(0, new Position((int) pos.getX(), (int) pos.getY(), (int) pos.getZ()), BlockBreakStage.STAGE_1)); 21 | break; 22 | } 23 | case BLOCK_STOP_BREAK: { 24 | Vector3f pos = packet.getPosition(); 25 | client.sendPacket(new ServerBlockBreakAnimPacket(0, new Position((int) pos.getX(), (int) pos.getY(), (int) pos.getZ()), BlockBreakStage.RESET)); 26 | break; 27 | } 28 | case STOP_RAINING: 29 | case STOP_THUNDERSTORM: { 30 | client.getWeather().setWeather(0); 31 | break; 32 | } 33 | case START_RAINING: { 34 | client.getWeather().setWeather(1); 35 | break; 36 | } 37 | case START_THUNDERSTORM: { 38 | client.getWeather().setWeather(2); 39 | break; 40 | } 41 | } 42 | } 43 | 44 | 45 | @Override 46 | public Class getPacketClass() { 47 | return LevelEventPacket.class; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/BedrockUtil.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 4 | import com.github.steveice10.mc.protocol.data.game.setting.Difficulty; 5 | import com.nukkitx.protocol.bedrock.data.GameType; 6 | 7 | import java.util.UUID; 8 | 9 | public class BedrockUtil { 10 | public static Difficulty convertDifficultyToJE(int diff) { 11 | Difficulty difficulty; 12 | switch (diff) { 13 | case 0: { 14 | difficulty = Difficulty.PEACEFUL; 15 | break; 16 | } 17 | case 1: { 18 | difficulty = Difficulty.EASY; 19 | break; 20 | } 21 | case 3: { 22 | difficulty = Difficulty.HARD; 23 | break; 24 | } 25 | default: { 26 | difficulty = Difficulty.NORMAL; 27 | break; 28 | } 29 | } 30 | return difficulty; 31 | } 32 | 33 | public static GameMode convertGameModeToJE(GameType gameType) { 34 | String BEGameType = gameType.toString(); 35 | if (BEGameType.contains("VIEWER")) { 36 | BEGameType = GameMode.SPECTATOR.name(); 37 | } 38 | GameMode gameMode = GameMode.SURVIVAL; 39 | try { 40 | gameMode = GameMode.valueOf(BEGameType); 41 | } catch (Exception e) { 42 | } 43 | return gameMode; 44 | } 45 | 46 | public static double calcDistance(double fromX, double fromY, double fromZ, double toX, double toY, double toZ) { 47 | return Math.sqrt(Math.pow(fromX - toX, 2.0D) + Math.pow(fromY - toY, 2.0D) + Math.pow(fromZ - toZ, 2.0D)); 48 | } 49 | 50 | public static String lengthCutter(String bedrockName, int leng) { 51 | if (bedrockName == null) { 52 | return "null"; 53 | } 54 | if (bedrockName.length() > leng) { 55 | return bedrockName.substring(0, leng); 56 | } else { 57 | return bedrockName; 58 | } 59 | } 60 | 61 | public static UUID getUUID(Object obj) { 62 | return UUID.nameUUIDFromBytes(String.valueOf(obj).getBytes()); 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/nukkit/BitArrayVersion.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils.nukkit; 2 | 3 | public enum BitArrayVersion { 4 | V16(16, 2, null), 5 | V8(8, 4, V16), 6 | V6(6, 5, V8), // 2 bit padding 7 | V5(5, 6, V6), // 2 bit padding 8 | V4(4, 8, V5), 9 | V3(3, 10, V4), // 2 bit padding 10 | V2(2, 16, V3), 11 | V1(1, 32, V2); 12 | 13 | public final byte bits;//TODO: probably make this private again just because 14 | public final byte entriesPerWord;//TODO: probably make this private again just because 15 | public final int maxEntryValue;//TODO: probably make this private again just because 16 | final BitArrayVersion next; 17 | 18 | BitArrayVersion(int bits, int entriesPerWord, BitArrayVersion next) { 19 | this.bits = (byte) bits; 20 | this.entriesPerWord = (byte) entriesPerWord; 21 | this.maxEntryValue = (1 << this.bits) - 1; 22 | this.next = next; 23 | } 24 | 25 | public static BitArrayVersion get(int version, boolean read) { 26 | for (BitArrayVersion ver : values()) { 27 | if ((!read && ver.entriesPerWord <= version) || (read && ver.bits == version)) { 28 | return ver; 29 | } 30 | } 31 | throw new IllegalArgumentException("Invalid palette version: " + version); 32 | } 33 | 34 | public BitArray createPalette(int size) { 35 | return this.createPalette(size, new int[this.getWordsForSize(size)]); 36 | } 37 | 38 | public byte getId() { 39 | return bits; 40 | } 41 | 42 | public int getWordsForSize(int size) { 43 | return (size / entriesPerWord) + (size % entriesPerWord == 0 ? 0 : 1); 44 | } 45 | 46 | public int getMaxEntryValue() { 47 | return maxEntryValue; 48 | } 49 | 50 | public BitArrayVersion next() { 51 | return next; 52 | } 53 | 54 | public BitArray createPalette(int size, int[] words) { 55 | if (this == V3 || this == V5 || this == V6) { 56 | // Padded palettes aren't able to use bitwise operations due to their padding. 57 | return new PaddedBitArray(this, size, words); 58 | } else { 59 | return new Pow2BitArray(this, size, words); 60 | } 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/PlayerListPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.auth.data.GameProfile; 4 | import com.github.steveice10.mc.protocol.data.game.PlayerListEntry; 5 | import com.github.steveice10.mc.protocol.data.game.PlayerListEntryAction; 6 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 7 | import com.github.steveice10.mc.protocol.data.message.TextMessage; 8 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerPlayerListEntryPacket; 9 | import com.nukkitx.protocol.bedrock.BedrockPacket; 10 | import com.nukkitx.protocol.bedrock.packet.PlayerListPacket; 11 | import me.liuli.ez4h.minecraft.Client; 12 | import me.liuli.ez4h.translators.BedrockTranslator; 13 | import me.liuli.ez4h.utils.BedrockUtil; 14 | 15 | import java.util.ArrayList; 16 | 17 | public class PlayerListPacketTranslator implements BedrockTranslator { 18 | @Override 19 | public void translate(BedrockPacket inPacket, Client client) { 20 | PlayerListPacket packet = (PlayerListPacket) inPacket; 21 | ArrayList playerListEntries = new ArrayList<>(); 22 | for (PlayerListPacket.Entry entry : packet.getEntries()) { 23 | GameProfile gameProfile = new GameProfile(entry.getUuid(), BedrockUtil.lengthCutter(entry.getName(), 16)); 24 | playerListEntries.add(new PlayerListEntry(gameProfile, GameMode.SURVIVAL, 0, new TextMessage(BedrockUtil.lengthCutter(entry.getName(), 16)))); 25 | } 26 | PlayerListEntry[] playerListEntriesL = playerListEntries.toArray(new PlayerListEntry[0]); 27 | switch (packet.getAction()) { 28 | case ADD: { 29 | client.sendPacket(new ServerPlayerListEntryPacket(PlayerListEntryAction.ADD_PLAYER, playerListEntriesL)); 30 | break; 31 | } 32 | case REMOVE: { 33 | client.sendPacket(new ServerPlayerListEntryPacket(PlayerListEntryAction.REMOVE_PLAYER, playerListEntriesL)); 34 | break; 35 | } 36 | } 37 | } 38 | 39 | @Override 40 | public Class getPacketClass() { 41 | return PlayerListPacket.class; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerPlaceBlockPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.Position; 4 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 5 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerPlaceBlockPacket; 6 | import com.github.steveice10.packetlib.packet.Packet; 7 | import com.nukkitx.math.vector.Vector3f; 8 | import com.nukkitx.math.vector.Vector3i; 9 | import com.nukkitx.protocol.bedrock.data.inventory.TransactionType; 10 | import com.nukkitx.protocol.bedrock.packet.InventoryTransactionPacket; 11 | import me.liuli.ez4h.minecraft.Client; 12 | import me.liuli.ez4h.translators.JavaTranslator; 13 | 14 | public class ClientPlayerPlaceBlockPacketTranslator implements JavaTranslator { 15 | @Override 16 | public void translate(Packet inPacket, Client client) { 17 | ClientPlayerPlaceBlockPacket packet = (ClientPlayerPlaceBlockPacket) inPacket; 18 | Position position = packet.getPosition(); 19 | 20 | InventoryTransactionPacket useInventoryTransactionPacket = new InventoryTransactionPacket(); 21 | useInventoryTransactionPacket.setTransactionType(TransactionType.ITEM_USE); 22 | useInventoryTransactionPacket.setActionType(0); 23 | useInventoryTransactionPacket.setBlockPosition(Vector3i.from(position.getX(), position.getY(), position.getZ())); 24 | useInventoryTransactionPacket.setBlockFace(packet.getFace().ordinal()); 25 | useInventoryTransactionPacket.setHotbarSlot(client.getInventory().getHandSlot()); 26 | useInventoryTransactionPacket.setItemInHand(client.getInventory().getBedrockItemInHand()); 27 | useInventoryTransactionPacket.setPlayerPosition(client.getPlayer().getVec3Location()); 28 | useInventoryTransactionPacket.setClickPosition(Vector3f.from(packet.getCursorX(), packet.getCursorY(), packet.getCursorZ())); 29 | useInventoryTransactionPacket.setBlockRuntimeId(0); 30 | client.sendPacket(useInventoryTransactionPacket); 31 | } 32 | 33 | @Override 34 | public Class getPacketClass() { 35 | return ClientPlayerPlaceBlockPacket.class; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/OtherUtil.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils; 2 | 3 | import javax.net.ssl.HttpsURLConnection; 4 | import java.awt.*; 5 | import java.awt.image.BufferedImage; 6 | import java.net.URL; 7 | import java.util.Base64; 8 | 9 | public class OtherUtil { 10 | public static boolean isNull(Object object) { 11 | return object == null; 12 | } 13 | 14 | public static String base64Encode(String input) { 15 | return new String(Base64.getEncoder().encode(input.getBytes())); 16 | } 17 | 18 | public static String base64Encode(byte[] input) { 19 | return new String(Base64.getEncoder().encode(input)); 20 | } 21 | 22 | public static String base64Decode(String input) { 23 | return new String(Base64.getDecoder().decode(input.getBytes())); 24 | } 25 | 26 | public static byte[] toByteArray(long value) { 27 | byte[] result = new byte[8]; 28 | for (int i = 7; i >= 0; i--) { 29 | result[i] = (byte) (int) (value & 0xFFL); 30 | value >>= 8L; 31 | } 32 | return result; 33 | } 34 | 35 | public static void setBaseHeaders(HttpsURLConnection connection) { 36 | connection.setRequestProperty("Accept-encoding", "gzip"); 37 | connection.setRequestProperty("Accept-Language", "en-US"); 38 | connection.setRequestProperty("User-Agent", "Mozilla/5.0 (XboxReplay; XboxLiveAuth/3.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36"); 39 | } 40 | 41 | public static boolean intToBool(int value, boolean defaultValue) { 42 | if (value == 0) { 43 | return false; 44 | } else if (value == 1) { 45 | return true; 46 | } else { 47 | return defaultValue; 48 | } 49 | } 50 | 51 | public static BufferedImage compressImage(BufferedImage image, int width,int height) { 52 | try { 53 | BufferedImage buffImg = new BufferedImage(width,height, BufferedImage.TYPE_4BYTE_ABGR); 54 | buffImg.getGraphics().drawImage(image.getScaledInstance(width,height, Image.SCALE_SMOOTH), 0, 0, null); 55 | return buffImg; 56 | } catch (Exception e) { 57 | e.printStackTrace(); 58 | } 59 | return null; 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/nukkit/PaddedBitArray.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils.nukkit; 2 | 3 | import java.util.Arrays; 4 | 5 | public class PaddedBitArray implements BitArray { 6 | 7 | /** 8 | * Array used to store data 9 | */ 10 | private final int[] words; 11 | 12 | /** 13 | * Palette version information 14 | */ 15 | private final BitArrayVersion version; 16 | 17 | /** 18 | * Number of entries in this palette (not the length of the words array that internally backs this palette) 19 | */ 20 | private final int size; 21 | 22 | PaddedBitArray(BitArrayVersion version, int size, int[] words) { 23 | this.size = size; 24 | this.version = version; 25 | this.words = words; 26 | int expectedWordsLength = ceil((float) size / version.entriesPerWord); 27 | if (words.length != expectedWordsLength) { 28 | throw new IllegalArgumentException("Invalid length given for storage, got: " + words.length + " but expected: " + expectedWordsLength); 29 | } 30 | } 31 | 32 | public static int ceil(float f) { 33 | int i = (int) f; 34 | return f > (float) i ? i + 1 : i; 35 | } 36 | 37 | @Override 38 | public void set(int index, int value) { 39 | int arrayIndex = index / this.version.entriesPerWord; 40 | int offset = (index % this.version.entriesPerWord) * this.version.bits; 41 | 42 | this.words[arrayIndex] = this.words[arrayIndex] & ~(this.version.maxEntryValue << offset) | (value & this.version.maxEntryValue) << offset; 43 | } 44 | 45 | @Override 46 | public int get(int index) { 47 | int arrayIndex = index / this.version.entriesPerWord; 48 | int offset = (index % this.version.entriesPerWord) * this.version.bits; 49 | 50 | return (this.words[arrayIndex] >>> offset) & this.version.maxEntryValue; 51 | } 52 | 53 | @Override 54 | public int size() { 55 | return this.size; 56 | } 57 | 58 | @Override 59 | public int[] getWords() { 60 | return this.words; 61 | } 62 | 63 | @Override 64 | public BitArrayVersion getVersion() { 65 | return this.version; 66 | } 67 | 68 | @Override 69 | public BitArray copy() { 70 | return new PaddedBitArray(this.version, this.size, Arrays.copyOf(this.words, this.words.length)); 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/play/ClientData.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityTeleportPacket; 4 | import com.nukkitx.math.vector.Vector3f; 5 | import lombok.Getter; 6 | import lombok.Setter; 7 | import me.liuli.ez4h.minecraft.Client; 8 | import me.liuli.ez4h.minecraft.data.entity.Entity; 9 | import me.liuli.ez4h.minecraft.data.entity.Inventory; 10 | import me.liuli.ez4h.minecraft.data.world.ChestData; 11 | import me.liuli.ez4h.minecraft.data.world.Weather; 12 | 13 | import java.util.HashMap; 14 | import java.util.Map; 15 | 16 | public class ClientData { 17 | private final Client client; 18 | 19 | @Getter 20 | private final Weather weather; 21 | @Getter 22 | private final Inventory inventory; 23 | private final Map entitys = new HashMap<>(); 24 | @Getter 25 | @Setter 26 | private int scoreSortorder = 0; 27 | @Getter 28 | @Setter 29 | private Form form = null; 30 | @Getter 31 | @Setter 32 | private int itemInHand = 0; 33 | @Getter 34 | @Setter 35 | private ChestData queueChest = null; 36 | @Getter 37 | @Setter 38 | private boolean jumpTiming = true; 39 | 40 | public ClientData(Client client) { 41 | this.client = client; 42 | this.weather = new Weather(client); 43 | this.inventory = new Inventory(client); 44 | } 45 | 46 | public void addEntity(int id, Entity entity) { 47 | entitys.put(id, entity); 48 | } 49 | 50 | public Entity removeEntity(int id) { 51 | return entitys.remove(id); 52 | } 53 | 54 | public Entity getEntity(int id) { 55 | return entitys.get(id); 56 | } 57 | 58 | public Entity getEntity(long id) { 59 | return getEntity((int) id); 60 | } 61 | 62 | public void moveEntity(Entity entity, Vector3f position, Vector3f rotation, boolean onGround) { 63 | if (entity == null) return; 64 | 65 | float packetY = position.getY(); 66 | //player head height 67 | if (entity.getType().equals(Entity.Type.PLAYER)) 68 | packetY -= 1.62F; 69 | 70 | client.sendPacket(new ServerEntityTeleportPacket(entity.getId(), position.getX(), packetY, position.getZ(), rotation.getY(), rotation.getX(), onGround)); 71 | entity.setX(position.getX()); 72 | entity.setY(position.getY() - 1.62F); 73 | entity.setZ(position.getZ()); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/nukkit/Pow2BitArray.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils.nukkit; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Pow2BitArray implements BitArray { 6 | 7 | /** 8 | * Array used to store data 9 | */ 10 | private final int[] words; 11 | 12 | /** 13 | * Palette version information 14 | */ 15 | private final BitArrayVersion version; 16 | 17 | /** 18 | * Number of entries in this palette (not the length of the words array that internally backs this palette) 19 | */ 20 | private final int size; 21 | 22 | Pow2BitArray(BitArrayVersion version, int size, int[] words) { 23 | this.size = size; 24 | this.version = version; 25 | this.words = words; 26 | int expectedWordsLength = PaddedBitArray.ceil((float) size / version.entriesPerWord); 27 | if (words.length != expectedWordsLength) { 28 | throw new IllegalArgumentException("Invalid length given for storage, got: " + words.length + " but expected: " + expectedWordsLength); 29 | } 30 | } 31 | 32 | /** 33 | * Sets the entry at the given location to the given value 34 | */ 35 | public void set(int index, int value) { 36 | int bitIndex = index * this.version.bits; 37 | int arrayIndex = bitIndex >> 5; 38 | int offset = bitIndex & 31; 39 | this.words[arrayIndex] = this.words[arrayIndex] & ~(this.version.maxEntryValue << offset) | (value & this.version.maxEntryValue) << offset; 40 | } 41 | 42 | /** 43 | * Gets the entry at the given index 44 | */ 45 | public int get(int index) { 46 | int bitIndex = index * this.version.bits; 47 | int arrayIndex = bitIndex >> 5; 48 | int wordOffset = bitIndex & 31; 49 | return this.words[arrayIndex] >>> wordOffset & this.version.maxEntryValue; 50 | } 51 | 52 | /** 53 | * Gets the long array that is used to store the data in this BitArray. This is useful for sending packet data. 54 | */ 55 | public int size() { 56 | return this.size; 57 | } 58 | 59 | /** 60 | * {@inheritDoc} 61 | * 62 | * @return {@inheritDoc} 63 | */ 64 | @Override 65 | public int[] getWords() { 66 | return this.words; 67 | } 68 | 69 | public BitArrayVersion getVersion() { 70 | return version; 71 | } 72 | 73 | @Override 74 | public BitArray copy() { 75 | return new Pow2BitArray(this.version, this.size, Arrays.copyOf(this.words, this.words.length)); 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerInteractEntityPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerInteractEntityPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.protocol.bedrock.data.inventory.TransactionType; 8 | import com.nukkitx.protocol.bedrock.packet.InteractPacket; 9 | import com.nukkitx.protocol.bedrock.packet.InventoryTransactionPacket; 10 | import me.liuli.ez4h.minecraft.Client; 11 | import me.liuli.ez4h.translators.JavaTranslator; 12 | 13 | public class ClientPlayerInteractEntityPacketTranslator implements JavaTranslator { 14 | @Override 15 | public void translate(Packet inPacket, Client client) { 16 | ClientPlayerInteractEntityPacket packet = (ClientPlayerInteractEntityPacket) inPacket; 17 | switch (packet.getAction()) { 18 | case INTERACT_AT: 19 | case INTERACT: { 20 | InteractPacket interactPacket = new InteractPacket(); 21 | interactPacket.setAction(InteractPacket.Action.INTERACT); 22 | interactPacket.setRuntimeEntityId(packet.getEntityId()); 23 | interactPacket.setMousePosition(Vector3f.ZERO); 24 | client.sendPacket(interactPacket); 25 | break; 26 | } 27 | case ATTACK: { 28 | InventoryTransactionPacket inventoryTransactionPacket = new InventoryTransactionPacket(); 29 | inventoryTransactionPacket.setTransactionType(TransactionType.ITEM_USE_ON_ENTITY); 30 | inventoryTransactionPacket.setActionType(1); 31 | inventoryTransactionPacket.setRuntimeEntityId(packet.getEntityId()); 32 | inventoryTransactionPacket.setHotbarSlot(client.getInventory().getHandSlot()); 33 | inventoryTransactionPacket.setItemInHand(client.getInventory().getBedrockItemInHand()); 34 | inventoryTransactionPacket.setPlayerPosition(client.getPlayer().getVec3Location()); 35 | inventoryTransactionPacket.setClickPosition(Vector3f.ZERO); 36 | client.sendPacket(inventoryTransactionPacket); 37 | break; 38 | } 39 | } 40 | } 41 | 42 | @Override 43 | public Class getPacketClass() { 44 | return ClientPlayerInteractEntityPacket.class; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/command/commands/StatusCommand.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers.command.commands; 2 | 3 | import me.liuli.ez4h.EZ4H; 4 | import me.liuli.ez4h.managers.command.CommandBase; 5 | import me.liuli.ez4h.minecraft.Client; 6 | 7 | import java.util.concurrent.TimeUnit; 8 | 9 | public class StatusCommand implements CommandBase { 10 | @Override 11 | public String getCommandName() { 12 | return "status"; 13 | } 14 | 15 | @Override 16 | public String getHelpMessage() { 17 | return "Show EZ4H status"; 18 | } 19 | 20 | @Override 21 | public void exec(String[] args, Client client) { 22 | client.sendMessage("§a---- §fServer status §a----"); 23 | long time = System.currentTimeMillis() - EZ4H.getStartTime(); 24 | client.sendMessage("§bUptime: " + formatUptime(time)); 25 | client.sendMessage("§bThread count: §a" + Thread.getAllStackTraces().size()); 26 | 27 | Runtime runtime = Runtime.getRuntime(); 28 | long totalMB = Math.round(((double) runtime.totalMemory()) / 1024 / 1024); 29 | long usedMB = Math.round((double) (runtime.totalMemory() - runtime.freeMemory()) / 1024 / 1024); 30 | long maxMB = Math.round(((double) runtime.maxMemory()) / 1024 / 1024); 31 | int usage = (int) (((double) usedMB) / ((double) totalMB) * 100D); 32 | String usageColor = "§a"; 33 | if (usage > 85) { 34 | usageColor = "§c"; 35 | } else if (usage > 60) { 36 | usageColor = "§e"; 37 | } 38 | client.sendMessage("§bUsed memory: " + usageColor + usedMB + " MB. (" + usage + "%)"); 39 | client.sendMessage("§bTotal memory: §c" + totalMB + " MB."); 40 | client.sendMessage("§bMaximum VM memory: §c" + maxMB + " MB."); 41 | client.sendMessage("§bAvailable processors: §a" + runtime.availableProcessors()); 42 | client.sendMessage("§bPlayers: §a" + EZ4H.getOnlinePlayers() + " online."); 43 | } 44 | 45 | private String formatUptime(long uptime) { 46 | long days = TimeUnit.MILLISECONDS.toDays(uptime); 47 | uptime -= TimeUnit.DAYS.toMillis(days); 48 | long hours = TimeUnit.MILLISECONDS.toHours(uptime); 49 | uptime -= TimeUnit.HOURS.toMillis(hours); 50 | long minutes = TimeUnit.MILLISECONDS.toMinutes(uptime); 51 | uptime -= TimeUnit.MINUTES.toMillis(minutes); 52 | long seconds = TimeUnit.MILLISECONDS.toSeconds(uptime); 53 | return String.format("§c%d§e days §c%d§e hours §c%d§e minutes §c%d§e seconds", days, hours, minutes, seconds); 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/LocaleManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import com.alibaba.fastjson.JSONArray; 4 | import me.liuli.ez4h.EZ4H; 5 | import me.liuli.ez4h.minecraft.data.play.MCLocale; 6 | import me.liuli.ez4h.utils.FileUtil; 7 | 8 | import javax.net.ssl.HttpsURLConnection; 9 | import java.io.File; 10 | import java.net.URL; 11 | import java.util.HashMap; 12 | import java.util.Map; 13 | 14 | public class LocaleManager { 15 | private static final String baseURL="https://project-ez4h.github.io/MCLanguage/"; 16 | private static final String defaultLocale="zh_cn"; 17 | 18 | private final Map locales=new HashMap<>(); 19 | 20 | public LocaleManager(){ 21 | //update/download locale 22 | if(EZ4H.getConfigManager().isUpdateLocale()) { 23 | try { 24 | EZ4H.getLogger().info("Updating locale data..."); 25 | JSONArray localeData = JSONArray.parseArray(FileUtil.httpsGet(baseURL + "list.json")); 26 | for (Object obj : localeData) { 27 | String name = (String) obj; 28 | if (!new File("./data/locale/" + name).exists()) { 29 | EZ4H.getLogger().info("Downloading Locale \"" + name + "\"..."); 30 | HttpsURLConnection connection = (HttpsURLConnection) new URL(baseURL + name + ".gz").openConnection(); 31 | connection.setRequestMethod("GET"); 32 | connection.connect(); 33 | String data = FileUtil.uncompressGzip(connection.getInputStream()); 34 | FileUtil.writeFile("./data/locale/" + name, data); 35 | EZ4H.getLogger().info("Locale \"" + name + "\" Downloaded."); 36 | } 37 | } 38 | } catch (Exception e) { 39 | e.printStackTrace(); 40 | } 41 | } 42 | //load locales 43 | File localeDir = new File("./data/locale/"); 44 | for(File file:localeDir.listFiles()){ 45 | if(file.isFile()){ 46 | locales.put(file.getName().split("\\.")[0],new MCLocale(FileUtil.readFile(file))); 47 | } 48 | } 49 | EZ4H.getLogger().info(locales.size()+" locales loaded!"); 50 | } 51 | 52 | public MCLocale getDefaultLocale(){ 53 | return locales.get(defaultLocale); 54 | } 55 | 56 | public MCLocale getLocale(String localeName){ 57 | MCLocale mcLocale=locales.get(localeName); 58 | if(mcLocale==null){ 59 | mcLocale=getDefaultLocale(); 60 | } 61 | return mcLocale; 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/ConfigManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.github.steveice10.mc.protocol.data.message.TextMessage; 5 | import lombok.Getter; 6 | import me.liuli.ez4h.EZ4H; 7 | import me.liuli.ez4h.utils.OtherUtil; 8 | 9 | import javax.imageio.ImageIO; 10 | import java.awt.*; 11 | import java.awt.geom.AffineTransform; 12 | import java.awt.image.AffineTransformOp; 13 | import java.awt.image.BufferedImage; 14 | import java.awt.image.ImageObserver; 15 | import java.io.File; 16 | import java.io.FileInputStream; 17 | import java.io.InputStream; 18 | import java.net.URL; 19 | 20 | public class ConfigManager { 21 | @Getter 22 | private final JSONObject config; 23 | @Getter 24 | private final String javaHost; 25 | @Getter 26 | private final int javaPort; 27 | @Getter 28 | private final String bedrockHost; 29 | @Getter 30 | private final int bedrockPort; 31 | @Getter 32 | private final boolean xboxAuth; 33 | @Getter 34 | private final boolean autoLogin; 35 | @Getter 36 | private final boolean updateLocale; 37 | @Getter 38 | private final TextMessage playerList; 39 | @Getter 40 | private BufferedImage serverIcon=null; 41 | 42 | public ConfigManager(JSONObject json) { 43 | config = json; 44 | 45 | javaHost = json.getString("je-host"); 46 | javaPort = json.getInteger("je-port"); 47 | bedrockHost = json.getString("be-host"); 48 | bedrockPort = json.getInteger("be-port"); 49 | playerList = new TextMessage(json.getString("player-list")); 50 | 51 | JSONObject auth = json.getJSONObject("auth"); 52 | autoLogin = auth.getBoolean("auto-login"); 53 | xboxAuth = auth.getBoolean("xbox-auth"); 54 | // mojangSkin=advanced.getBoolean("mojang-skin"); 55 | 56 | JSONObject advanced = json.getJSONObject("advanced"); 57 | updateLocale = advanced.getBoolean("update-locale"); 58 | 59 | EZ4H.setDebugManager(new DebugManager(json.getJSONObject("debug"))); 60 | 61 | try { 62 | BufferedImage rawImage = ImageIO.read(new File("./data/icon.png")); 63 | if(rawImage.getType()!=6||rawImage.getWidth()!=64||rawImage.getHeight()!=64){ 64 | EZ4H.getLogger().info("Icon not usable (type="+rawImage.getType()+",width="+rawImage.getWidth() 65 | +",height="+rawImage.getHeight()+") converting..."); 66 | rawImage=OtherUtil.compressImage(rawImage,64,64); 67 | } 68 | serverIcon=rawImage; 69 | } catch (Exception e) { 70 | e.printStackTrace(); 71 | } 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/world/BossEventPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.world; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.BossBarAction; 4 | import com.github.steveice10.mc.protocol.data.game.BossBarColor; 5 | import com.github.steveice10.mc.protocol.data.game.BossBarDivision; 6 | import com.github.steveice10.mc.protocol.data.message.TextMessage; 7 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerBossBarPacket; 8 | import com.nukkitx.protocol.bedrock.BedrockPacket; 9 | import com.nukkitx.protocol.bedrock.packet.BossEventPacket; 10 | import me.liuli.ez4h.minecraft.Client; 11 | import me.liuli.ez4h.translators.BedrockTranslator; 12 | import me.liuli.ez4h.utils.BedrockUtil; 13 | import me.liuli.ez4h.utils.OtherUtil; 14 | 15 | import java.util.UUID; 16 | 17 | public class BossEventPacketTranslator implements BedrockTranslator { 18 | private final BossBarColor[] colors = BossBarColor.values(); 19 | 20 | @Override 21 | public boolean needOrder() { 22 | return true; 23 | } 24 | 25 | @Override 26 | public void translate(BedrockPacket inPacket, Client client) { 27 | BossEventPacket packet = (BossEventPacket) inPacket; 28 | UUID uuid = UUID.nameUUIDFromBytes(String.valueOf(packet.getBossUniqueEntityId()).getBytes()); 29 | String title = BedrockUtil.lengthCutter(packet.getTitle(), 40); 30 | switch (packet.getAction()) { 31 | case CREATE: { 32 | client.sendPacket(new ServerBossBarPacket(uuid, BossBarAction.ADD, new TextMessage(title), packet.getHealthPercentage(), getColor(packet.getColor()), BossBarDivision.NONE, OtherUtil.intToBool(packet.getDarkenSky(), false), false)); 33 | break; 34 | } 35 | case REMOVE: { 36 | client.sendPacket(new ServerBossBarPacket(uuid)); 37 | break; 38 | } 39 | case UPDATE_PERCENTAGE: { 40 | client.sendPacket(new ServerBossBarPacket(uuid, BossBarAction.UPDATE_HEALTH, packet.getHealthPercentage())); 41 | break; 42 | } 43 | case UPDATE_NAME: { 44 | client.sendPacket(new ServerBossBarPacket(uuid, BossBarAction.UPDATE_TITLE, new TextMessage(title))); 45 | break; 46 | } 47 | } 48 | } 49 | 50 | private BossBarColor getColor(int color) { 51 | if (color < colors.length) { 52 | return colors[color]; 53 | } else { 54 | return BossBarColor.PURPLE; 55 | } 56 | } 57 | 58 | @Override 59 | public Class getPacketClass() { 60 | return BossEventPacket.class; 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/RespawnPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.world.WorldType; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerRespawnPacket; 5 | import com.nukkitx.math.vector.Vector3f; 6 | import com.nukkitx.math.vector.Vector3i; 7 | import com.nukkitx.protocol.bedrock.BedrockPacket; 8 | import com.nukkitx.protocol.bedrock.data.PlayerActionType; 9 | import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket; 10 | import com.nukkitx.protocol.bedrock.packet.PlayerActionPacket; 11 | import com.nukkitx.protocol.bedrock.packet.RespawnPacket; 12 | import me.liuli.ez4h.minecraft.Client; 13 | import me.liuli.ez4h.translators.BedrockTranslator; 14 | 15 | public class RespawnPacketTranslator implements BedrockTranslator { 16 | @Override 17 | public void translate(BedrockPacket inPacket, Client client) { 18 | RespawnPacket packet = (RespawnPacket) inPacket; 19 | switch (packet.getState()) { 20 | case SERVER_SEARCHING: { 21 | // client.sendPacket(new ServerPlayerHealthPacket(0,client.getPlayer().getFood(),0)); 22 | break; 23 | } 24 | case SERVER_READY: { 25 | PlayerActionPacket playerActionPacket = new PlayerActionPacket(); 26 | playerActionPacket.setAction(PlayerActionType.RESPAWN); 27 | playerActionPacket.setFace(-1); 28 | playerActionPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 29 | playerActionPacket.setBlockPosition(Vector3i.from(0, 0, 0)); 30 | client.sendPacket(playerActionPacket); 31 | client.sendPacket(new ServerRespawnPacket(client.getPlayer().getDimension(), client.getPlayer().getDifficulty(), client.getPlayer().getGameMode(), WorldType.DEFAULT)); 32 | MovePlayerPacket movePlayerPacket = new MovePlayerPacket(); 33 | movePlayerPacket.setMode(MovePlayerPacket.Mode.RESPAWN); 34 | movePlayerPacket.setOnGround(true); 35 | movePlayerPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 36 | movePlayerPacket.setRidingRuntimeEntityId(0); 37 | Vector3f position = packet.getPosition(); 38 | movePlayerPacket.setPosition(Vector3f.from(position.getX(), position.getY(), position.getZ())); 39 | movePlayerPacket.setRotation(Vector3f.from(0, 0, 0)); 40 | client.sendPacket(movePlayerPacket); 41 | break; 42 | } 43 | } 44 | } 45 | 46 | @Override 47 | public Class getPacketClass() { 48 | return RespawnPacket.class; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/world/Weather.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.world; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.world.notify.ClientNotification; 4 | import com.github.steveice10.mc.protocol.data.game.world.notify.RainStrengthValue; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerNotifyClientPacket; 6 | import lombok.Getter; 7 | import me.liuli.ez4h.minecraft.Client; 8 | 9 | public class Weather { 10 | private final Client client; 11 | @Getter 12 | private int weather; 13 | 14 | public Weather(Client client) { 15 | this.client = client; 16 | } 17 | 18 | public void setWeather(int weather) { 19 | switch (weather) { 20 | case 0: { 21 | if (this.weather == 2) { 22 | changeWeatherToClient(0, true); 23 | } else if (this.weather == 1) { 24 | changeWeatherToClient(0, false); 25 | } 26 | break; 27 | } 28 | case 1: { 29 | changeWeatherToClient(1, false); 30 | break; 31 | } 32 | case 2: { 33 | changeWeatherToClient(1, true); 34 | break; 35 | } 36 | } 37 | this.weather = weather; 38 | } 39 | 40 | private void changeWeatherToClient(float to, boolean isThunder) { 41 | WeatherThread weatherThread = new WeatherThread(); 42 | weatherThread.isThunder = isThunder; 43 | weatherThread.to = to; 44 | weatherThread.client = client; 45 | Thread thread = new Thread(weatherThread); 46 | thread.start(); 47 | } 48 | } 49 | 50 | class WeatherThread implements Runnable { 51 | public boolean isThunder, mode = false;//mode true plus,false minus 52 | public Client client; 53 | public float to; 54 | 55 | public void run() { 56 | try { 57 | if (to == 1) { 58 | mode = true; 59 | to = 0; 60 | } else { 61 | to = 1; 62 | } 63 | for (int i = 0; i < 40; i++) { 64 | if (mode) { 65 | to += 0.025; 66 | } else { 67 | to -= 0.025; 68 | } 69 | if (isThunder) { 70 | client.sendPacket(new ServerNotifyClientPacket(ClientNotification.THUNDER_STRENGTH, new RainStrengthValue(to))); 71 | } 72 | client.sendPacket(new ServerNotifyClientPacket(ClientNotification.RAIN_STRENGTH, new RainStrengthValue(to))); 73 | Thread.sleep(100); 74 | } 75 | } catch (InterruptedException e) { 76 | e.printStackTrace(); 77 | } 78 | } 79 | } -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientChatPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.ClientChatPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.protocol.bedrock.data.command.CommandOriginData; 7 | import com.nukkitx.protocol.bedrock.data.command.CommandOriginType; 8 | import com.nukkitx.protocol.bedrock.packet.CommandRequestPacket; 9 | import com.nukkitx.protocol.bedrock.packet.TextPacket; 10 | import me.liuli.ez4h.EZ4H; 11 | import me.liuli.ez4h.minecraft.Client; 12 | import me.liuli.ez4h.translators.JavaTranslator; 13 | 14 | import java.util.ArrayList; 15 | import java.util.List; 16 | 17 | public class ClientChatPacketTranslator implements JavaTranslator { 18 | @Override 19 | public void translate(Packet inPacket, Client client) { 20 | ClientChatPacket packet = (ClientChatPacket) inPacket; 21 | Character firstChar = packet.getMessage().charAt(0); 22 | if (firstChar.equals('/')) { 23 | CommandRequestPacket commandRequestPacket = new CommandRequestPacket(); 24 | commandRequestPacket.setInternal(false); 25 | commandRequestPacket.setCommand(packet.getMessage()); 26 | commandRequestPacket.setCommandOriginData(new CommandOriginData(CommandOriginType.PLAYER, client.getPlayer().getUuid(), "", 0)); 27 | client.sendPacket(commandRequestPacket); 28 | } else if (firstChar.equals('`')) { 29 | if (packet.getMessage().length() > 1) { 30 | String[] commandList = packet.getMessage().substring(1).split(" "), argsList = new String[commandList.length - 1]; 31 | if (commandList.length != 1) { 32 | for (int i = 1; i < commandList.length; i++) { 33 | argsList[i - 1] = commandList[i]; 34 | } 35 | } 36 | EZ4H.getCommandManager().runCommand(commandList[0], argsList, client); 37 | } 38 | } else { 39 | TextPacket textPacket = new TextPacket(); 40 | textPacket.setMessage(packet.getMessage()); 41 | textPacket.setType(TextPacket.Type.CHAT); 42 | textPacket.setNeedsTranslation(false); 43 | textPacket.setXuid(client.getPlayer().getXuid()); 44 | textPacket.setPlatformChatId(""); 45 | List para = new ArrayList<>(); 46 | textPacket.setParameters(para); 47 | textPacket.setSourceName(client.getPlayer().getName()); 48 | client.sendPacket(textPacket); 49 | } 50 | } 51 | 52 | @Override 53 | public Class getPacketClass() { 54 | return ClientChatPacket.class; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerPositionRotationPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerPositionRotationPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.math.vector.Vector3i; 8 | import com.nukkitx.protocol.bedrock.data.PlayerActionType; 9 | import com.nukkitx.protocol.bedrock.packet.MovePlayerPacket; 10 | import com.nukkitx.protocol.bedrock.packet.PlayerActionPacket; 11 | import me.liuli.ez4h.minecraft.Client; 12 | import me.liuli.ez4h.translators.JavaTranslator; 13 | 14 | public class ClientPlayerPositionRotationPacketTranslator implements JavaTranslator { 15 | public static void playerGround(Client client, boolean onGround) { 16 | if (!onGround && client.getData().isJumpTiming()) { 17 | PlayerActionPacket playerActionPacket = new PlayerActionPacket(); 18 | playerActionPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 19 | playerActionPacket.setAction(PlayerActionType.JUMP); 20 | playerActionPacket.setBlockPosition(Vector3i.ZERO); 21 | playerActionPacket.setFace(0); 22 | client.sendPacket(playerActionPacket); 23 | client.getData().setJumpTiming(false); 24 | } 25 | if (onGround) { 26 | client.getData().setJumpTiming(true); 27 | } 28 | } 29 | 30 | @Override 31 | public void translate(Packet inPacket, Client client) { 32 | ClientPlayerPositionRotationPacket packet = (ClientPlayerPositionRotationPacket) inPacket; 33 | MovePlayerPacket movePlayerPacket = new MovePlayerPacket(); 34 | movePlayerPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 35 | movePlayerPacket.setPosition(client.getPlayer().getVec3Location()); 36 | movePlayerPacket.setRotation(Vector3f.from(packet.getPitch(), packet.getYaw(), packet.getYaw())); 37 | movePlayerPacket.setMode(MovePlayerPacket.Mode.NORMAL); 38 | movePlayerPacket.setOnGround(packet.isOnGround()); 39 | movePlayerPacket.setRidingRuntimeEntityId(0); 40 | movePlayerPacket.setTeleportationCause(MovePlayerPacket.TeleportationCause.UNKNOWN); 41 | movePlayerPacket.setEntityType(0); 42 | client.sendPacket(movePlayerPacket); 43 | client.getPlayer().setPosition(packet.getX(), packet.getY(), packet.getZ()); 44 | client.getPlayer().setRotation(packet.getYaw(), packet.getPitch()); 45 | playerGround(client, packet.isOnGround()); 46 | } 47 | 48 | @Override 49 | public Class getPacketClass() { 50 | return ClientPlayerPositionRotationPacket.class; 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/JavaPacketHandler.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft; 2 | 3 | import com.github.steveice10.mc.auth.data.GameProfile; 4 | import com.github.steveice10.mc.protocol.MinecraftConstants; 5 | import com.github.steveice10.mc.protocol.MinecraftProtocol; 6 | import com.github.steveice10.mc.protocol.data.SubProtocol; 7 | import com.github.steveice10.mc.protocol.packet.login.client.LoginStartPacket; 8 | import com.github.steveice10.mc.protocol.packet.status.client.StatusPingPacket; 9 | import com.github.steveice10.mc.protocol.packet.status.client.StatusQueryPacket; 10 | import com.github.steveice10.mc.protocol.packet.status.server.StatusPongPacket; 11 | import com.github.steveice10.packetlib.event.session.PacketReceivedEvent; 12 | import com.github.steveice10.packetlib.event.session.SessionAdapter; 13 | import com.github.steveice10.packetlib.packet.Packet; 14 | import me.liuli.ez4h.EZ4H; 15 | import me.liuli.ez4h.utils.OtherUtil; 16 | 17 | public class JavaPacketHandler extends SessionAdapter { 18 | @Override 19 | public void packetReceived(PacketReceivedEvent event) { 20 | try { 21 | Packet packet = event.getPacket(); 22 | if (((MinecraftProtocol) event.getSession().getPacketProtocol()).getSubProtocol() == SubProtocol.STATUS) { 23 | if (packet instanceof StatusQueryPacket) { 24 | new Ping(event.getSession()); 25 | } else if (packet instanceof StatusPingPacket) { 26 | event.getSession().send(new StatusPongPacket(event.getPacket().getPingTime())); 27 | } 28 | return; 29 | } 30 | GameProfile profile = event.getSession().getFlag(MinecraftConstants.PROFILE_KEY); 31 | Client client = null; 32 | if (!OtherUtil.isNull(profile)) { 33 | client = EZ4H.getClient(profile.getName()); 34 | } 35 | if (event.getPacket().getClass().equals(LoginStartPacket.class)) { 36 | LoginStartPacket lpacket = event.getPacket(); 37 | if (!EZ4H.getConfigManager().isXboxAuth() || EZ4H.getAuthManager().getAccessTokens().containsKey(lpacket.getUsername())) { 38 | Client client_n = new Client(event, lpacket.getUsername()); 39 | EZ4H.addClient(lpacket.getUsername(), client_n); 40 | } else { 41 | event.getSession().removeListener(this); 42 | } 43 | EZ4H.getLogger().info(lpacket.getUsername() + "[" + event.getSession().getHost() + ":" + event.getSession().getPort() + "] JOINED."); 44 | } else { 45 | if (client != null) { 46 | client.addPacket(packet); 47 | } 48 | } 49 | } catch (Exception e) { 50 | e.printStackTrace(); 51 | } 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/AddPlayerPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.github.steveice10.mc.auth.data.GameProfile; 4 | import com.github.steveice10.mc.protocol.data.game.PlayerListEntry; 5 | import com.github.steveice10.mc.protocol.data.game.PlayerListEntryAction; 6 | import com.github.steveice10.mc.protocol.data.game.entity.EquipmentSlot; 7 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.EntityMetadata; 8 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 9 | import com.github.steveice10.mc.protocol.data.message.TextMessage; 10 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerPlayerListEntryPacket; 11 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityEquipmentPacket; 12 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.spawn.ServerSpawnPlayerPacket; 13 | import com.nukkitx.math.vector.Vector3f; 14 | import com.nukkitx.protocol.bedrock.BedrockPacket; 15 | import com.nukkitx.protocol.bedrock.data.entity.EntityData; 16 | import com.nukkitx.protocol.bedrock.packet.AddPlayerPacket; 17 | import me.liuli.ez4h.EZ4H; 18 | import me.liuli.ez4h.minecraft.Client; 19 | import me.liuli.ez4h.minecraft.data.entity.Entity; 20 | import me.liuli.ez4h.translators.BedrockTranslator; 21 | import me.liuli.ez4h.utils.BedrockUtil; 22 | 23 | public class AddPlayerPacketTranslator implements BedrockTranslator { 24 | @Override 25 | public void translate(BedrockPacket inPacket, Client client) { 26 | AddPlayerPacket packet = (AddPlayerPacket) inPacket; 27 | 28 | GameProfile gameProfile = new GameProfile(packet.getUuid(), BedrockUtil.lengthCutter(packet.getUsername(), 16)); 29 | client.sendPacket(new ServerPlayerListEntryPacket(PlayerListEntryAction.ADD_PLAYER, new PlayerListEntry[]{new PlayerListEntry(gameProfile, GameMode.SURVIVAL, 0, new TextMessage(BedrockUtil.lengthCutter(packet.getMetadata().getString(EntityData.NAMETAG), 16)))})); 30 | 31 | Vector3f position = packet.getPosition(), rotation = packet.getRotation(); 32 | client.getData().addEntity((int) packet.getRuntimeEntityId(), new Entity(position.getX(), position.getY(), position.getZ(), (int) packet.getRuntimeEntityId(), Entity.Type.PLAYER)); 33 | client.sendPacket(new ServerSpawnPlayerPacket((int) packet.getRuntimeEntityId(), packet.getUuid(), position.getX(), position.getY(), position.getZ(), rotation.getY(), rotation.getX(), new EntityMetadata[]{})); 34 | client.sendPacket(new ServerEntityEquipmentPacket((int) packet.getRuntimeEntityId(), EquipmentSlot.MAIN_HAND, EZ4H.getConverterManager().getItemConverter().convertToJE(packet.getHand()))); 35 | EZ4H.getConverterManager().getMetadataConverter().convert(packet.getMetadata(), client, (int) packet.getRuntimeEntityId()); 36 | } 37 | 38 | 39 | @Override 40 | public Class getPacketClass() { 41 | return AddPlayerPacket.class; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/auth/JoseStuff.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.auth; 2 | 3 | import java.security.SignatureException; 4 | 5 | //edited from, https://github.com/auth0/java-jwt/blob/master/lib/src/main/java/com/auth0/jwt/algorithms/ECDSAAlgorithm.java 6 | /* 7 | * this is probably similar to ECDSA.transcodeSignatureToConcat, but I found this before I found that, and I don't care 8 | * to check if the ECDSA one works, this works and that's fine. But for an example ECDSASigner.sign 9 | */ 10 | public class JoseStuff { 11 | 12 | public static byte[] DERToJOSE(byte[] derSignature, AlgorithmType algorithmType) throws SignatureException { 13 | // DER Structure: http://crypto.stackexchange.com/a/1797 14 | boolean derEncoded = derSignature[0] == 0x30 && derSignature.length != algorithmType.ecNumberSize * 2; 15 | if (!derEncoded) { 16 | throw new SignatureException("Invalid DER signature format."); 17 | } 18 | 19 | final byte[] joseSignature = new byte[algorithmType.ecNumberSize * 2]; 20 | 21 | //Skip 0x30 22 | int offset = 1; 23 | if (derSignature[1] == (byte) 0x81) { 24 | //Skip sign 25 | offset++; 26 | } 27 | 28 | //Convert to unsigned. Should match DER length - offset 29 | int encodedLength = derSignature[offset++] & 0xff; 30 | if (encodedLength != derSignature.length - offset) { 31 | throw new SignatureException("Invalid DER signature format."); 32 | } 33 | 34 | //Skip 0x02 35 | offset++; 36 | 37 | //Obtain R number length (Includes padding) and skip it 38 | int rLength = derSignature[offset++]; 39 | if (rLength > algorithmType.ecNumberSize + 1) { 40 | throw new SignatureException("Invalid DER signature format."); 41 | } 42 | int rPadding = algorithmType.ecNumberSize - rLength; 43 | //Retrieve R number 44 | System.arraycopy(derSignature, offset + Math.max(-rPadding, 0), joseSignature, Math.max(rPadding, 0), rLength + Math.min(rPadding, 0)); 45 | 46 | //Skip R number and 0x02 47 | offset += rLength + 1; 48 | 49 | //Obtain S number length. (Includes padding) 50 | int sLength = derSignature[offset++]; 51 | if (sLength > algorithmType.ecNumberSize + 1) { 52 | throw new SignatureException("Invalid DER signature format."); 53 | } 54 | int sPadding = algorithmType.ecNumberSize - sLength; 55 | //Retrieve R number 56 | System.arraycopy(derSignature, offset + Math.max(-sPadding, 0), joseSignature, algorithmType.ecNumberSize + Math.max(sPadding, 0), sLength + Math.min(sPadding, 0)); 57 | 58 | return joseSignature; 59 | } 60 | 61 | public enum AlgorithmType { 62 | ECDSA256(32), ECDSA384(48); 63 | 64 | public int ecNumberSize; 65 | 66 | AlgorithmType(int ecNumberSize) { 67 | this.ecNumberSize = ecNumberSize; 68 | } 69 | 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerStatePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerStatePacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3i; 7 | import com.nukkitx.protocol.bedrock.data.PlayerActionType; 8 | import com.nukkitx.protocol.bedrock.packet.PlayerActionPacket; 9 | import me.liuli.ez4h.minecraft.Client; 10 | import me.liuli.ez4h.translators.JavaTranslator; 11 | 12 | public class ClientPlayerStatePacketTranslator implements JavaTranslator { 13 | @Override 14 | public void translate(Packet inPacket, Client client) { 15 | ClientPlayerStatePacket packet = (ClientPlayerStatePacket) inPacket; 16 | switch (packet.getState()) { 17 | case START_SNEAKING: { 18 | PlayerActionPacket playerActionPacket = new PlayerActionPacket(); 19 | playerActionPacket.setAction(PlayerActionType.START_SNEAK); 20 | playerActionPacket.setBlockPosition(Vector3i.ZERO); 21 | playerActionPacket.setFace(0); 22 | playerActionPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 23 | client.sendPacket(playerActionPacket); 24 | break; 25 | } 26 | case STOP_SNEAKING: { 27 | PlayerActionPacket playerActionPacket = new PlayerActionPacket(); 28 | playerActionPacket.setAction(PlayerActionType.STOP_SNEAK); 29 | playerActionPacket.setBlockPosition(Vector3i.ZERO); 30 | playerActionPacket.setFace(0); 31 | playerActionPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 32 | client.sendPacket(playerActionPacket); 33 | break; 34 | } 35 | case START_SPRINTING: { 36 | PlayerActionPacket playerActionPacket = new PlayerActionPacket(); 37 | playerActionPacket.setAction(PlayerActionType.START_SPRINT); 38 | playerActionPacket.setBlockPosition(Vector3i.ZERO); 39 | playerActionPacket.setFace(0); 40 | playerActionPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 41 | client.sendPacket(playerActionPacket); 42 | break; 43 | } 44 | case STOP_SPRINTING: { 45 | PlayerActionPacket playerActionPacket = new PlayerActionPacket(); 46 | playerActionPacket.setAction(PlayerActionType.STOP_SPRINT); 47 | playerActionPacket.setBlockPosition(Vector3i.ZERO); 48 | playerActionPacket.setFace(0); 49 | playerActionPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 50 | client.sendPacket(playerActionPacket); 51 | break; 52 | } 53 | } 54 | } 55 | 56 | @Override 57 | public Class getPacketClass() { 58 | return ClientPlayerStatePacket.class; 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/play/ClientPlayerUseItemPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.play; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerUseItemPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.math.vector.Vector3f; 7 | import com.nukkitx.math.vector.Vector3i; 8 | import com.nukkitx.protocol.bedrock.data.inventory.TransactionType; 9 | import com.nukkitx.protocol.bedrock.packet.InventoryTransactionPacket; 10 | import me.liuli.ez4h.EZ4H; 11 | import me.liuli.ez4h.minecraft.Client; 12 | import me.liuli.ez4h.translators.JavaTranslator; 13 | 14 | public class ClientPlayerUseItemPacketTranslator implements JavaTranslator { 15 | @Override 16 | public void translate(Packet inPacket, Client client) { 17 | ClientPlayerUseItemPacket packet = (ClientPlayerUseItemPacket) inPacket; 18 | 19 | InventoryTransactionPacket inventoryTransactionPacket = new InventoryTransactionPacket(); 20 | inventoryTransactionPacket.setTransactionType(TransactionType.ITEM_USE); 21 | inventoryTransactionPacket.setActionType(1); 22 | inventoryTransactionPacket.setBlockPosition(Vector3i.ZERO); 23 | inventoryTransactionPacket.setBlockFace(255); 24 | inventoryTransactionPacket.setHotbarSlot(client.getInventory().getHandSlot()); 25 | inventoryTransactionPacket.setItemInHand(client.getInventory().getBedrockItemInHand()); 26 | inventoryTransactionPacket.setPlayerPosition(client.getPlayer().getVec3Location()); 27 | inventoryTransactionPacket.setClickPosition(Vector3f.ZERO); 28 | if (client.getPlayer().isUsingItem()) { 29 | inventoryTransactionPacket.setTransactionType(TransactionType.ITEM_RELEASE); 30 | //InventoryTransactionPacket(transactionType=4, actions=[NetworkInventoryAction(sourceType=0, windowId=0, unknown=0, inventorySlot=1, oldItem=Item Arrow (262:0)x63, newItem=Item Arrow (262:0)x62, stackNetworkId=0), NetworkInventoryAction(sourceType=0, windowId=0, unknown=0, inventorySlot=0, oldItem=Item Bow (261:1)x1, newItem=Item Bow (261:2)x1, stackNetworkId=0)], 31 | // transactionData=ReleaseItemData(actionType=0, hotbarSlot=0, itemInHand=Item Bow (261:1)x1, headRot=Vector3(x=-23.347400665283203,y=67.62000274658203,z=15.72659969329834)), hasNetworkIds=false, legacyRequestId=-46, isCraftingPart=false, isEnchantingPart=false) 32 | inventoryTransactionPacket.setLegacyRequestId(-46); 33 | inventoryTransactionPacket.setActionType(0); 34 | inventoryTransactionPacket.setHeadPosition(client.getPlayer().getHeadRotation()); 35 | client.getPlayer().setUsingItem(false); 36 | return; 37 | } else if (EZ4H.getConverterManager().getItemConverter().isUseableItem(client.getInventory().getBedrockItemInHand())) { 38 | client.getPlayer().setUsingItem(true); 39 | } 40 | client.sendPacket(inventoryTransactionPacket); 41 | } 42 | 43 | @Override 44 | public Class getPacketClass() { 45 | return ClientPlayerUseItemPacket.class; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Project discontinued. 2 | 3 | # EZ4H [![releases](https://img.shields.io/github/v/release/opZywl/EZ4H?display_name=tag&color=%231ab1ad)](https://github.com/opZywl/EZ4H/releases) [![players](https://img.shields.io/bstats/players/10109)](https://bstats.org/plugin/bukkit/EZ4H/10109) [![servers](https://img.shields.io/bstats/servers/10109)](https://bstats.org/plugin/bukkit/EZ4H/10109) [![license](https://img.shields.io/github/license/opZywl/EZ4H)](https://github.com/opZywl/EZ4H/blob/main/LICENSE) 4 | 5 | EZ4H is a bridge/proxy between Minecraft: JE and Minecraft: BE, which allows JE-clients (1.12.2) to connect to BE-servers (1.16.210) . 6 | 7 | ## 🎉Features 8 | - [x] Login 9 | - [x] Chat 10 | - [x] Command 11 | - [X] Xbox Auth 12 | - [X] Chunks 13 | - [X] Move 14 | - [X] Players 15 | - [X] Entitys 16 | - [X] Block Entitys 17 | - [X] Item Entitys 18 | - [X] Entity Metadata 19 | - [X] Entity Interact 20 | - [X] Block Interact 21 | - [X] Titles and other Messages 22 | - [X] Inventory Action 23 | - [ ] UIes 24 | - [ ] Particles 25 | - [x] Form UI 26 | - [X] Level Events 27 | - [ ] Sounds 28 | 29 | ## Credits 30 | It would basically be impossible to build EZ4H without these open-source projects, wheather its just looking how thing works inorder to reverse translate them, looking at their code to see how thing work or copying a little bit of their code. We apperiate all these projects. 31 | - [MCProtocolLib](https://github.com/Steveice10/MCProtocolLib) 32 | - [Bedrock-Protocol](https://github.com/CloudburstMC/Protocol) 33 | - [TunnelMC](https://github.com/THEREALWWEFAN231/TunnelMC) 34 | - [Nukkit](https://github.com/CloudburstMC/Nukkit/) 35 | 36 | # How to use? 37 | As with most servers written in Java, you need a startup `.BAT` to start it. 38 | ~~~ powershell 39 | @echo 40 | java -jar ez4h.jar 41 | pause 42 | ~~~ 43 | Double click to run it. 44 | When there is a `Done!` It was started successfully. 45 | 46 | After this, you will see some files generated under the EZ4H root directory. Let's open the `config.json` . 47 | 48 | ~~~json 49 | { 50 | "je_host": "127.0.0.1", 51 | "je_port": 25565, 52 | "be_host": "127.0.0.1", 53 | "be_port": 19132, 54 | "player-list": "A §bEZ§a4§bH§f§r Proxyed Server!\nhttps://github.com/opZywl/EZ4H", 55 | "advanced": { 56 | "debug": 0, 57 | "save-authdata": false, 58 | "xbox-auth": false 59 | } 60 | } 61 | ~~~ 62 | I think you already know how to configure this, but I'm going to go through it briefly. 63 | 64 | **`je_host` & `je_port`** are the local IP and port used by JE players to connect to the server, which can be configured according to needs. 65 | 66 | **`be_host` & `be_port`** are the IP and port of the desired BE server to connect to. EZ4H supports proxy external servers. You can fill in either the LAN IP, i.e. the local BE server address, or the IP of the online server to proxy the BE server you want to play on through EZ4H. 67 | 68 | **`player-list`** is the text content displayed when JE players press the tab key. 69 | 70 | **`xbox-auth`** indicates if xbox authentication is enabled. Turning it on prevents JE players from logging in offline, but introduces some restrictions; if set to false, you need to make sure the xbox authentication of the BE server you want to connect to is also off. 71 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/converters/BlockConverter.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.converters; 2 | 3 | import com.alibaba.fastjson.JSONArray; 4 | import com.alibaba.fastjson.JSONObject; 5 | import com.github.steveice10.mc.protocol.data.game.chunk.NibbleArray3d; 6 | import com.github.steveice10.mc.protocol.data.game.world.block.BlockState; 7 | import lombok.Getter; 8 | import me.liuli.ez4h.utils.BedrockUtil; 9 | 10 | import java.util.HashMap; 11 | import java.util.Map; 12 | 13 | public class BlockConverter { 14 | @Getter 15 | private final NibbleArray3d fullLight; 16 | @Getter 17 | private final NibbleArray3d noLight; 18 | 19 | private final Map blockStateMap = new HashMap<>(); 20 | private final Map blockLightMap = new HashMap<>(); 21 | private final JSONObject runtimeBlockMap; 22 | private final BlockState nullBlock = new BlockState(1, 0); 23 | 24 | public BlockConverter(JSONArray blockArray, JSONObject blockRuntimeData) { 25 | for (Object jsonObject : blockArray) { 26 | JSONObject json = (JSONObject) jsonObject; 27 | blockLightMap.put(json.getString("name"), json.getInteger("light")); 28 | blockStateMap.put(json.getString("name"), new BlockState(json.getInteger("id"), json.getInteger("meta"))); 29 | } 30 | runtimeBlockMap = blockRuntimeData; 31 | fullLight = new NibbleArray3d(4096); 32 | noLight = new NibbleArray3d(4096); 33 | for (int x = 0; x < 16; x++) { 34 | for (int y = 0; y < 16; y++) { 35 | for (int z = 0; z < 16; z++) { 36 | fullLight.set(x, y, z, 15); 37 | noLight.set(x, y, z, 0); 38 | } 39 | } 40 | } 41 | } 42 | 43 | public String getBedrockNameByRuntime(int runtime) { 44 | String result = (String) runtimeBlockMap.get(runtime); 45 | if (result == null) { 46 | result = "minecraft:stone[stone_type=stone]"; 47 | } 48 | return result; 49 | } 50 | 51 | public BlockState getBlockByName(String name) { 52 | BlockState result = blockStateMap.get(name); 53 | if (result == null) { 54 | result = nullBlock; 55 | } 56 | return result; 57 | } 58 | 59 | public int getBlockLightByName(String name) { 60 | Integer result = blockLightMap.get(name); 61 | if (result == null) { 62 | result = 0; 63 | } 64 | return result; 65 | } 66 | 67 | //TODO:Make this faster 68 | //Process time TOO LONG :( 69 | public void addLight(NibbleArray3d lightArray, int light, int X, int Y, int Z) { 70 | int posX = Math.max((X - light), 0), posXend = Math.min(X + light, 15), 71 | posY = Math.max((Y - light), 0), posYend = Math.min(Y + light, 15), 72 | posZ = Math.max((Z - light), 0), posZend = Math.min(Z + light, 15); 73 | for (int x = posX; x <= posXend; x++) { 74 | for (int y = posY; y <= posYend; y++) { 75 | for (int z = posZ; z <= posZend; z++) { 76 | int reLight = (int) Math.max(light - BedrockUtil.calcDistance(X, Y, Z, x, y, z), 0); 77 | if (lightArray.get(x, y, z) < reLight) { 78 | lightArray.set(x, y, z, reLight); 79 | } 80 | } 81 | } 82 | } 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/data/play/MCLocale.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.data.play; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.nukkitx.protocol.bedrock.packet.TextPacket; 5 | import lombok.Getter; 6 | 7 | public class MCLocale { 8 | @Getter 9 | private final JSONObject localeJSON; 10 | 11 | public MCLocale(String string){ 12 | localeJSON=JSONObject.parseObject(string); 13 | } 14 | 15 | public String translateMessage(TextPacket packet) { 16 | if (packet.isNeedsTranslation()) { 17 | String noColorMsg = colorTaker(packet.getMessage()); 18 | boolean has5 = false; 19 | if (noColorMsg.charAt(0) == '%') { 20 | packet.setNeedsTranslation(true); 21 | noColorMsg = noColorMsg.substring(1); 22 | has5 = true; 23 | } 24 | String converted = convertSingle(noColorMsg); 25 | int count = 1; 26 | for (String para : packet.getParameters()) { 27 | converted = converted.replaceAll("%" + count, para); 28 | count++; 29 | } 30 | if (has5) { 31 | noColorMsg = "%" + noColorMsg; 32 | } 33 | String conStr = packet.getMessage().replace(noColorMsg, converted); 34 | if (conStr.contains("%")) { 35 | String subConv = conStr.substring(conStr.indexOf("%") + 1); 36 | String needSubConvert = ""; 37 | for (String subList : subConv.split("")) { 38 | needSubConvert += subList; 39 | String subConverted = (String) localeJSON.get(needSubConvert); 40 | if (subConverted != null) { 41 | count = 1; 42 | for (String para : packet.getParameters()) { 43 | subConverted = subConverted.replaceAll("%" + count, para); 44 | count++; 45 | } 46 | conStr = conStr.replaceAll("%" + needSubConvert, subConverted); 47 | } 48 | } 49 | } 50 | return conStr; 51 | } 52 | return packet.getMessage(); 53 | } 54 | 55 | 56 | private String convertSingle(String msg) { 57 | String tr = (String) localeJSON.get(msg); 58 | if (tr == null) { 59 | return msg; 60 | } 61 | return tr; 62 | } 63 | 64 | private static String colorTaker(String msg) { 65 | return msg.replaceAll("§0", "") 66 | .replaceAll("§1", "") 67 | .replaceAll("§2", "") 68 | .replaceAll("§3", "") 69 | .replaceAll("§4", "") 70 | .replaceAll("§5", "") 71 | .replaceAll("§6", "") 72 | .replaceAll("§7", "") 73 | .replaceAll("§8", "") 74 | .replaceAll("§9", "") 75 | .replaceAll("§a", "") 76 | .replaceAll("§b", "") 77 | .replaceAll("§c", "") 78 | .replaceAll("§d", "") 79 | .replaceAll("§e", "") 80 | .replaceAll("§f", "") 81 | .replaceAll("§k", "") 82 | .replaceAll("§l", "") 83 | .replaceAll("§m", "") 84 | .replaceAll("§n", "") 85 | .replaceAll("§o", "") 86 | .replaceAll("§r", ""); 87 | } 88 | } 89 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/window/InventoryContentPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.window; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.ItemStack; 4 | import com.github.steveice10.mc.protocol.packet.ingame.server.window.ServerOpenWindowPacket; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.window.ServerWindowItemsPacket; 6 | import com.nukkitx.protocol.bedrock.BedrockPacket; 7 | import com.nukkitx.protocol.bedrock.data.inventory.ItemData; 8 | import com.nukkitx.protocol.bedrock.packet.InventoryContentPacket; 9 | import me.liuli.ez4h.EZ4H; 10 | import me.liuli.ez4h.minecraft.Client; 11 | import me.liuli.ez4h.minecraft.data.world.ChestData; 12 | import me.liuli.ez4h.translators.BedrockTranslator; 13 | import me.liuli.ez4h.translators.converters.ItemConverter; 14 | 15 | import java.util.ArrayList; 16 | import java.util.Arrays; 17 | import java.util.List; 18 | 19 | public class InventoryContentPacketTranslator implements BedrockTranslator { 20 | @Override 21 | public boolean needOrder() { 22 | return true; 23 | } 24 | 25 | @Override 26 | public void translate(BedrockPacket inPacket, Client client) { 27 | InventoryContentPacket packet = (InventoryContentPacket) inPacket; 28 | 29 | List contents = packet.getContents(); 30 | switch (packet.getContainerId()) { 31 | case 0: { 32 | ItemConverter itemConverter = EZ4H.getConverterManager().getItemConverter(); 33 | for (int i = 0; i < 36; i++) { 34 | client.getInventory().updateItem(contents.get(i), itemConverter.inventoryIndex(i, false), false); 35 | } 36 | break; 37 | } 38 | case 119: { 39 | client.getInventory().updateItem(contents.get(0), 45, false); 40 | break; 41 | } 42 | case 120: { 43 | for (int i = 0; i < 4; i++) { 44 | client.getInventory().updateItem(contents.get(i), i + 5, false); 45 | } 46 | break; 47 | } 48 | default: { 49 | if (client.getData().getQueueChest() != null && client.getData().getQueueChest().id == packet.getContainerId()) { 50 | ChestData chestData = client.getData().getQueueChest(); 51 | //open window 52 | client.sendPacket(new ServerOpenWindowPacket(chestData.id, chestData.type, "minecraft:menu", 45 + contents.size())); 53 | //translate items 54 | ArrayList javaItems = new ArrayList<>(Arrays.asList(client.getInventory().getJavaInventory())); 55 | for (ItemData itemData : contents) { 56 | javaItems.add(EZ4H.getConverterManager().getItemConverter().convertToJE(itemData)); 57 | } 58 | client.sendPacket(new ServerWindowItemsPacket(chestData.id, javaItems.toArray(new ItemStack[0]))); 59 | //clear chestData 60 | client.getData().setQueueChest(null); 61 | } 62 | break; 63 | } 64 | } 65 | client.sendPacket(new ServerWindowItemsPacket(0, client.getInventory().getJavaInventory())); 66 | } 67 | 68 | 69 | @Override 70 | public Class getPacketClass() { 71 | return InventoryContentPacket.class; 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/window/ClientCreativeInventoryActionPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.window; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.window.ClientCreativeInventoryActionPacket; 5 | import com.github.steveice10.packetlib.packet.Packet; 6 | import com.nukkitx.protocol.bedrock.data.inventory.InventoryActionData; 7 | import com.nukkitx.protocol.bedrock.data.inventory.InventorySource; 8 | import com.nukkitx.protocol.bedrock.data.inventory.ItemData; 9 | import com.nukkitx.protocol.bedrock.data.inventory.TransactionType; 10 | import com.nukkitx.protocol.bedrock.packet.InventoryTransactionPacket; 11 | import me.liuli.ez4h.EZ4H; 12 | import me.liuli.ez4h.minecraft.Client; 13 | import me.liuli.ez4h.translators.JavaTranslator; 14 | 15 | //Creative Item 16 | //InventoryTransactionPacket(legacyRequestId=0, legacySlots=[], actions=[InventoryActionData(source=InventorySource(type=CONTAINER, containerId=0, flag=NONE), slot=0, fromItem=ItemData(id=0, damage=0, count=0, tag=null, canPlace=[], canBreak=[], blockingTicks=0, netId=0), toItem=ItemData(id=339, damage=0, count=1, tag={ 17 | // "Damage": 0i}, canPlace=[], canBreak=[], blockingTicks=0, netId=1), stackNetworkId=0), 18 | // InventoryActionData(source=InventorySource(type=CREATIVE, containerId=-1, flag=NONE), slot=1, fromItem=ItemData(id=339, damage=0, count=1, tag={ 19 | // "Damage": 0i 20 | //}, canPlace=[], canBreak=[], blockingTicks=0, netId=1), toItem=ItemData(id=0, damage=0, count=0, tag=null, canPlace=[], canBreak=[], blockingTicks=0, netId=0), stackNetworkId=0)], 21 | // transactionType=NORMAL, actionType=0, runtimeEntityId=0, blockPosition=null, blockFace=0, hotbarSlot=0, itemInHand=null, playerPosition=null, clickPosition=null, headPosition=null, hasNetworkIds=false, blockRuntimeId=0) 22 | 23 | public class ClientCreativeInventoryActionPacketTranslator implements JavaTranslator { 24 | @Override 25 | public void translate(Packet inPacket, Client client) { 26 | ClientCreativeInventoryActionPacket packet = (ClientCreativeInventoryActionPacket) inPacket; 27 | 28 | if (packet.getClickedItem() == null) 29 | return; 30 | 31 | ItemData getItem = EZ4H.getConverterManager().getItemConverter().convertToBE(packet.getClickedItem()); 32 | 33 | if (packet.getSlot() == -1) { 34 | //drop item 35 | return; 36 | } 37 | 38 | InventoryTransactionPacket inventoryTransactionPacket = new InventoryTransactionPacket(); 39 | inventoryTransactionPacket.setLegacyRequestId(0); 40 | InventoryActionData action1 = new InventoryActionData(InventorySource.fromContainerWindowId(0), EZ4H.getConverterManager().getItemConverter().inventoryIndex(packet.getSlot(), true), client.getInventory().getBedrockItem(packet.getSlot()), getItem); 41 | inventoryTransactionPacket.getActions().add(action1); 42 | InventoryActionData action2 = new InventoryActionData(InventorySource.fromCreativeInventory(), 1, getItem, client.getInventory().getBedrockItem(packet.getSlot())); 43 | inventoryTransactionPacket.getActions().add(action2); 44 | inventoryTransactionPacket.setTransactionType(TransactionType.NORMAL); 45 | inventoryTransactionPacket.setActionType(0); 46 | client.sendPacket(inventoryTransactionPacket); 47 | } 48 | 49 | @Override 50 | public Class getPacketClass() { 51 | return ClientCreativeInventoryActionPacket.class; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/entity/MobEffectPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.entity; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.EntityMetadata; 5 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.MetadataType; 6 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityEffectPacket; 7 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityMetadataPacket; 8 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityRemoveEffectPacket; 9 | import com.nukkitx.protocol.bedrock.BedrockPacket; 10 | import com.nukkitx.protocol.bedrock.packet.MobEffectPacket; 11 | import me.liuli.ez4h.EZ4H; 12 | import me.liuli.ez4h.minecraft.Client; 13 | import me.liuli.ez4h.translators.BedrockTranslator; 14 | import me.liuli.ez4h.utils.FileUtil; 15 | 16 | public class MobEffectPacketTranslator implements BedrockTranslator { 17 | private final JSONObject bedrockEffects, javaEffects; 18 | 19 | public MobEffectPacketTranslator() { 20 | JSONObject effectJSON = JSONObject.parseObject(FileUtil.getTextFromResource("resources/effect.json")); 21 | bedrockEffects = effectJSON.getJSONObject("bedrock"); 22 | javaEffects = effectJSON.getJSONObject("java"); 23 | } 24 | 25 | @Override 26 | public void translate(BedrockPacket inPacket, Client client) { 27 | MobEffectPacket packet = (MobEffectPacket) inPacket; 28 | 29 | Integer effect = getEffect(packet.getEffectId(), client); 30 | if (effect == null) return; 31 | 32 | switch (packet.getEvent()) { 33 | case ADD: 34 | case MODIFY: { 35 | EntityMetadata[] metadata = new EntityMetadata[1]; 36 | metadata[0] = new EntityMetadata(8, MetadataType.INT, packet.getEffectId()); 37 | client.sendPacket(new ServerEntityMetadataPacket((int) packet.getRuntimeEntityId(), metadata)); 38 | client.sendPacket(new ServerEntityEffectPacket((int) packet.getRuntimeEntityId(), effect, packet.getAmplifier(), packet.getDuration(), true, packet.isParticles())); 39 | break; 40 | } 41 | case REMOVE: { 42 | EntityMetadata[] metadata = new EntityMetadata[1]; 43 | metadata[0] = new EntityMetadata(8, MetadataType.INT, 0); 44 | client.sendPacket(new ServerEntityMetadataPacket((int) packet.getRuntimeEntityId(), metadata)); 45 | client.sendPacket(new ServerEntityRemoveEffectPacket((int) packet.getRuntimeEntityId(), effect)); 46 | break; 47 | } 48 | } 49 | } 50 | 51 | private Integer getEffect(int id, Client client) { 52 | String effectName = bedrockEffects.getString(id + ""); 53 | Integer javaEffectId = javaEffects.getInteger(effectName); 54 | if (javaEffectId != null) { 55 | return javaEffectId; 56 | } else { 57 | if (effectName == null) { 58 | EZ4H.getLogger().warn("Can't translate effect with ID " + id + " for player " + client.getPlayer().getName()); 59 | } else { 60 | EZ4H.getLogger().warn("Can't translate effect with name " + effectName + " for player " + client.getPlayer().getName()); 61 | } 62 | } 63 | return null; 64 | } 65 | 66 | @Override 67 | public Class getPacketClass() { 68 | return MobEffectPacket.class; 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /src/main/resources/resources/entity.json: -------------------------------------------------------------------------------- 1 | {"wither_skeleton":{"type":"mob","name":"wither_skeleton"},"husk":{"type":"mob","name":"husk"},"stray":{"type":"mob","name":"stray"},"witch":{"type":"mob","name":"witch"},"zombie_villager":{"type":"mob","name":"zombie_villager"},"villager_v2":{"type":"mob","name":"villager"},"zombie_villager_v2":{"type":"mob","name":"zombie_villager"},"blaze":{"type":"mob","name":"blaze"},"magma_cube":{"type":"mob","name":"magma_cube"},"ghast":{"type":"mob","name":"ghast"},"cave_spider":{"type":"mob","name":"cave_spider"},"silverfish":{"type":"mob","name":"silverfish"},"enderman":{"type":"mob","name":"enderman"},"slime":{"type":"mob","name":"slime"},"zombie_pigman":{"type":"mob","name":"zombie_pigman"},"spider":{"type":"mob","name":"spider"},"skeleton":{"type":"mob","name":"skeleton"},"creeper":{"type":"mob","name":"creeper"},"zombie":{"type":"mob","name":"zombie"},"skeleton_horse":{"type":"mob","name":"skeleton_horse"},"mule":{"type":"mob","name":"mule"},"donkey":{"type":"mob","name":"donkey"},"wolf":{"type":"mob","name":"wolf"},"squid":{"type":"mob","name":"squid"},"sheep":{"type":"mob","name":"sheep"},"mooshroom":{"type":"mob","name":"mooshroom"},"pig":{"type":"mob","name":"pig"},"villager":{"type":"mob","name":"villager"},"cow":{"type":"mob","name":"cow"},"chicken":{"type":"mob","name":"chicken"},"llama":{"type":"mob","name":"llama"},"iron_golem":{"type":"mob","name":"iron_golem"},"rabbit":{"type":"mob","name":"rabbit"},"snow_golem":{"type":"mob","name":"snowman"},"bat":{"type":"mob","name":"bat"},"ocelot":{"type":"mob","name":"ocelot"},"horse":{"type":"mob","name":"horse"},"polar_bear":{"type":"mob","name":"polar_bear"},"zombie_horse":{"type":"mob","name":"zombie_horse"},"parrot":{"type":"mob","name":"parrot"},"guardian":{"type":"mob","name":"guardian"},"elder_guardian":{"type":"mob","name":"elder_guardian"},"vindicator":{"type":"mob","name":"vindicator"},"wither":{"type":"mob","name":"wither"},"ender_dragon":{"type":"mob","name":"ender_dragon"},"shulker":{"type":"mob","name":"shulker"},"endermite":{"type":"mob","name":"endermite"},"minecart":{"type":"object","name":"minecart"},"hopper_minecart":{"type":"object","name":"minecart"},"tnt_minecart":{"type":"object","name":"minecart"},"chest_minecart":{"type":"object","name":"minecart"},"command_block_minecart":{"type":"object","name":"minecart"},"armor_stand":{"type":"object","name":"armor_stand"},"tnt":{"type":"object","name":"primed_tnt"},"xp_bottle":{"type":"object","name":"xp_bottle"},"xp_orb":{"type":"xp_orb","name":"xp_orb"},"eye_of_ender_signal":{"type":"object","name":"eye_of_ender"},"ender_crystal":{"type":"object","name":"ender_crystal"},"shulker_bullet":{"type":"object","name":"shulker_bullet"},"fishing_hook":{"type":"object","name":"fish_hook"},"dragon_fireball":{"type":"object","name":"dragon_fireball"},"arrow":{"type":"disabled"},"snowball":{"type":"object","name":"snowball"},"egg":{"type":"object","name":"egg"},"fireball":{"type":"object","name":"ghast_fireball"},"splash_potion":{"type":"object","name":"potion"},"ender_pearl":{"type":"object","name":"ender_pearl"},"wither_skull":{"type":"object","name":"wither_head_projectile"},"wither_skull_dangerous":{"type":"object","name":"wither_head_projectile"},"boat":{"type":"object","name":"boat"},"lightning_bolt":{"type":"global","name":"lightning_bolt"},"small_fireball":{"type":"object","name":"blaze_fireball"},"llama_spit":{"type":"object","name":"llama_spit"},"area_effect_cloud":{"type":"object","name":"area_effect_cloud"},"lingering_potion":{"type":"object","name":"potion"},"fireworks_rocket":{"type":"object","name":"fireworks_rocket"},"evocation_fang":{"type":"object","name":"evocation_fangs"}} -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/managers/TranslatorManager.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.managers; 2 | 3 | import com.github.steveice10.packetlib.packet.Packet; 4 | import com.nukkitx.protocol.bedrock.BedrockPacket; 5 | import me.liuli.ez4h.EZ4H; 6 | import me.liuli.ez4h.minecraft.Client; 7 | import me.liuli.ez4h.translators.BedrockTranslator; 8 | import me.liuli.ez4h.translators.JavaTranslator; 9 | 10 | import java.util.HashMap; 11 | import java.util.Map; 12 | import java.util.concurrent.SynchronousQueue; 13 | import java.util.concurrent.ThreadPoolExecutor; 14 | import java.util.concurrent.TimeUnit; 15 | 16 | public class TranslatorManager { 17 | 18 | private final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor( 19 | Runtime.getRuntime().availableProcessors(), 20 | Integer.MAX_VALUE, 21 | 60, 22 | TimeUnit.SECONDS, 23 | new SynchronousQueue<>(), 24 | new ThreadPoolExecutor.CallerRunsPolicy()); 25 | 26 | private final Map, JavaTranslator> javaTranslators = new HashMap<>(); 27 | private final Map, BedrockTranslator> bedrockTranslators = new HashMap<>(); 28 | 29 | public void addBedrockTranslator(BedrockTranslator translator) { 30 | bedrockTranslators.put(translator.getPacketClass(), translator); 31 | } 32 | 33 | public void addJavaTranslator(JavaTranslator translator) { 34 | javaTranslators.put(translator.getPacketClass(), translator); 35 | } 36 | 37 | public void translatePacket(BedrockPacket packet, Client client) { 38 | if (EZ4H.getDebugManager().isAllPackets()) { 39 | EZ4H.getLogger().debug("Bedrock IN " + packet.toString()); 40 | } 41 | BedrockTranslator translator = bedrockTranslators.get(packet.getClass()); 42 | if (translator != null) { 43 | try { 44 | if (translator.needOrder()) { 45 | translator.translate(packet, client); 46 | } else { 47 | this.threadPoolExecutor.execute(() -> translator.translate(packet, client)); 48 | } 49 | } catch (Throwable t) { 50 | EZ4H.getLogger().throwing(t); 51 | } 52 | } else { 53 | if (EZ4H.getDebugManager().isUnknownPackets()) { 54 | EZ4H.getLogger().debug("Bedrock IN-UNKNOWN " + packet.toString()); 55 | } 56 | } 57 | } 58 | 59 | public void translatePacket(Packet packet, Client client) { 60 | if (EZ4H.getDebugManager().isAllPackets()) { 61 | EZ4H.getLogger().debug("Java IN " + packet.toString()); 62 | } 63 | JavaTranslator translator = javaTranslators.get(packet.getClass()); 64 | if (translator != null) { 65 | try { 66 | if (translator.needOrder()) { 67 | translator.translate(packet, client); 68 | } else { 69 | this.threadPoolExecutor.execute(() -> translator.translate(packet, client)); 70 | } 71 | } catch (Throwable t) { 72 | EZ4H.getLogger().throwing(t); 73 | } 74 | } else { 75 | if (EZ4H.getDebugManager().isUnknownPackets()) { 76 | EZ4H.getLogger().debug("Java IN-UNKNOWN " + packet.toString()); 77 | } 78 | } 79 | } 80 | 81 | public BedrockTranslator getBedrockTranslator(Class clazz) { 82 | return bedrockTranslators.get(clazz); 83 | } 84 | 85 | public JavaTranslator getJavaTranslator(Class clazz) { 86 | return javaTranslators.get(clazz); 87 | } 88 | } -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/Ping.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft; 2 | 3 | import com.github.steveice10.mc.auth.data.GameProfile; 4 | import com.github.steveice10.mc.protocol.MinecraftConstants; 5 | import com.github.steveice10.mc.protocol.data.message.TextMessage; 6 | import com.github.steveice10.mc.protocol.data.status.PlayerInfo; 7 | import com.github.steveice10.mc.protocol.data.status.ServerStatusInfo; 8 | import com.github.steveice10.mc.protocol.data.status.VersionInfo; 9 | import com.github.steveice10.mc.protocol.packet.status.server.StatusResponsePacket; 10 | import com.github.steveice10.packetlib.Session; 11 | import com.nukkitx.protocol.bedrock.BedrockClient; 12 | import lombok.Getter; 13 | import lombok.Setter; 14 | import me.liuli.ez4h.EZ4H; 15 | import me.liuli.ez4h.utils.RandUtil; 16 | 17 | import java.net.InetSocketAddress; 18 | 19 | public class Ping { 20 | @Setter 21 | @Getter 22 | private static TextMessage description = new TextMessage("SERVER DESCRIPTION"); 23 | 24 | public Ping(Session session) { 25 | new Thread(new PingThread(session)).start(); 26 | } 27 | } 28 | 29 | class PingThread implements Runnable { 30 | private final Session session; 31 | 32 | PingThread(Session session) { 33 | this.session = session; 34 | } 35 | 36 | @Override 37 | public void run() { 38 | InetSocketAddress bindAddress = new InetSocketAddress("0.0.0.0", RandUtil.rand(10000, 50000)); 39 | BedrockClient client = new BedrockClient(bindAddress); 40 | InetSocketAddress addressToPing = new InetSocketAddress(EZ4H.getConfigManager().getBedrockHost(), EZ4H.getConfigManager().getBedrockPort()); 41 | client.bind().join(); 42 | try { 43 | client.ping(addressToPing).whenComplete((pong, throwable) -> { 44 | if (throwable != null) { 45 | sendPingData(session, new ServerStatusInfo( 46 | new VersionInfo("EZ4H", session.getFlag(MinecraftConstants.PROTOCOL_KEY)), 47 | new PlayerInfo(0, 0, new GameProfile[0]), 48 | new TextMessage("§eA EZ4H Proxied Server!\n§cPING FAILED:" + throwable.getLocalizedMessage()), 49 | EZ4H.getConfigManager().getServerIcon() 50 | )); 51 | return; 52 | } 53 | // Pong received. 54 | Ping.setDescription(new TextMessage(pong.getMotd() + "\n" + pong.getSubMotd())); 55 | sendPingData(session, new ServerStatusInfo( 56 | new VersionInfo("EZ4H", session.getFlag(MinecraftConstants.PROTOCOL_KEY)), 57 | new PlayerInfo(pong.getMaximumPlayerCount(), pong.getPlayerCount(), new GameProfile[0]), 58 | Ping.getDescription(), 59 | EZ4H.getConfigManager().getServerIcon() 60 | )); 61 | client.close(); 62 | }).join(); 63 | } catch (Exception e) { 64 | e.printStackTrace(); 65 | client.close(); 66 | sendPingData(session, new ServerStatusInfo( 67 | new VersionInfo("EZ4H", session.getFlag(MinecraftConstants.PROTOCOL_KEY)), 68 | new PlayerInfo(0, 0, new GameProfile[0]), 69 | new TextMessage("§eA EZ4H Proxied Server!\n§cPING FAILED:" + e.getLocalizedMessage()), 70 | EZ4H.getConfigManager().getServerIcon() 71 | )); 72 | } 73 | } 74 | 75 | private void sendPingData(Session session, ServerStatusInfo info) { 76 | if (session.isConnected()) { 77 | session.send(new StatusResponsePacket(info)); 78 | } 79 | } 80 | } -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/world/BlockEntityDataPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.world; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.Position; 5 | import com.github.steveice10.mc.protocol.data.game.world.block.BlockChangeRecord; 6 | import com.github.steveice10.mc.protocol.data.game.world.block.BlockState; 7 | import com.github.steveice10.mc.protocol.data.game.world.block.UpdatedTileType; 8 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerBlockChangePacket; 9 | import com.github.steveice10.mc.protocol.packet.ingame.server.world.ServerUpdateTileEntityPacket; 10 | import com.github.steveice10.opennbt.tag.builtin.CompoundTag; 11 | import com.github.steveice10.opennbt.tag.builtin.IntTag; 12 | import com.github.steveice10.opennbt.tag.builtin.StringTag; 13 | import com.nukkitx.math.vector.Vector3i; 14 | import com.nukkitx.nbt.NbtMap; 15 | import com.nukkitx.protocol.bedrock.BedrockPacket; 16 | import com.nukkitx.protocol.bedrock.packet.BlockEntityDataPacket; 17 | import me.liuli.ez4h.minecraft.Client; 18 | import me.liuli.ez4h.translators.BedrockTranslator; 19 | 20 | public class BlockEntityDataPacketTranslator implements BedrockTranslator { 21 | @Override 22 | public void translate(BedrockPacket inPacket, Client client) { 23 | BlockEntityDataPacket packet = (BlockEntityDataPacket) inPacket; 24 | Vector3i pos = packet.getBlockPosition(); 25 | NbtMap data = packet.getData(); 26 | Position position = new Position(pos.getX(), pos.getY(), pos.getZ()); 27 | switch (data.getString("id")) { 28 | case "Chest": { 29 | client.sendPacket(new ServerBlockChangePacket(new BlockChangeRecord(position, new BlockState(54, 3)))); 30 | break; 31 | } 32 | case "Furnace": { 33 | client.sendPacket(new ServerBlockChangePacket(new BlockChangeRecord(position, new BlockState(61, 4)))); 34 | break; 35 | } 36 | case "ShulkerBox": { 37 | client.sendPacket(new ServerBlockChangePacket(new BlockChangeRecord(position, new BlockState(219, 1)))); 38 | break; 39 | } 40 | case "EnderChest": { 41 | client.sendPacket(new ServerBlockChangePacket(new BlockChangeRecord(position, new BlockState(130, 2)))); 42 | break; 43 | } 44 | case "Sign": { 45 | client.sendPacket(new ServerBlockChangePacket(new BlockChangeRecord(position, new BlockState(63, 0)))); 46 | 47 | CompoundTag tag = new CompoundTag(""); 48 | tag.put(new IntTag("x", position.getX())); 49 | tag.put(new IntTag("y", position.getY())); 50 | tag.put(new IntTag("z", position.getZ())); 51 | tag.put(new StringTag("id", "minecraft:sign")); 52 | String[] rawText = data.getString("Text").split("\n"); 53 | for (int i = 0; i < 4; i++) { 54 | JSONObject jsonText = new JSONObject(); 55 | if (rawText.length > i) { 56 | jsonText.put("text", rawText[i]); 57 | } else { 58 | jsonText.put("text", ""); 59 | } 60 | tag.put(new StringTag("Text" + (i + 1), jsonText.toJSONString())); 61 | } 62 | 63 | client.sendPacket(new ServerUpdateTileEntityPacket(position, UpdatedTileType.SIGN, tag)); 64 | break; 65 | } 66 | } 67 | } 68 | 69 | @Override 70 | public Class getPacketClass() { 71 | return BlockEntityDataPacket.class; 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/utils/FileUtil.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.utils; 2 | 3 | import me.liuli.ez4h.EZ4H; 4 | 5 | import javax.net.ssl.HttpsURLConnection; 6 | import java.io.*; 7 | import java.net.URL; 8 | import java.nio.charset.StandardCharsets; 9 | import java.nio.file.Files; 10 | import java.util.zip.GZIPInputStream; 11 | 12 | public class FileUtil { 13 | public static String getTextFromInputStream(InputStream inputStream) throws Exception { 14 | ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 15 | byte[] buffer = new byte[1024]; 16 | int length; 17 | while ((length = inputStream.read(buffer)) != -1) { 18 | byteArrayOutputStream.write(buffer, 0, length); 19 | } 20 | 21 | byteArrayOutputStream.close(); 22 | inputStream.close(); 23 | 24 | return byteArrayOutputStream.toString("UTF-8"); 25 | } 26 | 27 | public static byte[] getByteFromInputStream(InputStream inputStream) throws Exception { 28 | ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 29 | byte[] buffer = new byte[1024]; 30 | int length; 31 | while ((length = inputStream.read(buffer)) != -1) { 32 | byteArrayOutputStream.write(buffer, 0, length); 33 | } 34 | byteArrayOutputStream.close(); 35 | inputStream.close(); 36 | return byteArrayOutputStream.toByteArray(); 37 | } 38 | 39 | public static String readFile(File file) { 40 | try { 41 | return new String(Files.readAllBytes(file.toPath())); 42 | } catch (Exception e) { 43 | e.printStackTrace(); 44 | } 45 | return null; 46 | } 47 | 48 | public static void writeFile(String path, String text) { 49 | try { 50 | Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(path), StandardCharsets.UTF_8)); 51 | writer.write(text); 52 | writer.close(); 53 | } catch (Exception e) { 54 | e.printStackTrace(); 55 | } 56 | } 57 | 58 | public static void unzipResource(String resourceName,File targetPath){ 59 | InputStream inputStream = EZ4H.class.getClassLoader().getResourceAsStream(resourceName); 60 | try { 61 | byte[] bytes=getByteFromInputStream(inputStream); 62 | FileOutputStream fos=new FileOutputStream(targetPath); 63 | fos.write(bytes); 64 | fos.flush(); 65 | fos.close(); 66 | } catch (Exception e) { 67 | e.printStackTrace(); 68 | } 69 | } 70 | 71 | public static String getTextFromResource(String resourceName) { 72 | InputStream inputStream = EZ4H.class.getClassLoader().getResourceAsStream(resourceName); 73 | try { 74 | return getTextFromInputStream(inputStream); 75 | } catch (Exception e) { 76 | e.printStackTrace(); 77 | } 78 | return null; 79 | } 80 | 81 | public static String httpsGet(String url) throws Exception { 82 | HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection(); 83 | connection.setRequestMethod("GET"); 84 | connection.connect(); 85 | return FileUtil.getTextFromInputStream(connection.getInputStream()); 86 | } 87 | 88 | public static String uncompressGzip(InputStream inputStream) throws IOException { 89 | ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 90 | GZIPInputStream gZIPInputStream = new GZIPInputStream(inputStream); 91 | byte[] buffer = new byte[1024]; 92 | int length; 93 | while ((length = gZIPInputStream.read(buffer)) != -1) { 94 | byteArrayOutputStream.write(buffer, 0, length); 95 | } 96 | byteArrayOutputStream.close(); 97 | inputStream.close(); 98 | gZIPInputStream.close(); 99 | return byteArrayOutputStream.toString("UTF-8"); 100 | } 101 | } 102 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/auth/XboxLogin.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.auth; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import me.liuli.ez4h.utils.FileUtil; 5 | import me.liuli.ez4h.utils.OtherUtil; 6 | 7 | import javax.net.ssl.HttpsURLConnection; 8 | import java.io.ByteArrayOutputStream; 9 | import java.io.DataOutputStream; 10 | import java.io.IOException; 11 | import java.io.InputStream; 12 | import java.net.URL; 13 | import java.util.List; 14 | import java.util.zip.GZIPInputStream; 15 | 16 | //Translate to java from https://github.com/XboxReplay/xboxlive-auth 17 | public class XboxLogin { 18 | private static final String XBOX_PRE_AUTH_URL = "https://login.live.com/oauth20_authorize.srf?client_id=00000000441cc96b&redirect_uri=https://login.live.com/oauth20_desktop.srf&response_type=token&display=touch&scope=service::user.auth.xboxlive.com::MBI_SSL&locale=en"; 19 | 20 | private JSONObject getPreAuthToken() throws Exception { 21 | HttpsURLConnection connection = (HttpsURLConnection) new URL(XBOX_PRE_AUTH_URL).openConnection(); 22 | connection.setRequestMethod("GET"); 23 | OtherUtil.setBaseHeaders(connection); 24 | String responce = FileUtil.uncompressGzip(connection.getInputStream()); 25 | JSONObject resJson = new JSONObject(); 26 | resJson.put("urlPost", findArgs(responce, "urlPost:'")); 27 | String argTmp = findArgs(responce, "sFTTag:'"); 28 | argTmp = argTmp.substring(argTmp.indexOf("value=\"") + 7); 29 | resJson.put("PPFT", argTmp); 30 | List cookies = connection.getHeaderFields().get("Set-Cookie"); 31 | StringBuilder allCookie = new StringBuilder(); 32 | for (String cookie : cookies) { 33 | allCookie.append(cookie.split(";")[0]); 34 | allCookie.append("; "); 35 | } 36 | resJson.put("cookie", allCookie); 37 | return resJson; 38 | } 39 | 40 | public String getAccessToken(String username, String password) throws Exception { 41 | JSONObject preAuthToken = getPreAuthToken(); 42 | HttpsURLConnection connection = (HttpsURLConnection) new URL(preAuthToken.getString("urlPost")).openConnection(); 43 | connection.setRequestMethod("POST"); 44 | OtherUtil.setBaseHeaders(connection); 45 | connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); 46 | connection.setRequestProperty("Cookie", preAuthToken.getString("cookie")); 47 | 48 | StringBuilder postStr = new StringBuilder(); 49 | postStr.append("login="); 50 | postStr.append(username); 51 | postStr.append("&loginfmt="); 52 | postStr.append(username); 53 | postStr.append("&passwd="); 54 | postStr.append(password); 55 | postStr.append("&PPFT="); 56 | postStr.append(preAuthToken.getString("PPFT")); 57 | connection.setDoOutput(true); 58 | connection.setInstanceFollowRedirects(true); 59 | 60 | DataOutputStream dataOutputStream = new DataOutputStream(connection.getOutputStream()); 61 | dataOutputStream.writeBytes(postStr.toString()); 62 | dataOutputStream.flush(); 63 | 64 | connection.connect(); 65 | InputStream is = connection.getInputStream(); 66 | String url = connection.getURL().toString(), hash, accessToken = ""; 67 | hash = url.split("#")[1]; 68 | String[] hashes = hash.split("&"); 69 | for (String partHash : hashes) { 70 | if (partHash.split("=")[0].equals("access_token")) { 71 | accessToken = partHash.split("=")[1]; 72 | break; 73 | } 74 | } 75 | is.close(); 76 | return accessToken.replaceAll("%2b", "+"); 77 | } 78 | 79 | private String findArgs(String str, String args) { 80 | if (str.contains(args)) { 81 | int pos = str.indexOf(args); 82 | String result = str.substring(pos + args.length()); 83 | pos = result.indexOf("',"); 84 | result = result.substring(0, pos); 85 | return result; 86 | } else { 87 | throw new IllegalArgumentException("CANNOT FIND ARGUMENT"); 88 | } 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/UpdateAttributesPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.attribute.Attribute; 4 | import com.github.steveice10.mc.protocol.data.game.entity.attribute.AttributeType; 5 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.EntityMetadata; 6 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.MetadataType; 7 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityMetadataPacket; 8 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityPropertiesPacket; 9 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.player.ServerPlayerHealthPacket; 10 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.player.ServerPlayerSetExperiencePacket; 11 | import com.nukkitx.protocol.bedrock.BedrockPacket; 12 | import com.nukkitx.protocol.bedrock.data.AttributeData; 13 | import com.nukkitx.protocol.bedrock.packet.UpdateAttributesPacket; 14 | import me.liuli.ez4h.minecraft.Client; 15 | import me.liuli.ez4h.translators.BedrockTranslator; 16 | 17 | import java.util.ArrayList; 18 | import java.util.List; 19 | 20 | public class UpdateAttributesPacketTranslator implements BedrockTranslator { 21 | @Override 22 | public void translate(BedrockPacket inPacket, Client client) { 23 | boolean updateHP = false, updateEXP = false; 24 | UpdateAttributesPacket packet = (UpdateAttributesPacket) inPacket; 25 | if (packet.getRuntimeEntityId() == client.getPlayer().getEntityId()) { 26 | List attributes = packet.getAttributes(); 27 | for (AttributeData attribute : attributes) { 28 | switch (attribute.getName()) { 29 | case "minecraft:health": { 30 | List attributes1 = new ArrayList<>(); 31 | attributes1.add(new Attribute(AttributeType.GENERIC_MAX_HEALTH, attribute.getMaximum())); 32 | client.sendPacket(new ServerEntityPropertiesPacket((int) client.getPlayer().getEntityId(), attributes1)); 33 | client.getPlayer().setHealth(attribute.getValue()); 34 | updateHP = true; 35 | break; 36 | } 37 | case "minecraft:player.experience": { 38 | client.getPlayer().setExp(attribute.getValue() / attribute.getMaximum()); 39 | updateEXP = true; 40 | break; 41 | } 42 | case "minecraft:player.hunger": { 43 | client.getPlayer().setFood((int) attribute.getValue()); 44 | updateHP = true; 45 | break; 46 | } 47 | case "minecraft:player.level": { 48 | client.getPlayer().setExpLevel(attribute.getValue()); 49 | updateEXP = true; 50 | break; 51 | } 52 | case "minecraft:movement": { 53 | client.getPlayer().setWalkSpeed(attribute.getValue()); 54 | List attributes1 = new ArrayList<>(); 55 | attributes1.add(new Attribute(AttributeType.GENERIC_MOVEMENT_SPEED, attribute.getValue())); 56 | client.sendPacket(new ServerEntityPropertiesPacket((int) client.getPlayer().getEntityId(), attributes1)); 57 | break; 58 | } 59 | //ServerEntityMetadataPacket(entityId=2, metadata=[EntityMetadata(id=11, type=FLOAT, value=1024.0)]) 60 | //AttributeData(name=minecraft:absorption, minimum=0.0, maximum=3.4028235E38, value=4.0, defaultValue=0.0) 61 | case "minecraft:absorption": { 62 | client.sendPacket(new ServerEntityMetadataPacket((int) client.getPlayer().getEntityId(), new EntityMetadata[]{new EntityMetadata(11, MetadataType.FLOAT, attribute.getValue())})); 63 | break; 64 | } 65 | } 66 | } 67 | if (updateHP) { 68 | //idk why client display hurtcam when regen 69 | client.sendPacket(new ServerPlayerHealthPacket(client.getPlayer().getHealth(), client.getPlayer().getFood(), 0)); 70 | } 71 | if (updateEXP) { 72 | client.sendPacket(new ServerPlayerSetExperiencePacket(client.getPlayer().getExp(), (int) client.getPlayer().getExpLevel(), 0)); 73 | } 74 | } 75 | } 76 | 77 | @Override 78 | public Class getPacketClass() { 79 | return UpdateAttributesPacket.class; 80 | } 81 | } 82 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/JavaServer.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft; 2 | 3 | import com.github.steveice10.mc.auth.data.GameProfile; 4 | import com.github.steveice10.mc.auth.service.SessionService; 5 | import com.github.steveice10.mc.protocol.MinecraftConstants; 6 | import com.github.steveice10.mc.protocol.MinecraftProtocol; 7 | import com.github.steveice10.mc.protocol.ServerLoginHandler; 8 | import com.github.steveice10.mc.protocol.data.SubProtocol; 9 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 10 | import com.github.steveice10.mc.protocol.data.game.setting.Difficulty; 11 | import com.github.steveice10.mc.protocol.data.game.world.WorldType; 12 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerJoinGamePacket; 13 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerPluginMessagePacket; 14 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.player.ServerPlayerPositionRotationPacket; 15 | import com.github.steveice10.packetlib.Server; 16 | import com.github.steveice10.packetlib.Session; 17 | import com.github.steveice10.packetlib.event.server.ServerAdapter; 18 | import com.github.steveice10.packetlib.event.server.SessionAddedEvent; 19 | import com.github.steveice10.packetlib.event.server.SessionRemovedEvent; 20 | import com.github.steveice10.packetlib.event.session.SessionListener; 21 | import com.github.steveice10.packetlib.tcp.TcpSessionFactory; 22 | import me.liuli.ez4h.EZ4H; 23 | import me.liuli.ez4h.minecraft.auth.fakeAuthServer.FakeServer; 24 | import me.liuli.ez4h.utils.OtherUtil; 25 | 26 | public class JavaServer { 27 | private final Server server; 28 | 29 | public JavaServer() { 30 | SessionService sessionService = new SessionService(); 31 | server = new Server(EZ4H.getConfigManager().getJavaHost(), EZ4H.getConfigManager().getJavaPort(), MinecraftProtocol.class, new TcpSessionFactory()); 32 | server.setGlobalFlag("session-service", sessionService); 33 | server.setGlobalFlag(MinecraftConstants.VERIFY_USERS_KEY, false); 34 | 35 | server.setGlobalFlag(MinecraftConstants.SERVER_LOGIN_HANDLER_KEY, new ServerLoginHandler() { 36 | @Override 37 | public void loggedIn(Session session) { 38 | GameProfile profile = session.getFlag(MinecraftConstants.PROFILE_KEY); 39 | Client client = EZ4H.getClient(profile.getName()); 40 | if (client != null) { 41 | session.send(new ServerPluginMessagePacket("EZ4H", ("{\"type\":\"join\",\"data\":\"" + OtherUtil.base64Encode(EZ4H.getConfigManager().getConfig().toJSONString()) + "\"}").getBytes())); 42 | } else { 43 | ServerJoinGamePacket serverJoinGamePacket = new ServerJoinGamePacket( 44 | 1, 45 | false, 46 | GameMode.SURVIVAL, 47 | 0, 48 | Difficulty.NORMAL, 49 | 1, 50 | WorldType.CUSTOMIZED, 51 | true 52 | ); 53 | ServerPlayerPositionRotationPacket serverPlayerPositionRotationPacket = new ServerPlayerPositionRotationPacket(0, 70, 0, 90, 90, 1); 54 | session.send(serverJoinGamePacket); 55 | session.send(serverPlayerPositionRotationPacket); 56 | session.addListener(new FakeServer(session, profile.getName())); 57 | } 58 | } 59 | }); 60 | 61 | server.setGlobalFlag(MinecraftConstants.SERVER_COMPRESSION_THRESHOLD, 100); 62 | server.addListener(new ServerAdapter() { 63 | 64 | @Override 65 | public void sessionAdded(SessionAddedEvent event) { 66 | event.getSession().addListener(new JavaPacketHandler()); 67 | } 68 | 69 | @Override 70 | public void sessionRemoved(SessionRemovedEvent event) { 71 | MinecraftProtocol protocol = (MinecraftProtocol) event.getSession().getPacketProtocol(); 72 | if (protocol.getSubProtocol() == SubProtocol.GAME) { 73 | Session session = event.getSession(); 74 | GameProfile profile = session.getFlag(MinecraftConstants.PROFILE_KEY); 75 | Client client = EZ4H.removeClient(profile.getName()); 76 | EZ4H.getLogger().info(profile.getName() + "[" + session.getHost() + ":" + session.getPort() + "] QUITED."); 77 | if (client != null) { 78 | client.disconnectBedrock(); 79 | } else { 80 | for (SessionListener sessionListener : session.getListeners()) { 81 | FakeServer fakeServer = (FakeServer) sessionListener; 82 | fakeServer.setAuth(); 83 | } 84 | } 85 | } 86 | } 87 | }); 88 | server.bind(); 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/java/window/ClientWindowActionPacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.java.window; 2 | 3 | import com.github.steveice10.mc.protocol.packet.MinecraftPacket; 4 | import com.github.steveice10.mc.protocol.packet.ingame.client.player.ClientPlayerActionPacket; 5 | import com.github.steveice10.mc.protocol.packet.ingame.client.window.ClientWindowActionPacket; 6 | import com.github.steveice10.packetlib.packet.Packet; 7 | import com.nukkitx.math.vector.Vector3f; 8 | import com.nukkitx.protocol.bedrock.data.inventory.InventoryActionData; 9 | import com.nukkitx.protocol.bedrock.data.inventory.InventorySource; 10 | import com.nukkitx.protocol.bedrock.data.inventory.ItemData; 11 | import com.nukkitx.protocol.bedrock.data.inventory.TransactionType; 12 | import com.nukkitx.protocol.bedrock.packet.InteractPacket; 13 | import com.nukkitx.protocol.bedrock.packet.InventoryTransactionPacket; 14 | import me.liuli.ez4h.EZ4H; 15 | import me.liuli.ez4h.minecraft.Client; 16 | import me.liuli.ez4h.translators.JavaTranslator; 17 | import me.liuli.ez4h.translators.converters.ItemConverter; 18 | import me.liuli.ez4h.translators.java.play.ClientPlayerActionPacketTranslator; 19 | 20 | public class ClientWindowActionPacketTranslator implements JavaTranslator { 21 | @Override 22 | public void translate(Packet inPacket, Client client) { 23 | ClientWindowActionPacket packet = (ClientWindowActionPacket) inPacket; 24 | //TODO:Rewrite 25 | switch (packet.getMode()) { 26 | case 0: { 27 | if (packet.getSlot() == -999) return; 28 | if (client.getData().getItemInHand() == 0) { 29 | client.getData().setItemInHand(packet.getSlot()); 30 | } else { 31 | moveItem(client.getData().getItemInHand(), packet.getSlot(), client); 32 | client.getData().setItemInHand(0); 33 | } 34 | break; 35 | } 36 | case 1: { 37 | //TODO:Click with shift 38 | break; 39 | } 40 | case 2: { 41 | moveItem(packet.getSlot(), packet.getButton() + 36, client); 42 | break; 43 | } 44 | case 4: { 45 | if (packet.getSlot() == -999) return; 46 | int count = 1; 47 | ItemData item = client.getData().getInventory().getBedrockItem(packet.getSlot()); 48 | if (packet.getButton() == 1) { 49 | count = item.getCount(); 50 | } 51 | ((ClientPlayerActionPacketTranslator) EZ4H.getTranslatorManager().getJavaTranslator(ClientPlayerActionPacket.class)).dropItem(client, count, item); 52 | break; 53 | } 54 | } 55 | } 56 | 57 | public void moveItem(int fromSlot, int toSlot, Client client) { 58 | if (!client.getInventory().isOpen()) { 59 | InteractPacket interactPacket = new InteractPacket(); 60 | interactPacket.setAction(InteractPacket.Action.OPEN_INVENTORY); 61 | interactPacket.setRuntimeEntityId(client.getPlayer().getEntityId()); 62 | interactPacket.setMousePosition(Vector3f.ZERO); 63 | client.sendPacket(interactPacket); 64 | } 65 | ItemConverter itemConverter = EZ4H.getConverterManager().getItemConverter(); 66 | ItemData fromItem = client.getInventory().getBedrockItem(fromSlot), 67 | toItem = client.getInventory().getBedrockItem(toSlot); 68 | 69 | if (fromItem == null) { 70 | fromItem = ItemData.AIR; 71 | } 72 | if (toItem == null) { 73 | toItem = ItemData.AIR; 74 | } 75 | 76 | InventoryTransactionPacket inventoryTransactionPacket = new InventoryTransactionPacket(); 77 | inventoryTransactionPacket.setTransactionType(TransactionType.NORMAL); 78 | inventoryTransactionPacket.setLegacyRequestId(0); 79 | inventoryTransactionPacket.setActionType(0); 80 | inventoryTransactionPacket.setRuntimeEntityId(0); 81 | inventoryTransactionPacket.setBlockFace(0); 82 | inventoryTransactionPacket.setHotbarSlot(0); 83 | inventoryTransactionPacket.setBlockRuntimeId(0); 84 | inventoryTransactionPacket.setHasNetworkIds(false); 85 | InventoryActionData inventoryActionData = new InventoryActionData(InventorySource.fromContainerWindowId(0), itemConverter.inventoryIndex(fromSlot, true), fromItem, toItem); 86 | inventoryTransactionPacket.getActions().add(inventoryActionData); 87 | inventoryActionData = new InventoryActionData(InventorySource.fromContainerWindowId(0), itemConverter.inventoryIndex(toSlot, true), toItem, fromItem); 88 | inventoryTransactionPacket.getActions().add(inventoryActionData); 89 | client.sendPacket(inventoryTransactionPacket); 90 | 91 | client.getInventory().updateItem(fromItem, toSlot, true); 92 | client.getInventory().updateItem(toItem, fromSlot, true); 93 | } 94 | 95 | @Override 96 | public Class getPacketClass() { 97 | return ClientWindowActionPacket.class; 98 | } 99 | } 100 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/bedrock/play/StartGamePacketTranslator.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.bedrock.play; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.EntityStatus; 4 | import com.github.steveice10.mc.protocol.data.game.entity.player.GameMode; 5 | import com.github.steveice10.mc.protocol.data.game.setting.Difficulty; 6 | import com.github.steveice10.mc.protocol.data.game.world.WorldType; 7 | import com.github.steveice10.mc.protocol.data.message.TextMessage; 8 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerDifficultyPacket; 9 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerJoinGamePacket; 10 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerPlayerListDataPacket; 11 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerPluginMessagePacket; 12 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityStatusPacket; 13 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.player.ServerPlayerPositionRotationPacket; 14 | import com.nukkitx.math.vector.Vector2f; 15 | import com.nukkitx.math.vector.Vector3f; 16 | import com.nukkitx.protocol.bedrock.BedrockPacket; 17 | import com.nukkitx.protocol.bedrock.packet.SetLocalPlayerAsInitializedPacket; 18 | import com.nukkitx.protocol.bedrock.packet.StartGamePacket; 19 | import me.liuli.ez4h.EZ4H; 20 | import me.liuli.ez4h.minecraft.Client; 21 | import me.liuli.ez4h.minecraft.Ping; 22 | import me.liuli.ez4h.translators.BedrockTranslator; 23 | import me.liuli.ez4h.utils.BedrockUtil; 24 | 25 | import java.nio.charset.StandardCharsets; 26 | 27 | public class StartGamePacketTranslator implements BedrockTranslator { 28 | public TextMessage playerList; 29 | 30 | public StartGamePacketTranslator() { 31 | playerList = EZ4H.getConfigManager().getPlayerList(); 32 | if (playerList == null) { 33 | playerList = new TextMessage("null"); 34 | } 35 | } 36 | 37 | @Override 38 | public boolean needOrder() { 39 | return true; 40 | } 41 | 42 | @Override 43 | public void translate(BedrockPacket inPacket, Client client) { 44 | StartGamePacket packet = (StartGamePacket) inPacket; 45 | //player list 46 | ServerPlayerListDataPacket serverPlayerListDataPacket = new ServerPlayerListDataPacket(Ping.getDescription(), playerList); 47 | 48 | //packet what Sponge send to client 49 | //original data [83, 112, 111, 110, 103, 101] => Sponge 50 | ServerPluginMessagePacket pluginMessage1 = new ServerPluginMessagePacket("REGISTER", EZ4H.getName().getBytes(StandardCharsets.UTF_8)); 51 | //original data [13, 83, 112, 111, 110, 103, 101, 86, 97, 110, 105, 108, 108, 97] => SpongeVanilla 52 | ServerPluginMessagePacket pluginMessage2 = new ServerPluginMessagePacket("MC|Brand", EZ4H.getName().getBytes(StandardCharsets.UTF_8)); 53 | 54 | //login translate 55 | Difficulty difficulty; 56 | try { 57 | difficulty = BedrockUtil.convertDifficultyToJE(packet.getDifficulty()); 58 | } catch (Exception e) { 59 | difficulty = Difficulty.NORMAL; 60 | } 61 | ServerDifficultyPacket serverDifficultyPacket = new ServerDifficultyPacket(difficulty); 62 | ServerEntityStatusPacket serverEntityStatusPacket = new ServerEntityStatusPacket((int) packet.getRuntimeEntityId(), EntityStatus.PLAYER_OP_PERMISSION_LEVEL_0); 63 | GameMode gameMode = BedrockUtil.convertGameModeToJE(packet.getPlayerGameType()); 64 | ServerJoinGamePacket serverJoinGamePacket = new ServerJoinGamePacket( 65 | (int) packet.getRuntimeEntityId(), 66 | false, 67 | gameMode, 68 | packet.getDimensionId(), 69 | BedrockUtil.convertDifficultyToJE(packet.getDifficulty()), 70 | 0, 71 | WorldType.FLAT, 72 | true 73 | ); 74 | Vector3f position = packet.getPlayerPosition(); 75 | Vector2f rotation = packet.getRotation(); 76 | ServerPlayerPositionRotationPacket serverPlayerPositionRotationPacket = new ServerPlayerPositionRotationPacket(position.getX(), position.getY(), position.getZ(), rotation.getY(), rotation.getX(), 1); 77 | 78 | client.sendPacket(pluginMessage1); 79 | client.sendPacket(pluginMessage2); 80 | client.sendPacket(serverDifficultyPacket); 81 | client.sendPacket(serverJoinGamePacket); 82 | client.sendPacket(serverPlayerPositionRotationPacket); 83 | client.sendPacket(serverEntityStatusPacket); 84 | client.sendPacket(serverPlayerListDataPacket); 85 | 86 | client.getPlayer().setEntityId(packet.getRuntimeEntityId()); 87 | client.getPlayer().setDimension(packet.getDimensionId()); 88 | client.getPlayer().setDifficulty(difficulty); 89 | client.getPlayer().setGameMode(gameMode); 90 | 91 | SetLocalPlayerAsInitializedPacket setLocalPlayerAsInitializedPacket = new SetLocalPlayerAsInitializedPacket(); 92 | setLocalPlayerAsInitializedPacket.setRuntimeEntityId(packet.getRuntimeEntityId()); 93 | client.sendPacket(setLocalPlayerAsInitializedPacket); 94 | } 95 | 96 | @Override 97 | public Class getPacketClass() { 98 | return StartGamePacket.class; 99 | } 100 | } 101 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/minecraft/auth/fakeAuthServer/FakeServer.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.minecraft.auth.fakeAuthServer; 2 | 3 | import com.alibaba.fastjson.JSONObject; 4 | import com.github.steveice10.mc.protocol.data.game.TitleAction; 5 | import com.github.steveice10.mc.protocol.packet.ingame.client.ClientChatPacket; 6 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerChatPacket; 7 | import com.github.steveice10.mc.protocol.packet.ingame.server.ServerTitlePacket; 8 | import com.github.steveice10.packetlib.Session; 9 | import com.github.steveice10.packetlib.event.session.PacketReceivedEvent; 10 | import com.github.steveice10.packetlib.event.session.SessionAdapter; 11 | import me.liuli.ez4h.EZ4H; 12 | 13 | public class FakeServer extends SessionAdapter { 14 | private final String playerName; 15 | public AuthAlertThread runnable; 16 | public Thread thread; 17 | 18 | public FakeServer(Session session, String playerName) { 19 | this.playerName = playerName; 20 | JSONObject account = EZ4H.getAuthManager().getAccount(playerName); 21 | if (account != null) { 22 | try { 23 | session.send(new ServerTitlePacket(5, 10, 5)); 24 | session.send(new ServerTitlePacket(TitleAction.TITLE, "§a§lTrying AutoLogin")); 25 | session.send(new ServerTitlePacket(TitleAction.SUBTITLE, "wait few seconds....")); 26 | EZ4H.getAuthManager().getAccessTokens().put(playerName, EZ4H.getAuthManager().getXboxLogin().getAccessToken(account.getString("username"), account.getString("password"))); 27 | session.disconnect("§aAutoLogin successful!\n§fPlease RECONNECT To The Server!"); 28 | } catch (Exception e) { 29 | e.printStackTrace(); 30 | EZ4H.getAuthManager().removeAccount(playerName); 31 | session.send(new ServerChatPacket("§cAutoLogin Failed!Please reLogin!")); 32 | } 33 | } 34 | if (EZ4H.getConfigManager().isAutoLogin()) { 35 | session.send(new ServerChatPacket("§aAutoLogin Enabled on this server!")); 36 | session.send(new ServerChatPacket("if you dont want autologin please login as this format")); 37 | session.send(new ServerChatPacket("NAL:mail@outlook.com:password")); 38 | } 39 | runnable = new AuthAlertThread(); 40 | thread = new Thread(runnable); 41 | thread.start(); 42 | runnable.session = session; 43 | session.send(new ServerChatPacket("§aYou need to login xbox because xbox-auth is on!")); 44 | } 45 | 46 | public void setAuth() { 47 | runnable.authenticated = true; 48 | } 49 | 50 | @Override 51 | public void packetReceived(PacketReceivedEvent event) { 52 | if (event.getPacket() instanceof ClientChatPacket) { 53 | ClientChatPacket clientChatPacket = event.getPacket(); 54 | boolean canAutoLogin = EZ4H.getConfigManager().isAutoLogin(); 55 | String messageStr = clientChatPacket.getMessage(); 56 | if (messageStr.contains("NAL:")) { 57 | canAutoLogin = false; 58 | } 59 | String[] message = messageStr.split(":"); 60 | if (message.length != 2) { 61 | runnable.session.send(new ServerChatPacket("§cWRONG FORMAT")); 62 | return; 63 | } 64 | if (message[1].length() < 8) { 65 | runnable.session.send(new ServerChatPacket("§cWRONG PASSWORD LENGTH")); 66 | return; 67 | } 68 | try { 69 | runnable.session.send(new ServerTitlePacket(5, 10, 5)); 70 | runnable.session.send(new ServerTitlePacket(TitleAction.TITLE, "§a§lAuthenticated")); 71 | runnable.session.send(new ServerTitlePacket(TitleAction.SUBTITLE, "wait few seconds....")); 72 | setAuth(); 73 | EZ4H.getAuthManager().getAccessTokens().put(playerName, EZ4H.getAuthManager().getXboxLogin().getAccessToken(message[0], message[1])); 74 | if (canAutoLogin) { 75 | EZ4H.getAuthManager().saveAccount(playerName, message[0], message[1]); 76 | } 77 | runnable.session.disconnect("§aLogin Successful!\n§fPlease RECONNECT To The Server!"); 78 | } catch (Exception e) { 79 | e.printStackTrace(); 80 | runnable.session.disconnect("§cLogin FAILED:\n" + e); 81 | } 82 | } 83 | } 84 | } 85 | 86 | class AuthAlertThread implements Runnable { 87 | public boolean authenticated = false; 88 | public Session session; 89 | private int afkCount = 0; 90 | 91 | public void run() { 92 | while (!authenticated) { 93 | try { 94 | if (afkCount >= 20) { 95 | session.send(new ServerTitlePacket(5, 10, 5)); 96 | session.send(new ServerTitlePacket(TitleAction.TITLE, "§e§lAre You AFK?")); 97 | session.send(new ServerTitlePacket(TitleAction.SUBTITLE, "Kicked For AFK.")); 98 | Thread.sleep(500); 99 | session.disconnect("§eAre You AFK?"); 100 | } 101 | session.send(new ServerTitlePacket(0, 3000, 0)); 102 | session.send(new ServerTitlePacket(TitleAction.TITLE, "§cPlease Login!")); 103 | session.send(new ServerTitlePacket(TitleAction.SUBTITLE, "Input mail@outlook.com:password in chat")); 104 | afkCount++; 105 | Thread.sleep(2000); 106 | } catch (Exception e) { 107 | e.printStackTrace(); 108 | } 109 | } 110 | } 111 | } 112 | -------------------------------------------------------------------------------- /src/main/java/me/liuli/ez4h/translators/converters/MetadataConverter.java: -------------------------------------------------------------------------------- 1 | package me.liuli.ez4h.translators.converters; 2 | 3 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.EntityMetadata; 4 | import com.github.steveice10.mc.protocol.data.game.entity.metadata.MetadataType; 5 | import com.github.steveice10.mc.protocol.packet.ingame.server.entity.ServerEntityMetadataPacket; 6 | import com.nukkitx.protocol.bedrock.data.entity.EntityData; 7 | import com.nukkitx.protocol.bedrock.data.entity.EntityDataMap; 8 | import com.nukkitx.protocol.bedrock.data.entity.EntityFlag; 9 | import me.liuli.ez4h.minecraft.Client; 10 | import me.liuli.ez4h.minecraft.data.entity.Entity; 11 | import me.liuli.ez4h.utils.BedrockUtil; 12 | 13 | import java.util.ArrayList; 14 | 15 | public class MetadataConverter { 16 | public void convert(EntityDataMap bedrockMetadata, Client client, int entityId) { 17 | ArrayList metadata = new ArrayList<>(); 18 | if (bedrockMetadata.containsKey(EntityData.AIR_SUPPLY)) { 19 | metadata.add(new EntityMetadata(1, MetadataType.INT, (int) bedrockMetadata.getShort(EntityData.AIR_SUPPLY))); 20 | } 21 | if (bedrockMetadata.containsKey(EntityData.NAMETAG)) { 22 | metadata.add(new EntityMetadata(2, MetadataType.STRING, BedrockUtil.lengthCutter(bedrockMetadata.getString(EntityData.NAMETAG), 16))); 23 | } 24 | if (client.getPlayer().getEntityId() != entityId) { 25 | if (bedrockMetadata.containsKey(EntityData.HEALTH)) { 26 | float hp = 20; 27 | try { 28 | hp = bedrockMetadata.getInt(EntityData.HEALTH); 29 | } catch (Exception e) { 30 | hp = bedrockMetadata.getFloat(EntityData.HEALTH); 31 | } 32 | metadata.add(new EntityMetadata(7, MetadataType.FLOAT, hp)); 33 | } 34 | } 35 | client.sendPacket(new ServerEntityMetadataPacket(entityId, metadata.toArray(new EntityMetadata[0]))); 36 | metadata.clear(); 37 | 38 | if (bedrockMetadata.getFlags() == null) 39 | return; 40 | 41 | Entity.Pose pose = Entity.Pose.NONE; 42 | if (bedrockMetadata.getFlags().getFlag(EntityFlag.SNEAKING)) { 43 | pose = Entity.Pose.SNEAK; 44 | } 45 | if (bedrockMetadata.getFlags().getFlag(EntityFlag.ON_FIRE)) { 46 | pose = Entity.Pose.FIRE; 47 | } 48 | if (entityId == client.getPlayer().getEntityId()) { 49 | metadata.add(new EntityMetadata(0, MetadataType.BYTE, pose.data)); 50 | } 51 | Entity entity = client.getData().getEntity(entityId); 52 | if (entity != null) { 53 | boolean canShowName = bedrockMetadata.getFlags().getFlag(EntityFlag.CAN_SHOW_NAME), 54 | hasGravity = bedrockMetadata.getFlags().getFlag(EntityFlag.HAS_GRAVITY); 55 | if (entity.getMetadata().get(EntityFlag.CAN_SHOW_NAME) != canShowName) { 56 | if (canShowName) { 57 | metadata.add(new EntityMetadata(3, MetadataType.BOOLEAN, true)); 58 | } else { 59 | metadata.add(new EntityMetadata(3, MetadataType.BOOLEAN, false)); 60 | } 61 | entity.getMetadata().put(EntityFlag.CAN_SHOW_NAME, canShowName); 62 | } 63 | if (entity.getMetadata().get(EntityFlag.HAS_GRAVITY) != hasGravity) { 64 | if (hasGravity) { 65 | metadata.add(new EntityMetadata(5, MetadataType.BOOLEAN, false)); 66 | } else { 67 | metadata.add(new EntityMetadata(5, MetadataType.BOOLEAN, true)); 68 | } 69 | entity.getMetadata().put(EntityFlag.HAS_GRAVITY, hasGravity); 70 | } 71 | if (!entity.getPose().equals(pose)) { 72 | entity.setPose(pose); 73 | metadata.add(new EntityMetadata(0, MetadataType.BYTE, pose.data)); 74 | } 75 | } 76 | 77 | if (metadata.size() > 0) { 78 | client.sendPacket(new ServerEntityMetadataPacket(entityId, metadata.toArray(new EntityMetadata[metadata.size()]))); 79 | } 80 | // //score below name 81 | // if(entity!=null){ 82 | // if(bedrockMetadata.containsKey(EntityData.SCORE_TAG)){ 83 | // boolean canChange=false; 84 | // String score=BedrockUtils.lengthCutter(bedrockMetadata.getString(EntityData.SCORE_TAG),16); 85 | // if(entity.scoretag==null){ 86 | // canChange=true; 87 | // }else{ 88 | // canChange=!(entity.scoretag.equals(score)); 89 | // } 90 | // if(canChange){ 91 | // entity.scoretag=score; 92 | // client.sendPacket(new ServerScoreboardObjectivePacket("Entity_"+entity.id, ObjectiveAction.ADD,score,ScoreType.INTEGER)); 93 | // client.sendPacket(new ServerDisplayScoreboardPacket(ScoreboardPosition.BELOW_NAME, "Entity_"+entity.id)); 94 | // } 95 | // }else{ 96 | // if(entity.scoretag!=null){ 97 | // entity.scoretag=null; 98 | // client.sendPacket(new ServerScoreboardObjectivePacket("Entity_"+entity.id)); 99 | // } 100 | // } 101 | // }else if(entityId==client.getPlayer().getEntityId()){ 102 | // if(bedrockMetadata.containsKey(EntityData.SCORE_TAG)) { 103 | // client.sendPacket(new ServerScoreboardObjectivePacket("Entity_" + client.getPlayer().getEntityId(), ObjectiveAction.ADD, BedrockUtils.lengthCutter(bedrockMetadata.getString(EntityData.SCORE_TAG),16), ScoreType.INTEGER)); 104 | // client.sendPacket(new ServerDisplayScoreboardPacket(ScoreboardPosition.BELOW_NAME, "Entity_" + client.getPlayer().getEntityId())); 105 | // } 106 | // } 107 | } 108 | } 109 | --------------------------------------------------------------------------------