Examples with Client com.github.steveice10.packetlib.Client used on opensource projects

Example 1 with Client

use of com.github.steveice10.packetlib.Client in project DragonProxy by DragonetMC.

the class EntityMetaTranslator method translateToPE.

public static EntityMetaData translateToPE(UpstreamSession session, EntityMetadata[] pcMeta, EntityType type) {
    /*
     * Following format was fetched from http://wiki.vg/Entities#Entity_meta_Format
         */
    EntityMetaData peMeta = EntityMetaData.createDefault();
    // try (Timing timing = Timings.getEntityTiming(type.name())) {
    if (pcMeta == null || type == EntityType.NONE) {
        // timing.stopTiming();
        return peMeta;
    }
    // System.out.println("Entity + " + type);
    for (EntityMetadata m : pcMeta) {
        // System.out.println(m);
        boolean handle = true;
        try {
            if (m == null)
                continue;
            switch(m.getId()) {
                case // Flags
                0:
                    byte pcFlags = ((byte) m.getValue());
                    // System.out.println("PC flag: " + pcFlags);
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_ONFIRE, (pcFlags & 0x01) > 0);
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_SNEAKING, (pcFlags & 0x02) > 0);
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_RIDING, (pcFlags & 0x04) > 0);
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_SPRINTING, (pcFlags & 0x08) > 0);
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_ACTION, (pcFlags & 0x10) > 0);
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_INVISIBLE, (pcFlags & 0x20) > 0);
                    // peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_GLOWING, (pcFlags & 0x40) > 0); //Not implemented (possible with potions)
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_GLIDING, (pcFlags & 0x80) > 0);
                    break;
                case // Air
                1:
                    peMeta.set(EntityMetaData.Constants.DATA_AIR, new ShortMeta(((Integer) m.getValue()).shortValue()));
                    break;
                case // Name tag
                2:
                    if (!m.getValue().equals("")) {
                        peMeta.set(EntityMetaData.Constants.DATA_NAMETAG, new ByteArrayMeta((String) m.getValue()));
                    }
                    break;
                case // Always show name tag
                3:
                    byte data;
                    if (m.getType() == MetadataType.BYTE) {
                        data = (byte) m.getValue();
                    } else if (m.getType() == MetadataType.INT) {
                        data = (byte) (((int) m.getValue()) & 0xFF);
                    } else {
                        data = 1;
                    }
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_CAN_SHOW_NAMETAG, data > 0);
                    break;
                case // Boolean : Is silent
                4:
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_SILENT, ((boolean) m.getValue()));
                    break;
                case // Boolean : No gravity
                5:
                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_AFFECTED_BY_GRAVITY, (!((boolean) m.getValue())));
                    break;
                case 6:
                    switch(type) {
                        case // VarInt : Shaking power
                        MINECART:
                            peMeta.set(EntityMetaData.Constants.DATA_HURT_TIME, new IntegerMeta((int) m.getValue()));
                            break;
                        case // VarInt : Fuse time
                        PRIMED_TNT:
                            peMeta.set(EntityMetaData.Constants.DATA_FUSE_LENGTH, new IntegerMeta((int) m.getValue()));
                            break;
                        case // Slot : Potion which is thrown
                        POTION:
                            peMeta.set(EntityMetaData.Constants.DATA_TYPE_SLOT, new SlotMeta(ItemBlockTranslator.translateSlotToPE((ItemStack) m.getValue())));
                            break;
                        case // Position : spawn position
                        FALLING_BLOCK:
                            peMeta.set(EntityMetaData.Constants.DATA_BLOCK_TARGET, new BlockPositionMeta(new BlockPosition((Position) m.getValue())));
                            break;
                        case // Float : Radius
                        AREA_EFFECT_CLOUD:
                            peMeta.set(EntityMetaData.Constants.DATA_AREA_EFFECT_CLOUD_RADIUS, new FloatMeta((float) m.getValue()));
                            break;
                        case // VarInt : Hooked entity id + 1, or 0 if there is no hooked entity
                        FISHING_HOOK:
                            break;
                        case // Byte : is critical
                        ARROW:
                            peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_CRITICAL, ((byte) m.getValue() & 0x01) > 0);
                            break;
                        // case TIPPED_ARROW: //VarInt : Color (-1 for no particles)
                        case // VarInt : Time since last hit
                        BOAT:
                            peMeta.set(EntityMetaData.Constants.DATA_HURT_TIME, new IntegerMeta((int) m.getValue()));
                            break;
                        case // OptPosition : Beam target
                        ENDER_CRYSTAL:
                            if (m.getValue() != null) {
                                peMeta.set(EntityMetaData.Constants.DATA_BLOCK_TARGET, new BlockPositionMeta(new BlockPosition((Position) m.getValue())));
                            }
                            break;
                        case // Boolean Invulnerable
                        WITHER_SKULL:
                            peMeta.set(EntityMetaData.Constants.DATA_WITHER_INVULNERABLE_TICKS, new IntegerMeta((int) m.getValue()));
                            break;
                        case // Slot : Firework info
                        FIREWORKS_ROCKET:
                            peMeta.set(EntityMetaData.Constants.DATA_TYPE_SLOT, new SlotMeta(ItemBlockTranslator.translateSlotToPE((ItemStack) m.getValue())));
                            break;
                        // case ITEM_FRAME: //Slot : Item
                        case // Slot : Item
                        ITEM:
                            peMeta.set(EntityMetaData.Constants.DATA_TYPE_SLOT, new SlotMeta(ItemBlockTranslator.translateSlotToPE((ItemStack) m.getValue())));
                            break;
                        default:
                            // (all LIVING) Byte : Hand states, used to trigger blocking/eating/drinking animation.
                            if (m.getValue() instanceof Byte) {
                                peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_ACTION, ((byte) m.getValue() & 0x01) > 0);
                            } else
                                handle = false;
                            // System.out.println("case 6 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 7:
                    switch(type) {
                        // VarInt : Forward direction
                        case BOAT:
                        case // VarInt : Shaking direction
                        MINECART:
                            peMeta.set(EntityMetaData.Constants.DATA_HURT_DIRECTION, new IntegerMeta((int) m.getValue()));
                            break;
                        case // VarInt : Color (only for mob spell particle)
                        AREA_EFFECT_CLOUD:
                            peMeta.set(EntityMetaData.Constants.DATA_AREA_EFFECT_CLOUD_WAITING, new IntegerMeta((int) m.getValue()));
                            break;
                        case // Boolean : Show bottom
                        ENDER_CRYSTAL:
                            break;
                        case // VarInt : Entity ID of entity which used firework (for elytra boosting)
                        FIREWORKS_ROCKET:
                            peMeta.set(EntityMetaData.Constants.DATA_OWNER_EID, new IntegerMeta((int) m.getValue()));
                            break;
                        case ARROW:
                            break;
                        // break;
                        default:
                            // (all LIVING) Float : Health
                            if (m.getValue() instanceof Float) {
                                peMeta.set(EntityMetaData.Constants.DATA_HEALTH, new IntegerMeta((int) ((float) m.getValue())));
                            } else
                                handle = false;
                            // System.out.println("case 7 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 8:
                    switch(type) {
                        case // Boolean : Ignore radius and show effect as single point, not area
                        AREA_EFFECT_CLOUD:
                            break;
                        // Float : Shaking multiplier
                        case MINECART:
                        case // Float : Damage taken
                        BOAT:
                            break;
                        default:
                            // (all LIVING) VarInt : Potion effect color (or 0 if there is no effect)
                            peMeta.set(EntityMetaData.Constants.DATA_POTION_COLOR, new ByteMeta((byte) ((int) m.getValue() & 0xFF)));
                            // System.out.println("case 8 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 9:
                    switch(type) {
                        case // VarInt : Custom block ID and damage
                        MINECART:
                            peMeta.set(EntityMetaData.Constants.DATA_MINECART_DISPLAY_BLOCK, new IntegerMeta((int) m.getValue()));
                            break;
                        case // VarInt : Particle ID
                        AREA_EFFECT_CLOUD:
                            peMeta.set(EntityMetaData.Constants.DATA_AREA_EFFECT_CLOUD_PARTICLE_ID, new IntegerMeta((int) m.getValue()));
                            break;
                        case // VarInt : Type (0=oak, 1=spruce, 2=birch, 3=jungle, 4=acacia, 5=dark oak)
                        BOAT:
                            peMeta.set(20, /* woodID */
                            new ByteMeta((byte) ((Integer) m.getValue()).byteValue()));
                            break;
                        default:
                            // (all LIVING) Boolean : Is potion effect ambient: reduces the number of particles generated by potions to 1/5 the normal amount
                            peMeta.set(EntityMetaData.Constants.DATA_POTION_AMBIENT, new ByteMeta((byte) (((boolean) m.getValue()) ? 0x01 : 0x00)));
                            // System.out.println("case 9 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 10:
                    switch(type) {
                        case // VarInt : Custom block Y position (in 16ths of a block)
                        MINECART:
                            peMeta.set(EntityMetaData.Constants.DATA_MINECART_DISPLAY_OFFSET, new IntegerMeta((int) m.getValue()));
                            break;
                        case // VarInt : Particle parameter 1
                        AREA_EFFECT_CLOUD:
                            break;
                        case // Boolean : Right paddle turning
                        BOAT:
                            peMeta.set(EntityMetaData.Constants.DATA_PADDLE_TIME_RIGHT, new IntegerMeta(20));
                            break;
                        default:
                            // Not supported yet
                            break;
                    }
                    break;
                case 11:
                    switch(type) {
                        case // Boolean : Show custom block
                        MINECART:
                            peMeta.set(EntityMetaData.Constants.DATA_MINECART_HAS_DISPLAY, new ByteMeta((byte) (((boolean) m.getValue()) ? 0x01 : 0x00)));
                            break;
                        case // VarInt : Particle parameter 2
                        AREA_EFFECT_CLOUD:
                            break;
                        case // Boolean : Left paddle turning
                        BOAT:
                            peMeta.set(EntityMetaData.Constants.DATA_PADDLE_TIME_LEFT, new IntegerMeta(20));
                            break;
                        case // Byte : see http://wiki.vg/Entity_metadata#ArmorStand
                        ARMOR_STAND:
                            break;
                        case // Float : Additional Hearts
                        PLAYER:
                            // Not supported yet
                            break;
                        default:
                            // System.out.println("case 11 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 12:
                    switch(type) {
                        case MINECART:
                            if (m.getValue() instanceof Boolean) {
                                // Boolean : Is powered
                                peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_POWERED, ((boolean) m.getValue()));
                            }
                            if (m.getValue() instanceof String) {
                            // String : Command
                            // 
                            }
                            break;
                        case // Rotation : Head rotation
                        ARMOR_STAND:
                            break;
                        case // Byte : Is hanging
                        BAT:
                            // peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_SITTING, (((byte) m.getValue()) ? 0x01 : 0x00)); //wrong data
                            break;
                        // Byte : Is player-created
                        case IRON_GOLEM:
                        // Byte : has no pumpkin hat
                        case SNOWMAN:
                        case // Direction : Facing direction
                        SHULKER:
                            break;
                        case // Byte : 0x01 = Is on fire
                        BLAZE:
                            peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_ONFIRE, ((byte) m.getValue()) == 0x01);
                            break;
                        // VarInt	State (-1 = idle, 1 = fuse)
                        case CREEPER:
                        // Byte	Spell (0: none, 1: summon vex, 2: attack, 3: wololo)
                        case EVOCATION_ILLAGER:
                        // Byte : 0x01 = Is in attack mode
                        case VEX:
                        // Byte : 0x01 = Has target (aggressive state)
                        case VINDICATOR:
                        case // Boolean : Is swinging arms
                        SKELETON:
                            break;
                        case // Byte : 0x01 = Is climbing
                        SPIDER:
                            peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_WALLCLIMBING, ((byte) m.getValue()) == 0x01);
                            break;
                        // Boolean : Is drinking potion
                        case WITCH:
                        // VarInt : Center head's target (entity ID, or 0 if no target)
                        case WITHER:
                        // Opt BlockID : Carried block
                        case ENDERMAN:
                        // VarInt : Dragon phase
                        case ENDER_DRAGON:
                        case // Boolean : Is attacking
                        GHAST:
                            break;
                        // VarInt : Size
                        case SLIME:
                        case // VarInt : Size
                        MAGMA_CUBE:
                            peMeta.set(EntityMetaData.Constants.DATA_SCALE, new FloatMeta((int) m.getValue()));
                            break;
                        case // VarInt : Score
                        PLAYER:
                            // Not supported yet
                            break;
                        default:
                            // ZOMBIE, AGEABLE //Boolean Is baby
                            {
                                if (m.getValue() instanceof Boolean) {
                                    peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_BABY, ((boolean) m.getValue()));
                                    if ((boolean) m.getValue()) {
                                        peMeta.set(EntityMetaData.Constants.DATA_SCALE, new FloatMeta(0.5f));
                                    }
                                } else
                                    handle = false;
                                break;
                            }
                    }
                    break;
                case 13:
                    switch(type) {
                        case // Chat : Last output
                        MINECART:
                            if (m.getValue() instanceof String) {
                            // 
                            }
                        case // Rotation : Body rotation
                        ARMOR_STAND:
                            break;
                        case // Byte : see http://wiki.vg/Entity_metadata#AbstractHorse
                        HORSE:
                            break;
                        case // Byte 0x0F Color (matches dye damage values) //0x10 Is sheared
                        SHEEP:
                            if (((byte) (m.getValue()) & 0x10) == 0) {
                                peMeta.set(EntityMetaData.Constants.DATA_COLOR, new ByteMeta((byte) (m.getValue())));
                            } else {
                                peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_SHEARED, true);
                            }
                            break;
                        case // VarInt : Type
                        RABBIT:
                            peMeta.set(EntityMetaData.Constants.DATA_VARIANT, new IntegerMeta((int) m.getValue()));
                            break;
                        case // Boolean : Has saddle
                        PIG:
                            peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_SADDLED, ((boolean) m.getValue()));
                            break;
                        // Boolean : Standing up
                        case POLAR_BEAR:
                        // VarInt : Profession (Farmer = 0, Librarian = 1, Priest = 2, Blacksmith = 3, Butcher = 4, Nitwit = 5)
                        case VILLAGER:
                        case // OptPosition : Attachment position
                        SHULKER:
                            break;
                        case // Boolean : Is charged
                        CREEPER:
                            peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_CHARGED, ((boolean) m.getValue()));
                            break;
                        // VarInt : Left(?) head's target (entity ID, or 0 if no target)
                        case WITHER:
                        // VarInt : Unused (previously type)
                        case ZOMBIE:
                        case // Boolean : Is screaming
                        ENDERMAN:
                            break;
                        case // Byte : The Displayed Skin Parts bit mask that is sent in Client Settings
                        PLAYER:
                            // Not supported yet
                            break;
                        default:
                            // System.out.println("case 13 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 14:
                    switch(type) {
                        // Rotation : Left arm rotation
                        case ARMOR_STAND:
                        // OptUUID : Owner
                        case HORSE:
                        // VarInt : Total time to "boost" with a carrot on a stick for
                        case PIG:
                        case // Byte : Shield height
                        SHULKER:
                            break;
                        case // Boolean : Is ignited
                        CREEPER:
                            peMeta.setGenericFlag(EntityMetaData.Constants.DATA_FLAG_IGNITED, ((boolean) m.getValue()));
                            break;
                        // VarInt : Right(?) head's target (entity ID, or 0 if no target)
                        case WITHER:
                        case // Boolean : Are hands held up
                        ZOMBIE:
                            break;
                        case // Byte : Main hand (0 : Left, 1 : Right)
                        PLAYER:
                            // Not supported yet
                            break;
                        default:
                            // System.out.println("case 14 " + type.name() + " " + m.getValue());
                            break;
                    }
                    break;
                case 15:
                    switch(type) {
                        case // Rotation : Right arm rotation
                        ARMOR_STAND:
                            break;
                        case HORSE:
                            if (m.getValue() instanceof Integer) {
                                // VarInt : Variant (Color & Style)
                                peMeta.set(EntityMetaData.Constants.DATA_VARIANT, new IntegerMeta((int) m.getValue()));
                            }
                            if (m.getValue() instanceof Boolean) {
                            // Boolean : Has Chest
                            // 
                            }
                            break;
                        case // VarInt	Type (0 = untamed, 1 = tuxedo, 2 = tabby, 3 = siamese). Used to render regardless as to whether it is tamed or not.
                        OCELOT:
                            peMeta.set(EntityMetaData.Constants.DATA_VARIANT, new IntegerMeta((int) m.getValue()));
                            break;
                        case // Float : Damage taken (used for tail rotation)
                        WOLF:
                            break;
                        case // VarInt	Variant (0: red/blue, 1: blue, 2: green, 3: yellow/blue, 4: silver)
                        PARROT:
                            peMeta.set(EntityMetaData.Constants.DATA_VARIANT, new IntegerMeta((int) m.getValue()));
                            break;
                        case // Byte : Color (dye color)
                        SHULKER:
                            peMeta.set(EntityMetaData.Constants.DATA_VARIANT, new ByteMeta((byte) m.getValue()));
                            break;
                        case // VarInt : Invulnerable time
                        WITHER:
                            // case ZOMBIE_VILLAGER: //Boolean : Is converting
                            break;
                        case // NBT Tag : Left shoulder entity data (for occupying parrot)
                        PLAYER:
                            // Not supported yet
                            break;
                    }
                    break;
                case 16:
                    switch(type) {
                        // Rotation : Left leg rotation
                        case ARMOR_STAND:
                        // VarInt : Armor (0: none, 1: iron, 2: gold, 3: diamond)
                        case HORSE:
                        // Boolean : Is begging
                        case WOLF:
                        // case ZOMBIE_VILLAGER: //VarInt : Profession
                        case // NBT Tag : Right shoulder entity data (for occupying parrot)
                        PLAYER:
                            // Not supported yet
                            break;
                    }
                case 17:
                    switch(type) {
                        // Rotation : Right leg rotation
                        case ARMOR_STAND:
                        case // VarInt : Collar color (values are those used with dyes)
                        WOLF:
                            break;
                    }
                    break;
            }
            if (type == EntityType.GIANT_ZOMBIE) {
                peMeta.set(EntityMetaData.Constants.DATA_SCALE, new FloatMeta(6));
            }
            if (!handle)
                DragonProxy.getInstance().getLogger().debug("Not supported entity meta (" + type.name() + ") : " + m.toString());
        } catch (Exception p_Ex) {
            // timing.stopTiming();
            p_Ex.printStackTrace();
        }
    }
    // }
    return peMeta;
}

