Reformat code to use the official kotlin code style

blokk-api/src/main/kotlin/space/blokk/chat/ChatComponent.kt

@@ -55,17 +55,21 @@ sealed class ChatComponent {
         WHITE;
 
         object Adapter {
-            @ToJson fun toJson(value: Color) = value.name.toLowerCase()
+            @ToJson
-            @FromJson fun fromJson(value: String) = valueOf(value.toUpperCase())
+            fun toJson(value: Color) = value.name.toLowerCase()
+            @FromJson
+            fun fromJson(value: String) = valueOf(value.toUpperCase())
         }
     }
 
     object Adapter {
-        @FromJson fun fromJson(reader: JsonReader): ChatComponent? {
+        @FromJson
+        fun fromJson(reader: JsonReader): ChatComponent? {
             throw UnsupportedOperationException("ChatComponent cannot be deserialized.")
         }
 
-        @ToJson fun toJson(writer: JsonWriter, value: ChatComponent?) {
+        @ToJson
+        fun toJson(writer: JsonWriter, value: ChatComponent?) {
             @Suppress("UNCHECKED_CAST")
             if (value == null) writer.nullValue()
             else (Blokk.json.adapter(value::class.java) as JsonAdapter<ChatComponent>).toJson(writer, value)

blokk-api/src/main/kotlin/space/blokk/events/EventBus.kt

@@ -45,8 +45,10 @@ class EventBus<EventT: Event>(private val eventClass: KClass<EventT>, private va
             val klass = method.parameters[1].type.classifier as KClass<EventT>
 
             if (!eventClass.isSuperclassOf(klass))
-                throw InvalidEventHandlerException("${method.name}'s first parameter type is incompatible with the " +
+                throw InvalidEventHandlerException(
-                        "one required by the EventBus")
+                    "${method.name}'s first parameter type is incompatible with the " +
+                        "one required by the EventBus"
+                )
 
             @Suppress("UNCHECKED_CAST")
             val handler = Handler(

blokk-api/src/main/kotlin/space/blokk/logging/Logger.kt

@@ -14,9 +14,23 @@ class Logger(name: String) {
     infix fun debug(msg: String) = logger.debug(msg)
     infix fun trace(msg: String) = logger.trace(msg)
 
-    infix fun error(fn: () -> String) { if (logger.isErrorEnabled) logger.error(fn()) }
+    infix fun error(fn: () -> String) {
-    infix fun info(fn: () -> String) { if (logger.isInfoEnabled) logger.info(fn()) }
+        if (logger.isErrorEnabled) logger.error(fn())
-    infix fun warn(fn: () -> String) { if (logger.isWarnEnabled) logger.warn(fn()) }
+    }
-    infix fun debug(fn: () -> String) { if (logger.isDebugEnabled) logger.debug(fn()) }
+
-    infix fun trace(fn: () -> String) { if (logger.isTraceEnabled) logger.trace(fn()) }
+    infix fun info(fn: () -> String) {
+        if (logger.isInfoEnabled) logger.info(fn())
+    }
+
+    infix fun warn(fn: () -> String) {
+        if (logger.isWarnEnabled) logger.warn(fn())
+    }
+
+    infix fun debug(fn: () -> String) {
+        if (logger.isDebugEnabled) logger.debug(fn())
+    }
+
+    infix fun trace(fn: () -> String) {
+        if (logger.isTraceEnabled) logger.trace(fn())
+    }
 }

blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginProtocol.kt

@@ -2,7 +2,8 @@ package space.blokk.net.protocols.login
 
 import space.blokk.net.protocols.Protocol
 
-object LoginProtocol: Protocol("LOGIN", setOf(
+object LoginProtocol : Protocol(
+    "LOGIN", setOf(
         DisconnectPacket,
         LoginStartPacket,
         EncryptionRequestPacket,
@@ -11,4 +12,5 @@ object LoginProtocol: Protocol("LOGIN", setOf(
         LoginSuccessPacket,
         LoginPluginRequestPacket,
         LoginPluginResponsePacket
-))
+    )
+)

blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt

@@ -1,4 +1,5 @@
 package space.blokk.events
+
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay

blokk-server/build.gradle.kts

@@ -1,5 +1,3 @@
-
-
 plugins {
     kotlin("jvm")
     id("com.github.johnrengelman.shadow") version "6.0.0"

blokk-server/src/main/kotlin/space/blokk/BlokkServer.kt

@@ -14,7 +14,9 @@ import space.blokk.server.Server
 import space.blokk.server.events.ServerEvent
 
 class BlokkServer internal constructor() : Server {
-    init { i = this }
+    init {
+        i = this
+    }
 
     override val scope = CoroutineScope(CoroutineName("BlokkServer"))
     override val eventBus = EventBus(ServerEvent::class, scope)
@@ -52,7 +54,14 @@ class BlokkServer internal constructor(): Server {
             Blokk.sessions.registerListener(object : Listener {
                 @EventHandler
                 fun onServerListInfoRequest(event: ServerListInfoRequestEvent) {
-                    event.response = event.response.copy(description = TextComponent(event.session.address.hostAddress, bold = true, underlined = true, color = ChatComponent.Color.RED))
+                    event.response = event.response.copy(
+                        description = TextComponent(
+                            event.session.address.hostAddress,
+                            bold = true,
+                            underlined = true,
+                            color = ChatComponent.Color.RED
+                        )
+                    )
                 }
             })
 

blokk-server/src/main/kotlin/space/blokk/logging/ConsoleAppender.kt

@@ -23,13 +23,15 @@ class ConsoleAppender: AppenderBase<ILoggingEvent>() {
             else -> khalk
         }
 
-        stream.println(listOf(
+        stream.println(
+            listOf(
                 khalk.gray { dateFormat.format(Date(event.timeStamp)) },
                 color { event.level.toString().padEnd(5) },
                 khalk.bold { event.threadName },
                 color.inverse { " ${event.loggerName} " },
                 color { "❯" },
                 event.message
-        ).joinToString(" "))
+            ).joinToString(" ")
+        )
     }
 }

blokk-server/src/main/kotlin/space/blokk/net/BlokkSession.kt

@@ -4,6 +4,7 @@ import io.netty.channel.Channel
 import kotlinx.coroutines.*
 import space.blokk.BlokkServer
 import space.blokk.events.*
+import space.blokk.logging.Logger
 import space.blokk.net.events.PacketReceivedEvent
 import space.blokk.net.events.PacketSendEvent
 import space.blokk.net.events.SessionEvent
@@ -11,7 +12,6 @@ import space.blokk.net.protocols.OutgoingPacket
 import space.blokk.net.protocols.Protocol
 import space.blokk.net.protocols.handshaking.HandshakingProtocol
 import space.blokk.server.events.SessionInitializedEvent
-import space.blokk.logging.Logger
 import space.blokk.utils.awaitSuspending
 import java.net.InetAddress
 import java.net.InetSocketAddress

blokk-server/src/main/kotlin/space/blokk/net/BlokkSocketServer.kt

@@ -20,11 +20,13 @@ class BlokkSocketServer(private val blokkServer: BlokkServer) {
     private val workerGroup = createEventLoopGroup()
     private val bootstrap: ServerBootstrap = ServerBootstrap()
         .group(bossGroup, workerGroup)
-            .channel(when {
+        .channel(
+            when {
                 EPOLL_AVAILABLE -> EpollServerSocketChannel::class.java
                 KQUEUE_AVAILABLE -> KQueueServerSocketChannel::class.java
                 else -> NioServerSocketChannel::class.java
-            })
+            }
+        )
         .childOption(ChannelOption.SO_KEEPALIVE, true)
         .childOption(ChannelOption.TCP_NODELAY, true)
         .childHandler(BlokkChannelInitializer(this))

blokk-server/src/main/kotlin/space/blokk/net/FramingCodec.kt

@@ -21,8 +21,7 @@ class FramingCodec: ByteToMessageCodec<ByteBuf>() {
                 if (msg.varIntReadable()) {
                     length = msg.readVarInt()
                     currentLength = length
-                }
+                } else return
-                else return
             }
 
             if (msg.readableBytes() >= length) {

blokk-server/src/main/kotlin/space/blokk/net/PacketCodec.kt

@@ -8,8 +8,13 @@ import space.blokk.net.protocols.OutgoingPacket
 import java.io.IOException
 
 class PacketCodec(private val session: BlokkSession) : MessageToMessageCodec<ByteBuf, PacketMessage<*>>() {
-    override fun channelActive(ctx: ChannelHandlerContext) { session.onConnect() }
+    override fun channelActive(ctx: ChannelHandlerContext) {
-    override fun channelInactive(ctx: ChannelHandlerContext) { session.onDisconnect() }
+        session.onConnect()
+    }
+
+    override fun channelInactive(ctx: ChannelHandlerContext) {
+        session.onDisconnect()
+    }
 
     override fun encode(ctx: ChannelHandlerContext, msg: PacketMessage<*>, out: MutableList<Any>) {
         if (msg.packet !is OutgoingPacket) throw Error("Only clientbound packets are allowed. This should never happen.")

blokk-server/src/main/kotlin/space/blokk/net/PacketMessage.kt

@@ -7,7 +7,9 @@ data class PacketMessage<T: Packet>(val session: BlokkSession, val packet: T) {
     val packetCompanion by lazy {
         @Suppress("UNCHECKED_CAST")
         session.currentProtocol.packetCompanionsByPacketType[packet::class] as PacketCompanion<T>?
-                ?: throw Exception("No packet companion found for this packet type. " +
+            ?: throw Exception(
-                        "This can happen if the packet is not part of the current protocol.")
+                "No packet companion found for this packet type. " +
+                    "This can happen if the packet is not part of the current protocol."
+            )
     }
 }

blokk-server/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocolHandler.kt

@@ -9,10 +9,10 @@ import space.blokk.net.events.ServerListInfoRequestEvent
 import java.util.*
 
 // NOTE: PacketReceivedEventHandler.of<T> MUST have T specified correctly, otherwise the code breaks at runtime
-
 object StatusProtocolHandler : ProtocolPacketReceivedEventHandler(mapOf(
     RequestPacket to PacketReceivedEventHandler.of<RequestPacket> { session, _ ->
-            session.eventBus.emit(ServerListInfoRequestEvent(
+        session.eventBus.emit(
+            ServerListInfoRequestEvent(
                 session,
                 // TODO: Use the real server data
                 ResponsePacket(
@@ -22,10 +22,16 @@ object StatusProtocolHandler: ProtocolPacketReceivedEventHandler(mapOf(
                     players = ResponsePacket.Players(
                         10,
                         10,
-                        listOf(ResponsePacket.Players.SampleEntry("${FormattingCode.AQUA}Gronkh", UUID.randomUUID().toString()))
+                        listOf(
+                            ResponsePacket.Players.SampleEntry(
+                                "${FormattingCode.AQUA}Gronkh",
+                                UUID.randomUUID().toString()
                             )
                         )
-            )).ifNotCancelled { session.send(it.response) }
+                    )
+                )
+            )
+        ).ifNotCancelled { session.send(it.response) }
     },
     PingPacket to PacketReceivedEventHandler.of<PingPacket> { session, packet ->
         session.send(PongPacket(packet.payload))