From 0a4f835327b9c2e2e84eb6f736c79eb39517cfb9 Mon Sep 17 00:00:00 2001 From: Moritz Ruth Date: Fri, 14 Aug 2020 20:54:07 +0200 Subject: [PATCH] Reformat code to use the official kotlin code style --- .github/workflows/build_and_test.yml | 30 +++++++++---------- .../src/main/kotlin/space/blokk/Blokk.kt | 2 +- .../kotlin/space/blokk/chat/ChatComponent.kt | 14 +++++---- .../kotlin/space/blokk/events/Cancellable.kt | 4 +-- .../kotlin/space/blokk/events/EventBus.kt | 22 +++++++------- .../kotlin/space/blokk/events/EventTarget.kt | 2 +- .../space/blokk/events/EventTargetGroup.kt | 4 +-- .../main/kotlin/space/blokk/logging/Logger.kt | 24 +++++++++++---- .../main/kotlin/space/blokk/net/Session.kt | 2 +- .../kotlin/space/blokk/net/SessionGroup.kt | 2 +- .../blokk/net/events/PacketReceivedEvent.kt | 2 +- .../space/blokk/net/events/PacketSendEvent.kt | 2 +- .../net/events/ServerListInfoRequestEvent.kt | 2 +- .../space/blokk/net/events/SessionEvent.kt | 2 +- .../space/blokk/net/protocols/Packet.kt | 14 ++++----- .../space/blokk/net/protocols/Protocol.kt | 2 +- .../protocols/handshaking/HandshakePacket.kt | 12 ++++---- .../net/protocols/login/DisconnectPacket.kt | 4 +-- .../login/EncryptionRequestPacket.kt | 10 +++---- .../login/EncryptionResponsePacket.kt | 8 ++--- .../login/LoginPluginRequestPacket.kt | 10 +++---- .../login/LoginPluginResponsePacket.kt | 4 +-- .../net/protocols/login/LoginProtocol.kt | 6 ++-- .../net/protocols/login/LoginStartPacket.kt | 4 +-- .../net/protocols/login/LoginSuccessPacket.kt | 4 +-- .../protocols/login/SetCompressionPacket.kt | 4 +-- .../net/protocols/status/RequestPacket.kt | 2 +- .../net/protocols/status/StatusProtocol.kt | 2 +- .../main/kotlin/space/blokk/server/Server.kt | 2 +- .../space/blokk/server/events/ServerEvent.kt | 2 +- .../server/events/SessionInitializedEvent.kt | 2 +- .../space/blokk/chat/FormattingCodeTest.kt | 2 +- .../kotlin/space/blokk/events/EventBusTest.kt | 9 +++--- .../blokk/net/protocols/ProtocolsTest.kt | 2 +- blokk-server/build.gradle.kts | 2 -- .../main/kotlin/space/blokk/BlokkServer.kt | 15 ++++++++-- .../space/blokk/logging/ConsoleAppender.kt | 20 +++++++------ .../blokk/net/BlokkChannelInitializer.kt | 10 +++---- .../kotlin/space/blokk/net/BlokkSession.kt | 2 +- .../space/blokk/net/BlokkSocketServer.kt | 12 ++++---- .../net/DefaultPacketReceivedEventHandler.kt | 12 ++++---- .../kotlin/space/blokk/net/FramingCodec.kt | 5 ++-- .../kotlin/space/blokk/net/PacketCodec.kt | 11 +++++-- .../kotlin/space/blokk/net/PacketMessage.kt | 8 +++-- .../space/blokk/net/PacketMessageHandler.kt | 2 +- .../handshaking/HandshakingProtocolHandler.kt | 8 ++--- .../protocols/status/StatusProtocolHandler.kt | 26 +++++++++------- 47 files changed, 199 insertions(+), 153 deletions(-) diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml index 79fc0fd..48955fc 100644 --- a/.github/workflows/build_and_test.yml +++ b/.github/workflows/build_and_test.yml @@ -13,18 +13,18 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 - - name: Set up JDK 1.8 - uses: actions/setup-java@v1 - with: - java-version: 1.8 - - name: Cache Gradle packages - uses: actions/cache@v2 - with: - path: ~/.gradle/caches - key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }} - restore-keys: ${{ runner.os }}-gradle - - name: Build with Gradle - run: ./gradlew build - - name: Test with Gradle - run: ./gradlew test + - uses: actions/checkout@v2 + - name: Set up JDK 1.8 + uses: actions/setup-java@v1 + with: + java-version: 1.8 + - name: Cache Gradle packages + uses: actions/cache@v2 + with: + path: ~/.gradle/caches + key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }} + restore-keys: ${{ runner.os }}-gradle + - name: Build with Gradle + run: ./gradlew build + - name: Test with Gradle + run: ./gradlew test diff --git a/blokk-api/src/main/kotlin/space/blokk/Blokk.kt b/blokk-api/src/main/kotlin/space/blokk/Blokk.kt index 6571461..9084813 100644 --- a/blokk-api/src/main/kotlin/space/blokk/Blokk.kt +++ b/blokk-api/src/main/kotlin/space/blokk/Blokk.kt @@ -15,7 +15,7 @@ interface BlokkProvider { val sessions: EventTargetGroup } -object Blokk: BlokkProvider { +object Blokk : BlokkProvider { // Is assigned by BlokkServer using reflection private var provider: BlokkProvider? = null override val server get() = provider!!.server diff --git a/blokk-api/src/main/kotlin/space/blokk/chat/ChatComponent.kt b/blokk-api/src/main/kotlin/space/blokk/chat/ChatComponent.kt index 6856393..5b37ca1 100644 --- a/blokk-api/src/main/kotlin/space/blokk/chat/ChatComponent.kt +++ b/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() - @FromJson fun fromJson(value: String) = valueOf(value.toUpperCase()) + @ToJson + 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).toJson(writer, value) @@ -85,7 +89,7 @@ data class TextComponent( override val obfuscated: Boolean = false, override val color: Color? = null, override val extra: List? = null -): ChatComponent() { +) : ChatComponent() { companion object { /** * Creates a new [TextComponent] instance using [text] and returns it. diff --git a/blokk-api/src/main/kotlin/space/blokk/events/Cancellable.kt b/blokk-api/src/main/kotlin/space/blokk/events/Cancellable.kt index fab8ba9..cf2dd04 100644 --- a/blokk-api/src/main/kotlin/space/blokk/events/Cancellable.kt +++ b/blokk-api/src/main/kotlin/space/blokk/events/Cancellable.kt @@ -7,9 +7,9 @@ interface Cancellable { /** * Only executes [fn] if [isCancelled][Cancellable.isCancelled] is true. */ -inline fun T.ifCancelled(fn: (T) -> R): R? = if (isCancelled) fn(this) else null +inline fun T.ifCancelled(fn: (T) -> R): R? = if (isCancelled) fn(this) else null /** * Only executes [fn] if [isCancelled][Cancellable.isCancelled] is false. */ -inline fun T.ifNotCancelled(fn: (T) -> R): R? = if (!isCancelled) fn(this) else null +inline fun T.ifNotCancelled(fn: (T) -> R): R? = if (!isCancelled) fn(this) else null diff --git a/blokk-api/src/main/kotlin/space/blokk/events/EventBus.kt b/blokk-api/src/main/kotlin/space/blokk/events/EventBus.kt index 302608d..e8dbb5b 100644 --- a/blokk-api/src/main/kotlin/space/blokk/events/EventBus.kt +++ b/blokk-api/src/main/kotlin/space/blokk/events/EventBus.kt @@ -7,7 +7,7 @@ import kotlin.reflect.KClass import kotlin.reflect.KFunction import kotlin.reflect.full.* -class EventBus(private val eventClass: KClass, private val scope: CoroutineScope) { +class EventBus(private val eventClass: KClass, private val scope: CoroutineScope) { /** * All event handlers, sorted by their priority and the order in which they were registered. */ @@ -19,12 +19,12 @@ class EventBus(private val eventClass: KClass, private va * * @return [event] */ - suspend fun emit(event: T): T { + suspend fun emit(event: T): T { handlers.filter { it.eventType.isInstance(event) }.forEach { it.fn.callSuspend(it.listener, event) } return event } - fun emitAsync(event: T) = scope.async { emit(event) } + fun emitAsync(event: T) = scope.async { emit(event) } /** * Registers all [event handlers][EventHandler] in [listener] to be invoked when their corresponding event is emitted. @@ -32,10 +32,10 @@ class EventBus(private val eventClass: KClass, private va * @return [listener] * @throws InvalidEventHandlerException if one of the event handlers does not meet the requirements */ - fun register(listener: T): T { + fun register(listener: T): T { val handlersOfListener = listener::class.functions - .mapNotNull { method -> method.findAnnotation()?.let { method to it } } - .toMap() + .mapNotNull { method -> method.findAnnotation()?.let { method to it } } + .toMap() for ((method, data) in handlersOfListener) { if (method.valueParameters.count() != 1) @@ -45,8 +45,10 @@ class EventBus(private val eventClass: KClass, private va val klass = method.parameters[1].type.classifier as KClass if (!eventClass.isSuperclassOf(klass)) - throw InvalidEventHandlerException("${method.name}'s first parameter type is incompatible with the " + - "one required by the EventBus") + throw InvalidEventHandlerException( + "${method.name}'s first parameter type is incompatible with the " + + "one required by the EventBus" + ) @Suppress("UNCHECKED_CAST") val handler = Handler( @@ -71,9 +73,9 @@ class EventBus(private val eventClass: KClass, private va handlers.removeIf { it.listener === listener } } - class InvalidEventHandlerException internal constructor(message: String): Exception(message) + class InvalidEventHandlerException internal constructor(message: String) : Exception(message) - private data class Handler( + private data class Handler( val eventType: KClass, val listener: Listener, val fn: KFunction, diff --git a/blokk-api/src/main/kotlin/space/blokk/events/EventTarget.kt b/blokk-api/src/main/kotlin/space/blokk/events/EventTarget.kt index 25b3dc8..3874609 100644 --- a/blokk-api/src/main/kotlin/space/blokk/events/EventTarget.kt +++ b/blokk-api/src/main/kotlin/space/blokk/events/EventTarget.kt @@ -1,5 +1,5 @@ package space.blokk.events -interface EventTarget { +interface EventTarget { val eventBus: EventBus } diff --git a/blokk-api/src/main/kotlin/space/blokk/events/EventTargetGroup.kt b/blokk-api/src/main/kotlin/space/blokk/events/EventTargetGroup.kt index 2a82730..bd0d23d 100644 --- a/blokk-api/src/main/kotlin/space/blokk/events/EventTargetGroup.kt +++ b/blokk-api/src/main/kotlin/space/blokk/events/EventTargetGroup.kt @@ -1,13 +1,13 @@ package space.blokk.events -interface EventTargetGroup> : Iterable { +interface EventTargetGroup> : Iterable { /** * Register a listener for all elements in this group. * You should never reuse [listener] for other groups or directly on event targets * because this may lead to strange behaviour. */ - fun registerListener(listener: T): T + fun registerListener(listener: T): T /** * Unregister a listener for all elements in this group. diff --git a/blokk-api/src/main/kotlin/space/blokk/logging/Logger.kt b/blokk-api/src/main/kotlin/space/blokk/logging/Logger.kt index 0a36f7f..b6e5b1e 100644 --- a/blokk-api/src/main/kotlin/space/blokk/logging/Logger.kt +++ b/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 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()) } + infix fun error(fn: () -> String) { + if (logger.isErrorEnabled) logger.error(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()) + } } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/Session.kt b/blokk-api/src/main/kotlin/space/blokk/net/Session.kt index 41ea5fd..6ac5a86 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/Session.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/Session.kt @@ -7,7 +7,7 @@ import space.blokk.net.protocols.OutgoingPacket import space.blokk.net.protocols.Protocol import java.net.InetAddress -interface Session: EventTarget { +interface Session : EventTarget { /** * The protocol this session is currently using. */ diff --git a/blokk-api/src/main/kotlin/space/blokk/net/SessionGroup.kt b/blokk-api/src/main/kotlin/space/blokk/net/SessionGroup.kt index a00228c..6f784d9 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/SessionGroup.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/SessionGroup.kt @@ -3,7 +3,7 @@ package space.blokk.net import space.blokk.events.EventTargetGroup import space.blokk.events.Listener -class SessionGroup: EventTargetGroup { +class SessionGroup : EventTargetGroup { private val sessions = mutableSetOf() private val listeners = mutableSetOf() diff --git a/blokk-api/src/main/kotlin/space/blokk/net/events/PacketReceivedEvent.kt b/blokk-api/src/main/kotlin/space/blokk/net/events/PacketReceivedEvent.kt index b50d337..1fbbabe 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/events/PacketReceivedEvent.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/events/PacketReceivedEvent.kt @@ -4,6 +4,6 @@ import space.blokk.events.Cancellable import space.blokk.net.Session import space.blokk.net.protocols.IncomingPacket -class PacketReceivedEvent(session: Session, var packet: T): SessionEvent(session), Cancellable { +class PacketReceivedEvent(session: Session, var packet: T) : SessionEvent(session), Cancellable { override var isCancelled = false } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/events/PacketSendEvent.kt b/blokk-api/src/main/kotlin/space/blokk/net/events/PacketSendEvent.kt index 2751f57..852b325 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/events/PacketSendEvent.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/events/PacketSendEvent.kt @@ -4,6 +4,6 @@ import space.blokk.events.Cancellable import space.blokk.net.Session import space.blokk.net.protocols.OutgoingPacket -class PacketSendEvent(session: Session, var packet: OutgoingPacket): SessionEvent(session), Cancellable { +class PacketSendEvent(session: Session, var packet: OutgoingPacket) : SessionEvent(session), Cancellable { override var isCancelled = false } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/events/ServerListInfoRequestEvent.kt b/blokk-api/src/main/kotlin/space/blokk/net/events/ServerListInfoRequestEvent.kt index 2bd7552..7f13a77 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/events/ServerListInfoRequestEvent.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/events/ServerListInfoRequestEvent.kt @@ -7,6 +7,6 @@ import space.blokk.net.protocols.status.ResponsePacket class ServerListInfoRequestEvent( session: Session, var response: ResponsePacket -): SessionEvent(session), Cancellable { +) : SessionEvent(session), Cancellable { override var isCancelled = false } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/events/SessionEvent.kt b/blokk-api/src/main/kotlin/space/blokk/net/events/SessionEvent.kt index bc3a3b8..4387d67 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/events/SessionEvent.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/events/SessionEvent.kt @@ -3,4 +3,4 @@ package space.blokk.net.events import space.blokk.events.Event import space.blokk.net.Session -abstract class SessionEvent(val session: Session): Event() +abstract class SessionEvent(val session: Session) : Event() diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/Packet.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/Packet.kt index e4cb4c6..522241f 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/Packet.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/Packet.kt @@ -7,23 +7,23 @@ abstract class Packet { override fun toString(): String = this::class.java.simpleName + "(no data)" } -abstract class IncomingPacket: Packet() +abstract class IncomingPacket : Packet() -abstract class OutgoingPacket: Packet() { +abstract class OutgoingPacket : Packet() { abstract fun encode(dst: ByteBuf) } -sealed class PacketCompanion(val id: Int, val packetType: KClass) +sealed class PacketCompanion(val id: Int, val packetType: KClass) -abstract class IncomingPacketCompanion( +abstract class IncomingPacketCompanion( id: Int, packetType: KClass -): PacketCompanion(id, packetType) { +) : PacketCompanion(id, packetType) { abstract fun decode(msg: ByteBuf): T } -abstract class OutgoingPacketCompanion( +abstract class OutgoingPacketCompanion( id: Int, packetType: KClass -): PacketCompanion(id, packetType) +) : PacketCompanion(id, packetType) diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/Protocol.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/Protocol.kt index 1cccb3c..cf0415d 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/Protocol.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/Protocol.kt @@ -7,7 +7,7 @@ abstract class Protocol internal constructor(val name: String, packets: Set> Iterable.mapToIDMap() = map { it.id to it }.toMap() + private fun > Iterable.mapToIDMap() = map { it.id to it }.toMap() fun validate() { ensureDistinctIDs(incomingPackets, "serverbound") diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakePacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakePacket.kt index 25ec09d..d8a6055 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakePacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakePacket.kt @@ -22,15 +22,15 @@ data class HandshakePacket( val serverAddress: String, val serverPort: Int, val loginAttempt: Boolean -): IncomingPacket() { - companion object: IncomingPacketCompanion(0x00, HandshakePacket::class) { +) : IncomingPacket() { + companion object : IncomingPacketCompanion(0x00, HandshakePacket::class) { override fun decode(msg: ByteBuf): HandshakePacket { return with(MinecraftDataTypes) { HandshakePacket( - protocolVersion = msg.readVarInt(), - serverAddress = msg.readString(), - serverPort = msg.readUnsignedShort(), - loginAttempt = msg.readVarInt() == 2 + protocolVersion = msg.readVarInt(), + serverAddress = msg.readString(), + serverPort = msg.readUnsignedShort(), + loginAttempt = msg.readVarInt() == 2 ) } } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/DisconnectPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/DisconnectPacket.kt index 75c85b5..a1aa62d 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/DisconnectPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/DisconnectPacket.kt @@ -11,8 +11,8 @@ import space.blokk.net.protocols.OutgoingPacketCompanion * * @param reason The reason why the login process was cancelled. */ -data class DisconnectPacket(val reason: ChatComponent): OutgoingPacket() { - companion object: OutgoingPacketCompanion(0x00, DisconnectPacket::class) +data class DisconnectPacket(val reason: ChatComponent) : OutgoingPacket() { + companion object : OutgoingPacketCompanion(0x00, DisconnectPacket::class) override fun encode(dst: ByteBuf) { dst.writeString(reason.toJson()) diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionRequestPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionRequestPacket.kt index 6d5e407..8e3a9ad 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionRequestPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionRequestPacket.kt @@ -13,11 +13,11 @@ import space.blokk.net.protocols.OutgoingPacketCompanion * @see https://wiki.vg/Protocol_Encryption */ data class EncryptionRequestPacket( - val serverID: String, - val publicKey: ByteArray, - val verifyToken: ByteArray -): OutgoingPacket() { - companion object: OutgoingPacketCompanion(0x01, EncryptionRequestPacket::class) + val serverID: String, + val publicKey: ByteArray, + val verifyToken: ByteArray +) : OutgoingPacket() { + companion object : OutgoingPacketCompanion(0x01, EncryptionRequestPacket::class) init { if (serverID.length > 20) throw IllegalArgumentException("serverID can only be 16 characters long") diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionResponsePacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionResponsePacket.kt index ffc9929..1c14a64 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionResponsePacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/EncryptionResponsePacket.kt @@ -11,10 +11,10 @@ import space.blokk.net.protocols.IncomingPacketCompanion * @see https://wiki.vg/Protocol_Encryption */ data class EncryptionResponsePacket( - val sharedSecret: ByteArray, - val verifyToken: ByteArray -): IncomingPacket() { - companion object: IncomingPacketCompanion(0x01, EncryptionResponsePacket::class) { + val sharedSecret: ByteArray, + val verifyToken: ByteArray +) : IncomingPacket() { + companion object : IncomingPacketCompanion(0x01, EncryptionResponsePacket::class) { override fun decode(msg: ByteBuf): EncryptionResponsePacket { return with(MinecraftDataTypes) { val sharedSecretLength = msg.readVarInt() diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginRequestPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginRequestPacket.kt index bde8090..82d9379 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginRequestPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginRequestPacket.kt @@ -14,11 +14,11 @@ import space.blokk.net.protocols.OutgoingPacketCompanion * @param data Any data, depending on the channel. */ data class LoginPluginRequestPacket( - val messageID: Int, - val channel: String, - val data: ByteBuf -): OutgoingPacket() { - companion object: OutgoingPacketCompanion(0x04, LoginPluginRequestPacket::class) + val messageID: Int, + val channel: String, + val data: ByteBuf +) : OutgoingPacket() { + companion object : OutgoingPacketCompanion(0x04, LoginPluginRequestPacket::class) override fun encode(dst: ByteBuf) { dst.writeVarInt(messageID) diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginResponsePacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginResponsePacket.kt index af42060..6ece806 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginResponsePacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginPluginResponsePacket.kt @@ -13,8 +13,8 @@ import space.blokk.net.protocols.IncomingPacketCompanion data class LoginPluginResponsePacket( val messageID: Int, val data: ByteArray? -): IncomingPacket() { - companion object: IncomingPacketCompanion(0x02, LoginPluginResponsePacket::class) { +) : IncomingPacket() { + companion object : IncomingPacketCompanion(0x02, LoginPluginResponsePacket::class) { override fun decode(msg: ByteBuf): LoginPluginResponsePacket { return with(MinecraftDataTypes) { val messageID = msg.readVarInt() diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginProtocol.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginProtocol.kt index 8b4f472..75d2bf9 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginProtocol.kt +++ b/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 -)) + ) +) diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginStartPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginStartPacket.kt index db70b3f..fa7907e 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginStartPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginStartPacket.kt @@ -10,8 +10,8 @@ import space.blokk.net.protocols.IncomingPacketCompanion * * @param username The username of the client. This is not validated (yet). Can only be 16 characters long. */ -data class LoginStartPacket(val username: String): IncomingPacket() { - companion object: IncomingPacketCompanion(0x00, LoginStartPacket::class) { +data class LoginStartPacket(val username: String) : IncomingPacket() { + companion object : IncomingPacketCompanion(0x00, LoginStartPacket::class) { override fun decode(msg: ByteBuf): LoginStartPacket { return with(MinecraftDataTypes) { LoginStartPacket(msg.readString()) } } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginSuccessPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginSuccessPacket.kt index ebc6d9d..50103b5 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginSuccessPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/LoginSuccessPacket.kt @@ -14,8 +14,8 @@ import java.util.* * @param uuid The UUID of the player. * @param username The username of the player. Can only be 16 characters long. */ -data class LoginSuccessPacket(val uuid: UUID, val username: String): OutgoingPacket() { - companion object: OutgoingPacketCompanion(0x02, LoginSuccessPacket::class) +data class LoginSuccessPacket(val uuid: UUID, val username: String) : OutgoingPacket() { + companion object : OutgoingPacketCompanion(0x02, LoginSuccessPacket::class) init { if (username.length > 16) throw IllegalArgumentException("username can only be 16 characters long") diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/SetCompressionPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/SetCompressionPacket.kt index 2a03b54..d8ab811 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/SetCompressionPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/login/SetCompressionPacket.kt @@ -11,8 +11,8 @@ import space.blokk.net.protocols.OutgoingPacketCompanion * * @param threshold Maximum size before a packet is compressed. Values lower than 1 will disable compression. */ -data class SetCompressionPacket(val threshold: Int): OutgoingPacket() { - companion object: OutgoingPacketCompanion(0x03, SetCompressionPacket::class) +data class SetCompressionPacket(val threshold: Int) : OutgoingPacket() { + companion object : OutgoingPacketCompanion(0x03, SetCompressionPacket::class) override fun encode(dst: ByteBuf) { dst.writeVarInt(threshold) diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/RequestPacket.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/RequestPacket.kt index 0adbb16..d241e7e 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/RequestPacket.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/RequestPacket.kt @@ -11,7 +11,7 @@ import space.blokk.net.protocols.IncomingPacketCompanion * * @see [space.blokk.net.events.ServerListInfoRequestEvent] */ -class RequestPacket: IncomingPacket() { +class RequestPacket : IncomingPacket() { companion object : IncomingPacketCompanion(0x00, RequestPacket::class) { override fun decode(msg: ByteBuf): RequestPacket = RequestPacket() } diff --git a/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocol.kt b/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocol.kt index e14df93..a97e036 100644 --- a/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocol.kt +++ b/blokk-api/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocol.kt @@ -2,4 +2,4 @@ package space.blokk.net.protocols.status import space.blokk.net.protocols.Protocol -object StatusProtocol: Protocol("STATUS", setOf(RequestPacket, ResponsePacket, PingPacket, PongPacket)) +object StatusProtocol : Protocol("STATUS", setOf(RequestPacket, ResponsePacket, PingPacket, PongPacket)) diff --git a/blokk-api/src/main/kotlin/space/blokk/server/Server.kt b/blokk-api/src/main/kotlin/space/blokk/server/Server.kt index 988e23e..1fcec9c 100644 --- a/blokk-api/src/main/kotlin/space/blokk/server/Server.kt +++ b/blokk-api/src/main/kotlin/space/blokk/server/Server.kt @@ -5,7 +5,7 @@ import space.blokk.events.EventBus import space.blokk.events.EventTarget import space.blokk.server.events.ServerEvent -interface Server: EventTarget { +interface Server : EventTarget { override val eventBus: EventBus val scope: CoroutineScope } diff --git a/blokk-api/src/main/kotlin/space/blokk/server/events/ServerEvent.kt b/blokk-api/src/main/kotlin/space/blokk/server/events/ServerEvent.kt index cc4de8d..44c8a98 100644 --- a/blokk-api/src/main/kotlin/space/blokk/server/events/ServerEvent.kt +++ b/blokk-api/src/main/kotlin/space/blokk/server/events/ServerEvent.kt @@ -2,4 +2,4 @@ package space.blokk.server.events import space.blokk.events.Event -abstract class ServerEvent: Event() +abstract class ServerEvent : Event() diff --git a/blokk-api/src/main/kotlin/space/blokk/server/events/SessionInitializedEvent.kt b/blokk-api/src/main/kotlin/space/blokk/server/events/SessionInitializedEvent.kt index 4384525..2fc7f33 100644 --- a/blokk-api/src/main/kotlin/space/blokk/server/events/SessionInitializedEvent.kt +++ b/blokk-api/src/main/kotlin/space/blokk/server/events/SessionInitializedEvent.kt @@ -3,6 +3,6 @@ package space.blokk.server.events import space.blokk.events.Cancellable import space.blokk.net.Session -class SessionInitializedEvent(val session: Session): ServerEvent(), Cancellable { +class SessionInitializedEvent(val session: Session) : ServerEvent(), Cancellable { override var isCancelled: Boolean = false } diff --git a/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt b/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt index a66793b..9acadef 100644 --- a/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt +++ b/blokk-api/src/test/kotlin/space/blokk/chat/FormattingCodeTest.kt @@ -5,7 +5,7 @@ import org.spekframework.spek2.style.specification.describe import strikt.api.expectThat import strikt.assertions.isEqualTo -object FormattingCodeTest: Spek({ +object FormattingCodeTest : Spek({ describe("FormattingCode") { it("correctly translates to a string") { expectThat("${FormattingCode.AQUA}").isEqualTo("§b") diff --git a/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt b/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt index 7bd8b6c..d128755 100644 --- a/blokk-api/src/test/kotlin/space/blokk/events/EventBusTest.kt +++ b/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 @@ -10,11 +11,11 @@ import strikt.api.expectThrows import strikt.assertions.* import kotlin.system.measureTimeMillis -private abstract class TestEvent: Event() -private class FirstEvent: TestEvent() -private class SecondEvent: TestEvent() +private abstract class TestEvent : Event() +private class FirstEvent : TestEvent() +private class SecondEvent : TestEvent() -object EventBusTest: Spek({ +object EventBusTest : Spek({ describe("EventBus") { val eventBus by memoized { EventBus(TestEvent::class, CoroutineScope(Dispatchers.Default)) } diff --git a/blokk-api/src/test/kotlin/space/blokk/net/protocols/ProtocolsTest.kt b/blokk-api/src/test/kotlin/space/blokk/net/protocols/ProtocolsTest.kt index 13b6b62..ffd54b4 100644 --- a/blokk-api/src/test/kotlin/space/blokk/net/protocols/ProtocolsTest.kt +++ b/blokk-api/src/test/kotlin/space/blokk/net/protocols/ProtocolsTest.kt @@ -3,7 +3,7 @@ package space.blokk.net.protocols import org.spekframework.spek2.Spek import org.spekframework.spek2.style.specification.describe -object ProtocolsTest: Spek({ +object ProtocolsTest : Spek({ describe("Protocols") { it("are valid") { Protocols.validate() diff --git a/blokk-server/build.gradle.kts b/blokk-server/build.gradle.kts index 80c6d77..194a2d0 100644 --- a/blokk-server/build.gradle.kts +++ b/blokk-server/build.gradle.kts @@ -1,5 +1,3 @@ - - plugins { kotlin("jvm") id("com.github.johnrengelman.shadow") version "6.0.0" diff --git a/blokk-server/src/main/kotlin/space/blokk/BlokkServer.kt b/blokk-server/src/main/kotlin/space/blokk/BlokkServer.kt index dd4a2d5..4719828 100644 --- a/blokk-server/src/main/kotlin/space/blokk/BlokkServer.kt +++ b/blokk-server/src/main/kotlin/space/blokk/BlokkServer.kt @@ -13,8 +13,10 @@ import space.blokk.net.events.ServerListInfoRequestEvent import space.blokk.server.Server import space.blokk.server.events.ServerEvent -class BlokkServer internal constructor(): Server { - init { i = this } +class BlokkServer internal constructor() : Server { + 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 + ) + ) } }) diff --git a/blokk-server/src/main/kotlin/space/blokk/logging/ConsoleAppender.kt b/blokk-server/src/main/kotlin/space/blokk/logging/ConsoleAppender.kt index e90ea57..873f7bf 100644 --- a/blokk-server/src/main/kotlin/space/blokk/logging/ConsoleAppender.kt +++ b/blokk-server/src/main/kotlin/space/blokk/logging/ConsoleAppender.kt @@ -8,7 +8,7 @@ import java.io.PrintStream import java.text.SimpleDateFormat import java.util.* -class ConsoleAppender: AppenderBase() { +class ConsoleAppender : AppenderBase() { private val dateFormat = SimpleDateFormat("HH:mm:ss.SSS") override fun append(event: ILoggingEvent) { @@ -23,13 +23,15 @@ class ConsoleAppender: AppenderBase() { else -> khalk } - 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(" ")) + 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(" ") + ) } } diff --git a/blokk-server/src/main/kotlin/space/blokk/net/BlokkChannelInitializer.kt b/blokk-server/src/main/kotlin/space/blokk/net/BlokkChannelInitializer.kt index 71e6edd..dd5d248 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/BlokkChannelInitializer.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/BlokkChannelInitializer.kt @@ -7,7 +7,7 @@ import io.netty.channel.ChannelOption import io.netty.handler.timeout.IdleStateHandler import space.blokk.BlokkServer -class BlokkChannelInitializer(private val blokkSocketServer: BlokkSocketServer): ChannelInitializer() { +class BlokkChannelInitializer(private val blokkSocketServer: BlokkSocketServer) : ChannelInitializer() { private val logger = BlokkServer.i.logger override fun initChannel(channel: Channel) { @@ -21,10 +21,10 @@ class BlokkChannelInitializer(private val blokkSocketServer: BlokkSocketServer): val session = BlokkSession(channel) channel.pipeline() - .addLast(IdleStateHandler(20, 15, 0)) - .addLast(FramingCodec()) - .addLast(PacketCodec(session)) - .addLast(PacketMessageHandler(session)) + .addLast(IdleStateHandler(20, 15, 0)) + .addLast(FramingCodec()) + .addLast(PacketCodec(session)) + .addLast(PacketMessageHandler(session)) } companion object { diff --git a/blokk-server/src/main/kotlin/space/blokk/net/BlokkSession.kt b/blokk-server/src/main/kotlin/space/blokk/net/BlokkSession.kt index a5d05c5..e07ed27 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/BlokkSession.kt +++ b/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 diff --git a/blokk-server/src/main/kotlin/space/blokk/net/BlokkSocketServer.kt b/blokk-server/src/main/kotlin/space/blokk/net/BlokkSocketServer.kt index c8dc5dc..8560b8f 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/BlokkSocketServer.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/BlokkSocketServer.kt @@ -19,14 +19,16 @@ class BlokkSocketServer(private val blokkServer: BlokkServer) { private val bossGroup = createEventLoopGroup() private val workerGroup = createEventLoopGroup() private val bootstrap: ServerBootstrap = ServerBootstrap() - .group(bossGroup, workerGroup) - .channel(when { + .group(bossGroup, workerGroup) + .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) + } + ) + .childOption(ChannelOption.SO_KEEPALIVE, true) + .childOption(ChannelOption.TCP_NODELAY, true) .childHandler(BlokkChannelInitializer(this)) internal val allSessionsGroup = SessionGroup() diff --git a/blokk-server/src/main/kotlin/space/blokk/net/DefaultPacketReceivedEventHandler.kt b/blokk-server/src/main/kotlin/space/blokk/net/DefaultPacketReceivedEventHandler.kt index 7e282b4..a6a19d6 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/DefaultPacketReceivedEventHandler.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/DefaultPacketReceivedEventHandler.kt @@ -17,20 +17,20 @@ open class ProtocolPacketReceivedEventHandler(handlers: Map { +abstract class PacketReceivedEventHandler { abstract suspend fun handle(session: BlokkSession, packet: T) companion object { - fun of(fn: suspend (session: BlokkSession, packet: T) -> Unit) = - object : PacketReceivedEventHandler() { - override suspend fun handle(session: BlokkSession, packet: T) = fn(session, packet) - } + fun of(fn: suspend (session: BlokkSession, packet: T) -> Unit) = + object : PacketReceivedEventHandler() { + override suspend fun handle(session: BlokkSession, packet: T) = fn(session, packet) + } } } object SessionPacketReceivedEventHandler { suspend fun handle(session: BlokkSession, packet: IncomingPacket) { - val handler = when(session.currentProtocol) { + val handler = when (session.currentProtocol) { HandshakingProtocol -> HandshakingProtocolHandler StatusProtocol -> StatusProtocolHandler else -> return diff --git a/blokk-server/src/main/kotlin/space/blokk/net/FramingCodec.kt b/blokk-server/src/main/kotlin/space/blokk/net/FramingCodec.kt index 3c318ad..a007cfe 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/FramingCodec.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/FramingCodec.kt @@ -4,7 +4,7 @@ import io.netty.buffer.ByteBuf import io.netty.channel.ChannelHandlerContext import io.netty.handler.codec.ByteToMessageCodec -class FramingCodec: ByteToMessageCodec() { +class FramingCodec : ByteToMessageCodec() { private var currentLength: Int? = null override fun encode(ctx: ChannelHandlerContext, msg: ByteBuf, out: ByteBuf) { @@ -21,8 +21,7 @@ class FramingCodec: ByteToMessageCodec() { if (msg.varIntReadable()) { length = msg.readVarInt() currentLength = length - } - else return + } else return } if (msg.readableBytes() >= length) { diff --git a/blokk-server/src/main/kotlin/space/blokk/net/PacketCodec.kt b/blokk-server/src/main/kotlin/space/blokk/net/PacketCodec.kt index 836deb5..fde7a86 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/PacketCodec.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/PacketCodec.kt @@ -7,9 +7,14 @@ import space.blokk.BlokkServer import space.blokk.net.protocols.OutgoingPacket import java.io.IOException -class PacketCodec(private val session: BlokkSession): MessageToMessageCodec>() { - override fun channelActive(ctx: ChannelHandlerContext) { session.onConnect() } - override fun channelInactive(ctx: ChannelHandlerContext) { session.onDisconnect() } +class PacketCodec(private val session: BlokkSession) : MessageToMessageCodec>() { + override fun channelActive(ctx: ChannelHandlerContext) { + session.onConnect() + } + + override fun channelInactive(ctx: ChannelHandlerContext) { + session.onDisconnect() + } override fun encode(ctx: ChannelHandlerContext, msg: PacketMessage<*>, out: MutableList) { if (msg.packet !is OutgoingPacket) throw Error("Only clientbound packets are allowed. This should never happen.") diff --git a/blokk-server/src/main/kotlin/space/blokk/net/PacketMessage.kt b/blokk-server/src/main/kotlin/space/blokk/net/PacketMessage.kt index e2d6e25..f66467f 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/PacketMessage.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/PacketMessage.kt @@ -3,11 +3,13 @@ package space.blokk.net import space.blokk.net.protocols.Packet import space.blokk.net.protocols.PacketCompanion -data class PacketMessage(val session: BlokkSession, val packet: T) { +data class PacketMessage(val session: BlokkSession, val packet: T) { val packetCompanion by lazy { @Suppress("UNCHECKED_CAST") session.currentProtocol.packetCompanionsByPacketType[packet::class] as PacketCompanion? - ?: throw Exception("No packet companion found for this packet type. " + - "This can happen if the packet is not part of the current protocol.") + ?: throw Exception( + "No packet companion found for this packet type. " + + "This can happen if the packet is not part of the current protocol." + ) } } diff --git a/blokk-server/src/main/kotlin/space/blokk/net/PacketMessageHandler.kt b/blokk-server/src/main/kotlin/space/blokk/net/PacketMessageHandler.kt index 01a0b94..89a8fce 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/PacketMessageHandler.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/PacketMessageHandler.kt @@ -6,7 +6,7 @@ import kotlinx.coroutines.launch import space.blokk.net.events.PacketReceivedEvent import space.blokk.net.protocols.IncomingPacket -class PacketMessageHandler(private val session: BlokkSession): SimpleChannelInboundHandler>() { +class PacketMessageHandler(private val session: BlokkSession) : SimpleChannelInboundHandler>() { override fun channelRead0(ctx: ChannelHandlerContext, msg: PacketMessage<*>) { if (msg.packet !is IncomingPacket) throw Error("Only serverbound packets are allowed. This should never happen.") session.logger.trace { "Packet received: ${msg.packet}" } diff --git a/blokk-server/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakingProtocolHandler.kt b/blokk-server/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakingProtocolHandler.kt index 17b104e..bcaabb6 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakingProtocolHandler.kt +++ b/blokk-server/src/main/kotlin/space/blokk/net/protocols/handshaking/HandshakingProtocolHandler.kt @@ -5,8 +5,8 @@ import space.blokk.net.ProtocolPacketReceivedEventHandler import space.blokk.net.protocols.login.LoginProtocol import space.blokk.net.protocols.status.StatusProtocol -object HandshakingProtocolHandler: ProtocolPacketReceivedEventHandler(mapOf( - HandshakePacket to PacketReceivedEventHandler.of { session, packet -> - session.currentProtocol = if (packet.loginAttempt) LoginProtocol else StatusProtocol - } +object HandshakingProtocolHandler : ProtocolPacketReceivedEventHandler(mapOf( + HandshakePacket to PacketReceivedEventHandler.of { session, packet -> + session.currentProtocol = if (packet.loginAttempt) LoginProtocol else StatusProtocol + } )) diff --git a/blokk-server/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocolHandler.kt b/blokk-server/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocolHandler.kt index 6d25090..cbf48c3 100644 --- a/blokk-server/src/main/kotlin/space/blokk/net/protocols/status/StatusProtocolHandler.kt +++ b/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 MUST have T specified correctly, otherwise the code breaks at runtime - -object StatusProtocolHandler: ProtocolPacketReceivedEventHandler(mapOf( - RequestPacket to PacketReceivedEventHandler.of { session, _ -> - session.eventBus.emit(ServerListInfoRequestEvent( +object StatusProtocolHandler : ProtocolPacketReceivedEventHandler(mapOf( + RequestPacket to PacketReceivedEventHandler.of { session, _ -> + session.eventBus.emit( + ServerListInfoRequestEvent( session, // TODO: Use the real server data ResponsePacket( @@ -22,12 +22,18 @@ 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) } - }, - PingPacket to PacketReceivedEventHandler.of { session, packet -> - session.send(PongPacket(packet.payload)) - } + ) + ).ifNotCancelled { session.send(it.response) } + }, + PingPacket to PacketReceivedEventHandler.of { session, packet -> + session.send(PongPacket(packet.payload)) + } ))