Example 2 with Client

use of com.github.steveice10.packetlib.Client in project DragonProxy by DragonetMC.

the class PingThread method setClient.

private void setClient() {
    this.client = new Client(DragonProxy.getInstance().getConfig().remote_server_addr, DragonProxy.getInstance().getConfig().remote_server_port, new MinecraftProtocol(SubProtocol.STATUS), new TcpSessionFactory());
    this.client.getSession().setFlag(MinecraftConstants.SERVER_INFO_HANDLER_KEY, (ServerInfoHandler) (session, info) -> {
        this.info = info;
        this.client.getSession().disconnect(null);
    });
}

Example 3 with Client

use of com.github.steveice10.packetlib.Client in project DragonProxy by DragonetMC.

the class PCDownstreamSession method connect.

public void connect(String addr, int port) {
    if (this.protocol == null) {
        // Clear the flags
        upstream.onConnected();
        upstream.disconnect("ERROR! ");
        return;
    }
    remoteClient = new Client(addr, port, protocol, new TcpSessionFactory());
    remoteClient.getSession().setConnectTimeout(5);
    remoteClient.getSession().setReadTimeout(5);
    remoteClient.getSession().setWriteTimeout(5);
    remoteClient.getSession().addListener(new SessionAdapter() {

        @Override
        public void connected(ConnectedEvent event) {
            proxy.getLogger().info(proxy.getLang().get(Lang.MESSAGE_REMOTE_CONNECTED, upstream.getUsername(), upstream.getRemoteAddress()));
            upstream.onConnected();
        }

        @Override
        public void packetSending(PacketSendingEvent event) {
            if (proxy.getAuthMode().equalsIgnoreCase("hybrid")) {
                if (protocol.getSubProtocol() == SubProtocol.HANDSHAKE && event.getPacket() instanceof HandshakePacket) {
                    HandshakePacket packet = event.getPacket();
                    String host = remoteClient.getSession().getHost() + "\0" + upstream.getProfile().getChainJWT();
                    packet = new HandshakePacket(packet.getProtocolVersion(), host, packet.getPort(), packet.getIntent());
                    event.setPacket(packet);
                }
            }
        }

        @Override
        public void disconnected(DisconnectedEvent event) {
            System.out.println("DisconnectedEvent " + event.getCause() + " " + event.getReason());
            upstream.disconnect(proxy.getLang().get(event.getReason()));
        }

        @Override
        public void disconnecting(DisconnectingEvent event) {
            System.out.println("DisconnectingEvent " + event.getCause() + " " + event.getReason());
            upstream.disconnect(proxy.getLang().get(event.getReason()));
        }

        @Override
        public void packetReceived(PacketReceivedEvent event) {
            // Handle the packet
            try {
                PEPacket[] packets = PacketTranslatorRegister.translateToPE(upstream, event.getPacket());
                if (packets == null) {
                    return;
                }
                if (packets.length <= 0) {
                    return;
                }
                if (packets.length == 1) {
                    upstream.sendPacket(packets[0]);
                } else {
                    upstream.sendAllPackets(packets, false);
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }
        }
    });
    remoteClient.getSession().connect();
}

Example 4 with Client

use of com.github.steveice10.packetlib.Client in project DragonProxy by DragonetMC.

the class PEPacketProcessor method handlePacket.

// this method should be in UpstreamSession
public void handlePacket(PEPacket packet) {
    if (packet == null)
        return;
    if (!client.getProxy().getConfig().disable_packet_events) {
        PacketfromPlayerEvent packetEvent = new PacketfromPlayerEvent(client, packet);
        client.getProxy().getEventManager().callEvent(packetEvent);
        if (packetEvent.isCancelled()) {
            return;
        }
    }
    // Wait for player logginig in
    if ("online_login_wait".equals(this.client.getDataCache().get(CacheKey.AUTHENTICATION_STATE))) {
        if (packet.pid() == ProtocolInfo.MOVE_PLAYER_PACKET) {
            InputComponent username = new InputComponent(this.client.getProxy().getLang().get(Lang.FORM_LOGIN_USERNAME)).setPlaceholder("steve@example.com");
            InputComponent password = new InputComponent(this.client.getProxy().getLang().get(Lang.FORM_LOGIN_PASSWORD)).setPlaceholder("123456");
            if (this.client.getProxy().getConfig().auto_login) {
                username.setDefaultValue(this.client.getProxy().getConfig().online_username);
                password.setDefaultValue(this.client.getProxy().getConfig().online_password);
            }
            // client.getDataCache().put(CacheKey.AUTHENTICATION_STATE, "online_login");
            ModalFormRequestPacket packetForm = new ModalFormRequestPacket();
            CustomFormComponent form = new CustomFormComponent(this.client.getProxy().getLang().get(Lang.FORM_LOGIN_TITLE));
            form.addComponent(new LabelComponent(this.client.getProxy().getLang().get(Lang.FORM_LOGIN_DESC)));
            form.addComponent(new LabelComponent(this.client.getProxy().getLang().get(Lang.FORM_LOGIN_PROMPT)));
            form.addComponent(username);
            form.addComponent(password);
            packetForm.formId = 1;
            packetForm.formData = form.serializeToJson().toString();
            this.client.sendPacket(packetForm, true);
            return;
        }
        if (packet.pid() == ProtocolInfo.MODAL_FORM_RESPONSE_PACKET) {
            try {
                this.client.sendChat(this.client.getProxy().getLang().get(Lang.MESSAGE_LOGIN_PROGRESS));
                ModalFormResponsePacket formResponse = (ModalFormResponsePacket) packet;
                JsonArray array = JsonUtil.parseArray(formResponse.formData);
                this.client.getDataCache().remove(CacheKey.AUTHENTICATION_STATE);
                this.client.authenticate(array.get(2).getAsString(), array.get(3).getAsString(), authProxy);
            } catch (Exception ex) {
                this.client.sendChat(this.client.getProxy().getLang().get(Lang.MESSAGE_ONLINE_LOGIN_FAILD));
            }
            return;
        }
    }
    switch(packet.pid()) {
        case ProtocolInfo.BATCH_PACKET:
            DragonProxy.getInstance().getLogger().debug("Received batch packet from client !");
            break;
        case ProtocolInfo.LOGIN_PACKET:
            this.client.onLogin((LoginPacket) packet);
            break;
        case ProtocolInfo.RESOURCE_PACK_CLIENT_RESPONSE_PACKET:
            if (!this.client.isLoggedIn())
                this.client.postLogin();
            break;
        default:
            if (this.client.getDownstream() == null || !this.client.getDownstream().isConnected())
                break;
            if (enableForward.get() && FORWARDED_PACKETS.contains(packet.getClass())) {
                BinaryStream bis = new BinaryStream();
                bis.putString("PacketForward");
                bis.putByteArray(packet.getBuffer());
                ClientPluginMessagePacket msg = new ClientPluginMessagePacket("DragonProxy", bis.getBuffer());
                client.getDownstream().send(msg);
            } else // IMPORTANT Do not send packet until client is connected !
            if (client.isSpawned()) {
                Packet[] translated = PacketTranslatorRegister.translateToPC(this.client, packet);
                if (translated == null || translated.length == 0)
                    break;
                client.getDownstream().send(translated);
            }
            break;
    }
}