Merge remote-tracking branch 'origin/spring'

# Conflicts:
#	pom.xml
#	src/main/java/mc/core/Main.java
#	src/main/java/mc/core/NetStream.java
#	src/main/java/mc/core/Server.java
#	src/main/java/mc/core/StartServerException.java
#	src/main/java/mc/core/netty/NettyServer.java
#	src/main/java/mc/core/netty/PacketDecoder.java
#	src/main/java/mc/core/netty/PacketEncoder.java
#	src/main/java/mc/core/netty/PacketHandler.java
#	src/main/java/mc/core/netty/State.java
#	src/main/java/mc/core/netty/packets/PingPacket.java

pom.xml

@@ -14,6 +14,7 @@
         <java.version>1.8</java.version>
         <slf4j.version>1.7.21</slf4j.version>
         <log4j.version>2.5</log4j.version>
+        <spring.version>4.2.5.RELEASE</spring.version>
         <netty.version>4.1.22.Final</netty.version>
     </properties>
 
@@ -24,6 +25,11 @@
             <artifactId>slf4j-api</artifactId>
             <version>${slf4j.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>jcl-over-slf4j</artifactId>
+            <version>${slf4j.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
@@ -35,28 +41,18 @@
             <version>${log4j.version}</version>
         </dependency>
 
-        <!-- COMPONENTS -->
+        <!-- SPRING -->
         <dependency>
-            <groupId>org.projectlombok</groupId>
+            <groupId>org.springframework</groupId>
-            <artifactId>lombok</artifactId>
+            <artifactId>spring-context</artifactId>
-            <version>1.16.16</version>
+            <version>${spring.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
-        <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>2.8.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.google.guava</groupId>
-            <artifactId>guava</artifactId>
-            <version>24.1-jre</version>
-        </dependency>
-        <dependency>
-            <groupId>commons-io</groupId>
-            <artifactId>commons-io</artifactId>
-            <version>2.6</version>
-        </dependency>
-
 
         <!-- Netty -->
         <dependency>
@@ -65,6 +61,27 @@
             <version>${netty.version}</version>
         </dependency>
 
+        <!-- COMPONENTS -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.16</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>24.1-jre</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.2</version>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/mc/core/ByteArrayOutputNetStream.java

@@ -0,0 +1,40 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core;
+
+import java.io.ByteArrayOutputStream;
+
+public class ByteArrayOutputNetStream extends NetStream {
+    private ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+    @Override
+    public byte readByte() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void readBytes(byte[] buffer) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public int readUnsignedShort() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void writeByte(int value) {
+        baos.write(value);
+    }
+
+    @Override
+    public void writeBytes(byte[] buffer) {
+        baos.write(buffer, 0, buffer.length);
+    }
+
+    public byte[] toByteArray() {
+        return baos.toByteArray();
+    }
+}

src/main/java/mc/core/CSPacket.java

@@ -0,0 +1,10 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core;
+
+public interface CSPacket {
+    default void readSelf(NetStream netStream) {
+    }
+}

src/main/java/mc/core/Config.java

@@ -0,0 +1,13 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core;
+
+public interface Config {
+    int getMaxPlayers();
+    String getDescriptionServer();
+    byte[] getFaviconBase64();
+    String getHost();
+    int getPort();
+}

src/main/java/mc/core/Main.java

@@ -5,18 +5,22 @@
 package mc.core;
 
 import lombok.extern.slf4j.Slf4j;
-import mc.core.netty.NettyServer;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
 
 @Slf4j
 public class Main {
+    public static ApplicationContext appContext; //FIXME
+
     public static void main(String[] args) {
-        log.info("Start server");
+        appContext = new ClassPathXmlApplicationContext("spring.xml");
-        Server server = new NettyServer();
+        Config config = appContext.getBean("config", Config.class);
+
+        Server server = appContext.getBean("server", Server.class);
         try {
-            server.start("127.0.0.1", 25565);
+            server.start(config.getHost(), config.getPort());
         } catch (StartServerException e) {
-            log.error("Starting server error", e);
+            log.error("Can't start server", e);
-            server.stop();
         }
     }
 }

src/main/java/mc/core/NetStream.java

@@ -4,29 +4,82 @@
  */
 package mc.core;
 
-public interface NetStream {
+import lombok.Getter;
-    byte readByte();
+import lombok.Setter;
-    void writeByte(byte value);
+import lombok.extern.slf4j.Slf4j;
 
-    int readBytes(byte[] buffer);
+import java.nio.charset.StandardCharsets;
-    void writeBytes(byte[] buffer);
 
-    int readBytes(byte[] buffer, int offset, int length);
+@Slf4j
-    void writeBytes(byte[] buffer, int offset, int length);
+public abstract class NetStream {
+    @Getter
+    @Setter
+    private int expectedSize;
 
-    int readVarInt();
+    public static int sizeVarInt(final int value) {
-    void writeVarInt(int value);
+        byte size = 0;
+        int v = value;
+
+        do {
+            v >>>= 7;
+            size++;
+        } while (v != 0);
+
+        return size;
+    }
+
+    public int readVarInt() {
+        int result = 0;
+        byte read;
+        byte numRead = 0;
+
+        do {
+            read = readByte();
+            int value = (read & 0b01111111);
+            result |= (value << (7 * numRead));
+
+            numRead++;
+            if (numRead > 5) {
+                log.debug("VarInt is too big!");
+                break;
+            }
+        } while ((read & 0b10000000) != 0);
+
+        return result;
+    }
+
+    public void writeVarInt(int value) {
+        do {
+            byte temp = (byte)(value & 0b01111111);
+            value >>>= 7;
+            if (value != 0) {
+                temp |= 0b10000000;
+            }
+
+            writeByte(temp);
+        } while (value != 0);
+    }
+
+    public String readString() {
+        int length = readVarInt();
+
+        byte[] buffer = new byte[length];
+        readBytes(buffer);
+
+        return new String(buffer, StandardCharsets.UTF_8);
+    }
+
+    public void writeString(String value) {
+        writeVarInt(value.length());
+        writeBytes(value.getBytes());
+    }
+
+    public abstract byte readByte();
+    public abstract void readBytes(byte[] buffer);
+    public abstract int readUnsignedShort();
+
+    public abstract void writeByte(int value);
+    public abstract void writeBytes(byte[] buffer);
 
-    long readVarLong();
-    void writeVarLong(long value);
 
-    String readString();
-    void writeString(String value);
-
-    int readUnsignedShort();
-
-    void skipBytes(int count);
-
-    void setExpectedLength(int value);
-    int getExpectedLength();
 }

src/main/java/mc/core/SCPacket.java

@@ -0,0 +1,9 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core;
+
+public interface SCPacket {
+    byte[] toByteArray();
+}

src/main/java/mc/core/Server.java

@@ -6,6 +6,4 @@ package mc.core;
 
 public interface Server {
     void start(String host, int port) throws StartServerException;
-    void stop();
-    boolean isRunning();
 }

src/main/java/mc/core/embedded/ConfigFromSpring.java

@@ -0,0 +1,41 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.embedded;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import mc.core.Config;
+import org.apache.commons.io.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Base64;
+
+@Slf4j
+@Getter
+public class ConfigFromSpring implements Config {
+    @Setter
+    private String descriptionServer;
+    private byte[] faviconBase64;
+    @Setter
+    private int maxPlayers;
+    @Setter
+    private String host;
+    @Setter
+    private int port;
+
+    public void setFaviconBase64(File faviconImageFile) {
+        log.debug("faviconImageFile: {}", faviconImageFile.getAbsolutePath());
+        try {
+            faviconBase64 = Base64.getEncoder().encode(
+                FileUtils.readFileToByteArray(faviconImageFile)
+            );
+        } catch (IOException e) {
+            log.warn("Can't load favicon", e);
+            faviconBase64 = null;
+        }
+    }
+}

src/main/java/mc/core/netty/NettyServer.java

@@ -13,7 +13,6 @@ import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.logging.LoggingHandler;
 import mc.core.Server;
 import mc.core.StartServerException;
-import mc.core.netty.handlers.HandshakeHandler;
 
 public class NettyServer implements Server {
     private EventLoopGroup bossGroup, workerGroup;
@@ -49,25 +48,10 @@ public class NettyServer implements Server {
 
         ServerBootstrap serverBootstrap = buildServerBootstrap();
 
-        EventBus.getInstance().listenIncomingPacket(new HandshakeHandler());
-
         try {
             serverBootstrap.bind(host, port).sync().channel().closeFuture().sync();
         } catch (InterruptedException e) {
             throw new StartServerException(e);
         }
     }
-
-    @Override
-    public void stop() {
-        workerGroup.shutdownGracefully();
-        bossGroup.shutdownGracefully();
-    }
-
-    @Override
-    public boolean isRunning() {
-        return bossGroup != null
-                && workerGroup != null
-                && !(bossGroup.isShutdown() && workerGroup.isShutdown());
-    }
 }

src/main/java/mc/core/netty/PacketDecoder.java

@@ -6,44 +6,65 @@ package mc.core.netty;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.ReplayingDecoder;
+import io.netty.handler.codec.ByteToMessageDecoder;
 import lombok.extern.slf4j.Slf4j;
+import mc.core.CSPacket;
 import mc.core.NetStream;
-import mc.core.Packet;
+import mc.core.netty.packets.RawPacket;
 
 import java.util.List;
-import java.util.Optional;
 
 @Slf4j
-public class PacketDecoder extends ReplayingDecoder<Packet> {
+public class PacketDecoder extends ByteToMessageDecoder {
     @Override
-    protected void decode(ChannelHandlerContext context, ByteBuf byteBuf, List<Object> list) throws Exception {
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
-        NetStream netStream = new WrapperByteBufNetStream(byteBuf);
+        ctx.channel().attr(State.ATTR_STATE).set(State.STATUS);
+        ctx.fireChannelActive();
+    }
 
-        int length = netStream.readVarInt();
+    @Override
-        netStream.setExpectedLength(length);
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        ctx.channel().attr(State.ATTR_STATE).set(null);
+        ctx.fireChannelInactive();
+    }
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+        State state = ctx.channel().attr(State.ATTR_STATE).get();
+        NetStream netStream = new WrapperNetStream(in);
+
+        log.debug("ByteBuf readableBytes: {}", in.readableBytes());
+
+        int size = netStream.readVarInt();
+        log.debug("Pkt-Size: {}", size);
         int id = netStream.readVarInt();
-        log.debug("PktLEN: {} | PktID: {}", length, id);
+        log.debug("Pkt-Id: {}", id);
 
-        State state = context.channel().attr(State.ATTR_STATE).get();
+        Class<? extends CSPacket> clientSidePacketClass = state.getClientSidePacket(id);
-        log.debug("Current state: {}:{}", state.getId(), state.name());
+        if (clientSidePacketClass == null) {
-        Optional<Class<? extends Packet>> packetClass = state.getPacketClass(id);
+            log.warn("Unknown packet: {}:{}", state.name(), id);
 
-        if (packetClass.isPresent()) {
+            if (log.isDebugEnabled()) {
-            log.debug("Detect packet: {}", packetClass.get().getSimpleName());
+                byte[] rawData;
-            Packet packet = packetClass.get().newInstance();
+                if (size > in.readableBytes()) {
-            packet.readSelf(netStream);
+                    rawData = new byte[in.readableBytes()];
-            list.add(packet);
+                } else {
-            if (length < packet.getSize()) {
+                    rawData = new byte[size - NetStream.sizeVarInt(id)];
-                log.warn("WTF?! length < packet.getSize() !!");
+                }
-                log.warn("Packet size: {}", packet.getSize());
+                in.readBytes(rawData);
-            } else if (length > packet.getSize()) {
+
-                log.debug("skipBytes {}", length - packet.getSize());
+                RawPacket packet = new RawPacket();
-                byteBuf.skipBytes(length - packet.getSize());
+                packet.setRawData(rawData);
+                out.add(packet);
             }
         } else {
-            list.add(new UnknownPacket(length, id));
+            CSPacket packet = clientSidePacketClass.newInstance();
-            byteBuf.skipBytes(length-1);
+            netStream.setExpectedSize(size - NetStream.sizeVarInt(id));
-        }
+            packet.readSelf(netStream);
+            out.add(packet);
+        }
+
+        log.debug("ByteBuf readableBytes: {}", in.readableBytes());
+        in.skipBytes(in.readableBytes());
     }
 }

src/main/java/mc/core/netty/PacketEncoder.java

@@ -7,11 +7,26 @@ package mc.core.netty;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToByteEncoder;
-import mc.core.Packet;
+import lombok.extern.slf4j.Slf4j;
+import mc.core.NetStream;
+import mc.core.SCPacket;
 
-public class PacketEncoder extends MessageToByteEncoder<Packet> {
+@Slf4j
+public class PacketEncoder extends MessageToByteEncoder<SCPacket> {
     @Override
-    protected void encode(ChannelHandlerContext context, Packet packet, ByteBuf byteBuf) throws Exception {
+    protected void encode(ChannelHandlerContext ctx, SCPacket pkt, ByteBuf out) throws Exception {
-        packet.writeSelf(new WrapperByteBufNetStream(byteBuf));
+        State state = ctx.channel().attr(State.ATTR_STATE).get();
+        Integer id = state.getServerSidePaclet(pkt.getClass());
+        if (id == null) {
+            log.error("Packet not found: {}:{}", state.name(), pkt.getClass().getSimpleName());
+            return;
+        }
+
+        byte[] bytes = pkt.toByteArray();
+        NetStream netStream = new WrapperNetStream(out);
+
+        netStream.writeVarInt(bytes.length + NetStream.sizeVarInt(id));
+        netStream.writeVarInt(id);
+        netStream.writeBytes(bytes);
     }
 }

src/main/java/mc/core/netty/PacketHandler.java

@@ -4,32 +4,58 @@
  */
 package mc.core.netty;
 
+import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import mc.core.Packet;
+import mc.core.CSPacket;
-import mc.core.netty.packets.HandshakeRequestPacket;
+import mc.core.Config;
-import mc.core.netty.packets.HandshakeResponsePacket;
+import mc.core.Main;
+import mc.core.netty.packets.PingPacket;
+import mc.core.netty.packets.StatusRequest;
+import mc.core.netty.packets.StatusResponse;
 
-import static mc.core.netty.Utils.equalsPacket;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Optional;
 
 @Slf4j
-public class PacketHandler extends SimpleChannelInboundHandler<Packet> {
+public class PacketHandler extends SimpleChannelInboundHandler<CSPacket> {
     @Override
-    public void channelActive(ChannelHandlerContext context) throws Exception {
+    protected void channelRead0(ChannelHandlerContext ctx, CSPacket packet) throws Exception {
-        context.channel().attr(State.ATTR_STATE).set(State.Handshaking);
+        log.debug("{}: {}", packet.getClass().getSimpleName(), packet.toString());
+
+        Optional<Method> optionalMethod = Arrays.stream(this.getClass().getDeclaredMethods())
+                .filter(method -> method.getName().equals("on" + packet.getClass().getSimpleName())
+                    && method.getParameterCount() == 2
+                    && method.getParameterTypes()[0].isAssignableFrom(Channel.class)
+                    && method.getParameterTypes()[1].isAssignableFrom(packet.getClass()))
+                .findFirst();
+
+        if (optionalMethod.isPresent()) {
+            Method method = optionalMethod.get();
+            method.invoke(this, ctx.channel(), packet);
+        }
     }
 
-    @Override
+    public void onStatusRequest(Channel channel, StatusRequest packet) {
-    protected void channelRead0(ChannelHandlerContext context, Packet packet) throws Exception {
+        if (!packet.getNextState().equals(State.UNKNOWN)) {
-        log.info("Packet: {} | Data: {}",
+            channel.attr(State.ATTR_STATE).set(packet.getNextState());
-                packet.getClass().getSimpleName(),
+        }
-                packet.toString());
 
-        EventBus.getInstance().eventIncomingPacket(
+        if (packet.getNextState().equals(State.STATUS)) {
-                context.channel().attr(State.ATTR_STATE).get().getId(),
+            Config config = Main.appContext.getBean("config", Config.class); //FIXME
-                packet,
+            StatusResponse pkt = new StatusResponse();
-                context.channel()
+            pkt.setDescription(config.getDescriptionServer());
-        );
+            pkt.setMaxOnline(config.getMaxPlayers());
+            pkt.setFaviconBase64(config.getFaviconBase64());
+
+            channel.writeAndFlush(pkt);
+        }
+    }
+
+    public void onPingPacket(Channel channel, PingPacket packet) {
+        channel.writeAndFlush(packet);
     }
 }

src/main/java/mc/core/netty/State.java

@@ -4,45 +4,52 @@
  */
 package mc.core.netty;
 
-import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableBiMap;
 import io.netty.util.AttributeKey;
-import lombok.Getter;
+import lombok.RequiredArgsConstructor;
-import mc.core.Packet;
+import mc.core.CSPacket;
-import mc.core.netty.packets.HandshakeRequestPacket;
+import mc.core.SCPacket;
 import mc.core.netty.packets.PingPacket;
+import mc.core.netty.packets.StatusRequest;
+import mc.core.netty.packets.StatusResponse;
 
 import java.util.Arrays;
+import java.util.Map;
 import java.util.Optional;
 
+@RequiredArgsConstructor
 public enum State {
-    Unknown(0, ImmutableBiMap.of()),
+    UNKNOWN(0, ImmutableMap.of(), ImmutableMap.of()),
-    Handshaking(1, ImmutableBiMap.of(
+    STATUS(1,
-            0, HandshakeRequestPacket.class,
+        ImmutableMap.of(
+            0, StatusRequest.class,
             1, PingPacket.class
-    ));
+        ),
-    //Login(2, ...)
+        ImmutableMap.of(
+            StatusResponse.class, 0,
+            PingPacket.class, 1
+        )
+    );
 
     public static final AttributeKey<State> ATTR_STATE = AttributeKey.newInstance("ATTR_STATE");
 
-    public static Optional<State> getById(final int id) {
+    public static State getStateById(final int id) {
-        return Arrays.stream(State.values()).filter(state -> state.id == id).findFirst();
+        Optional<State> optionalState = Arrays.stream(State.values())
+                .filter(state -> state.id == id)
+                .findFirst();
+
+        return optionalState.orElse(UNKNOWN);
     }
 
-    @Getter
     private final int id;
-    private final BiMap<Integer, Class<? extends Packet>> requestMap;
+    private final Map<Integer, Class<? extends CSPacket>> clientSidePackets;
+    private final Map<Class<? extends SCPacket>, Integer> serverSidePackets;
 
-    State(int id, BiMap<Integer, Class<? extends Packet>> requestMap) {
+    public Class<? extends CSPacket> getClientSidePacket(final int packetId) {
-        this.id = id;
+        return clientSidePackets.get(packetId);
-        this.requestMap = requestMap;
     }
 
-    public Optional<Class<? extends Packet>> getPacketClass(int id) {
+    public Integer getServerSidePaclet(final Class<? extends SCPacket> clazz) {
-        return Optional.ofNullable(requestMap.get(id));
+        return serverSidePackets.get(clazz);
-    }
-
-    public Optional<Integer> getPacketId(Class<? extends Packet> clazz) {
-        return Optional.ofNullable(requestMap.inverse().get(clazz));
     }
 }

src/main/java/mc/core/netty/WrapperNetStream.java

@@ -0,0 +1,39 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty;
+
+import io.netty.buffer.ByteBuf;
+import lombok.RequiredArgsConstructor;
+import mc.core.NetStream;
+
+@RequiredArgsConstructor
+public class WrapperNetStream extends NetStream {
+    private final ByteBuf byteBuf;
+
+    @Override
+    public byte readByte() {
+        return byteBuf.readByte();
+    }
+
+    @Override
+    public void readBytes(byte[] buffer) {
+        byteBuf.readBytes(buffer);
+    }
+
+    @Override
+    public int readUnsignedShort() {
+        return byteBuf.readUnsignedShort();
+    }
+
+    @Override
+    public void writeByte(int value) {
+        byteBuf.writeByte(value);
+    }
+
+    @Override
+    public void writeBytes(byte[] buffer) {
+        byteBuf.writeBytes(buffer);
+    }
+}

src/main/java/mc/core/netty/packets/PingPacket.java

@@ -4,39 +4,21 @@
  */
 package mc.core.netty.packets;
 
-import lombok.ToString;
+import mc.core.CSPacket;
 import mc.core.NetStream;
-import mc.core.Packet;
+import mc.core.SCPacket;
-import mc.core.netty.Utils;
 
-@ToString
+public class PingPacket implements CSPacket, SCPacket {
-public class PingPacket implements Packet {
+    private byte[] rawData;
-    private static final int id = 1;
-    private static final int lenId = Utils.lengthVarInt(id);
-    private byte[] rawdata;
-    private int size;
-
-    @Override
-    public int getSize() {
-        return size;
-    }
-
-    @Override
-    public int getId() {
-        return id;
-    }
 
     @Override
     public void readSelf(NetStream netStream) {
-        rawdata = new byte[netStream.getExpectedLength() - lenId];
+        rawData = new byte[netStream.getExpectedSize()];
-        netStream.readBytes(rawdata);
+        netStream.readBytes(rawData);
-        size = lenId + rawdata.length;
     }
 
     @Override
-    public void writeSelf(NetStream netStream) {
+    public byte[] toByteArray() {
-        netStream.writeVarInt(size);
+        return rawData;
-        netStream.writeVarInt(id);
-        netStream.writeBytes(rawdata);
     }
 }

src/main/java/mc/core/netty/packets/RawPacket.java

@@ -0,0 +1,17 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty.packets;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import mc.core.CSPacket;
+
+@ToString
+public class RawPacket implements CSPacket {
+    @Getter
+    @Setter
+    private byte[] rawData;
+}

src/main/java/mc/core/netty/packets/StatusRequest.java

@@ -0,0 +1,35 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty.packets;
+
+import lombok.Getter;
+import lombok.ToString;
+import lombok.extern.slf4j.Slf4j;
+import mc.core.CSPacket;
+import mc.core.NetStream;
+import mc.core.netty.State;
+
+@Slf4j
+@Getter
+@ToString
+public class StatusRequest implements CSPacket {
+    private int protocolVersion;
+    private String serverAddress;
+    private int serverPort;
+    private State nextState;
+
+    @Override
+    public void readSelf(NetStream netStream) {
+        protocolVersion = netStream.readVarInt();
+        serverAddress = netStream.readString();
+        serverPort = netStream.readUnsignedShort();
+
+        int nextStateId = netStream.readVarInt();
+        nextState = State.getStateById(nextStateId);
+        if (nextState.equals(State.UNKNOWN)){
+            log.warn("Unknown state ({})!", nextStateId);
+        }
+    }
+}

src/main/java/mc/core/netty/packets/StatusResponse.java

@@ -0,0 +1,56 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty.packets;
+
+import com.google.gson.JsonObject;
+import lombok.Setter;
+import lombok.ToString;
+import mc.core.ByteArrayOutputNetStream;
+import mc.core.SCPacket;
+
+@ToString
+public class StatusResponse implements SCPacket {
+    private static final String name = "1.12.2";
+    private static final int protocol = 340;
+
+    @Setter
+    private int maxOnline;
+    @Setter
+    private int online;
+    @Setter
+    private String description;
+    @Setter
+    private byte[] faviconBase64;
+
+    @Override
+    public byte[] toByteArray() {
+        ByteArrayOutputNetStream netStream = new ByteArrayOutputNetStream();
+
+        JsonObject versionObj = new JsonObject();
+        versionObj.addProperty("name", name);
+        versionObj.addProperty("protocol", protocol);
+
+        JsonObject playersObj = new JsonObject();
+        playersObj.addProperty("max", maxOnline);
+        playersObj.addProperty("online", online);
+
+        JsonObject descriptionObj = new JsonObject();
+        descriptionObj.addProperty("text", description);
+
+        JsonObject rootObj = new JsonObject();
+        rootObj.add("version", versionObj);
+        rootObj.add("players", playersObj);
+        rootObj.add("description", descriptionObj);
+
+        if (faviconBase64 != null && faviconBase64.length > 0) {
+            rootObj.addProperty("favicon",
+                    "data:image/png;base64," + new String(faviconBase64)
+            );
+        }
+
+        netStream.writeString(rootObj.toString());
+        return netStream.toByteArray();
+    }
+}

src/main/resources/spring.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
+    <bean id="config" class="mc.core.embedded.ConfigFromSpring">
+        <property name="descriptionServer" value="MC Core"/>
+        <property name="maxPlayers" value="100"/>
+        <property name="faviconBase64" value="icon.png"/>
+        <property name="host" value="127.0.0.1"/>
+        <property name="port" value="25565"/>
+    </bean>
+
+    <bean id="server" class="mc.core.netty.NettyServer"/>
+</beans>