Move length encoding/decoding from Rs2{Decoder,Encoder} to PacketCodec

There are now three additional abstract PacketCodec classes:
FixedPacketCodec, VariableBytePacketCodec and VariableShortPacketCodec.

The PacketLength class has been removed, as it is no longer required.

The main reason for this change is that the create suggested names
packet is a bit of an oddball: its length field measures the size of the
packet in longs, not bytes. The codec for this packet will be able to
inherit from PacketCodec directly to implement the custom length logic.

Signed-off-by: Graham <gpe@openrs2.org>

archive/src/main/kotlin/org/openrs2/archive/cache/nxt/InitJs5RemoteConnectionCodec.kt

@@ -4,13 +4,11 @@ import io.netty.buffer.ByteBuf
 import org.openrs2.buffer.readString
 import org.openrs2.buffer.writeString
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.VariableBytePacketCodec
-import org.openrs2.protocol.PacketLength
 
-public object InitJs5RemoteConnectionCodec : PacketCodec<InitJs5RemoteConnection>(
+public object InitJs5RemoteConnectionCodec : VariableBytePacketCodec<InitJs5RemoteConnection>(
-    length = PacketLength.VARIABLE_BYTE,
+    type = InitJs5RemoteConnection::class.java,
-    opcode = 15,
+    opcode = 15
-    type = InitJs5RemoteConnection::class.java
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): InitJs5RemoteConnection {
         val buildMajor = input.readInt()

archive/src/main/kotlin/org/openrs2/archive/cache/nxt/Js5OkCodec.kt

@@ -2,12 +2,12 @@ package org.openrs2.archive.cache.nxt
 
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.FixedPacketCodec
 
-public object Js5OkCodec : PacketCodec<LoginResponse.Js5Ok>(
+public object Js5OkCodec : FixedPacketCodec<LoginResponse.Js5Ok>(
+    type = LoginResponse.Js5Ok::class.java,
     opcode = 0,
-    length = LoginResponse.Js5Ok.LOADING_REQUIREMENTS * 4,
+    length = LoginResponse.Js5Ok.LOADING_REQUIREMENTS * 4
-    type = LoginResponse.Js5Ok::class.java
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): LoginResponse.Js5Ok {
         val loadingRequirements = mutableListOf<Int>()

protocol/src/main/kotlin/org/openrs2/protocol/EmptyPacketCodec.kt

@@ -6,7 +6,7 @@ import org.openrs2.crypto.StreamCipher
 public abstract class EmptyPacketCodec<T : Packet>(
     private val packet: T,
     opcode: Int
-) : PacketCodec<T>(packet.javaClass, opcode, length = 0) {
+) : FixedPacketCodec<T>(packet.javaClass, opcode, length = 0) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): T {
         return packet
     }

protocol/src/main/kotlin/org/openrs2/protocol/FixedPacketCodec.kt

@@ -0,0 +1,37 @@
+package org.openrs2.protocol
+
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.ByteBufAllocator
+import io.netty.handler.codec.EncoderException
+
+public abstract class FixedPacketCodec<T : Packet>(
+    type: Class<T>,
+    opcode: Int,
+    public val length: Int
+) : PacketCodec<T>(type, opcode) {
+    override fun isLengthReadable(input: ByteBuf): Boolean {
+        return true
+    }
+
+    override fun readLength(input: ByteBuf): Int {
+        return length
+    }
+
+    override fun writeLengthPlaceholder(output: ByteBuf) {
+        // empty
+    }
+
+    override fun setLength(output: ByteBuf, index: Int, written: Int) {
+        if (written != length) {
+            throw EncoderException("Fixed payload length mismatch (expected $length bytes, got $written bytes)")
+        }
+    }
+
+    override fun allocateBuffer(alloc: ByteBufAllocator, input: T, preferDirect: Boolean): ByteBuf {
+        return if (preferDirect) {
+            alloc.ioBuffer(1 + length, 1 + length)
+        } else {
+            alloc.heapBuffer(1 + length, 1 + length)
+        }
+    }
+}

protocol/src/main/kotlin/org/openrs2/protocol/PacketCodec.kt

@@ -6,43 +6,26 @@ import org.openrs2.crypto.StreamCipher
 
 public abstract class PacketCodec<T : Packet>(
     public val type: Class<T>,
-    public val opcode: Int,
+    public val opcode: Int
-    public val length: Int
 ) {
     init {
         require(opcode in 0 until 256)
-        require(length >= PacketLength.VARIABLE_SHORT)
     }
 
     public abstract fun decode(input: ByteBuf, cipher: StreamCipher): T
     public abstract fun encode(input: T, output: ByteBuf, cipher: StreamCipher)
 
-    public open fun getLength(input: T): Int {
+    public abstract fun isLengthReadable(input: ByteBuf): Boolean
-        return length
+    public abstract fun readLength(input: ByteBuf): Int
-    }
-
-    public fun allocateBuffer(alloc: ByteBufAllocator, input: T, preferDirect: Boolean): ByteBuf {
-        val payloadLen = getLength(input)
-        if (payloadLen < 0) {
-            return if (preferDirect) {
-                alloc.ioBuffer()
-            } else {
-                alloc.heapBuffer()
-            }
-        }
-
-        val headerLen = when (length) {
-            PacketLength.VARIABLE_BYTE -> 2
-            PacketLength.VARIABLE_SHORT -> 3
-            else -> 1
-        }
 
-        val totalLen = headerLen + payloadLen
+    public abstract fun writeLengthPlaceholder(output: ByteBuf)
+    public abstract fun setLength(output: ByteBuf, index: Int, written: Int)
 
+    public open fun allocateBuffer(alloc: ByteBufAllocator, input: T, preferDirect: Boolean): ByteBuf {
         return if (preferDirect) {
-            alloc.ioBuffer(totalLen, totalLen)
+            alloc.ioBuffer()
         } else {
-            alloc.heapBuffer(totalLen, totalLen)
+            alloc.heapBuffer()
         }
     }
 }

protocol/src/main/kotlin/org/openrs2/protocol/PacketLength.kt

@@ -1,6 +0,0 @@
-package org.openrs2.protocol
-
-public object PacketLength {
-    public const val VARIABLE_SHORT: Int = -2
-    public const val VARIABLE_BYTE: Int = -1
-}

protocol/src/main/kotlin/org/openrs2/protocol/Rs2Decoder.kt

@@ -32,29 +32,17 @@ public class Rs2Decoder(public var protocol: Protocol) : ByteToMessageDecoder()
 
             val opcode = (input.readUnsignedByte().toInt() - cipher.nextInt()) and 0xFF
             decoder = protocol.getDecoder(opcode) ?: throw DecoderException("Unsupported opcode: $opcode")
-            length = decoder.length
 
             state = State.READ_LENGTH
         }
 
         if (state == State.READ_LENGTH) {
-            when (length) {
+            if (!decoder.isLengthReadable(input)) {
-                PacketLength.VARIABLE_BYTE -> {
+                return
-                    if (!input.isReadable) {
-                        return
-                    }
-
-                    length = input.readUnsignedByte().toInt()
-                }
-                PacketLength.VARIABLE_SHORT -> {
-                    if (input.readableBytes() < 2) {
-                        return
-                    }
-
-                    length = input.readUnsignedShort()
-                }
             }
 
+            length = decoder.readLength(input)
+
             state = State.READ_PAYLOAD
         }
 

protocol/src/main/kotlin/org/openrs2/protocol/Rs2Encoder.kt

@@ -16,39 +16,14 @@ public class Rs2Encoder(public var protocol: Protocol) : MessageToByteEncoder<Pa
 
         out.writeByte(encoder.opcode + cipher.nextInt())
 
-        val len = encoder.length
         val lenIndex = out.writerIndex()
-        when (len) {
+        encoder.writeLengthPlaceholder(out)
-            PacketLength.VARIABLE_BYTE -> out.writeZero(1)
-            PacketLength.VARIABLE_SHORT -> out.writeZero(2)
-        }
 
         val payloadIndex = out.writerIndex()
         encoder.encode(msg, out, cipher)
 
         val written = out.writerIndex() - payloadIndex
-
+        encoder.setLength(out, lenIndex, written)
-        when (len) {
-            PacketLength.VARIABLE_BYTE -> {
-                if (written >= 256) {
-                    throw EncoderException("Variable byte payload too long: $written bytes")
-                }
-
-                out.setByte(lenIndex, written)
-            }
-            PacketLength.VARIABLE_SHORT -> {
-                if (written >= 65536) {
-                    throw EncoderException("Variable short payload too long: $written bytes")
-                }
-
-                out.setShort(lenIndex, written)
-            }
-            else -> {
-                if (written != len) {
-                    throw EncoderException("Fixed payload length mismatch (expected $len bytes, got $written bytes)")
-                }
-            }
-        }
     }
 
     override fun allocateBuffer(ctx: ChannelHandlerContext, msg: Packet, preferDirect: Boolean): ByteBuf {

protocol/src/main/kotlin/org/openrs2/protocol/VariableBytePacketCodec.kt

@@ -0,0 +1,47 @@
+package org.openrs2.protocol
+
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.ByteBufAllocator
+import io.netty.handler.codec.EncoderException
+
+public abstract class VariableBytePacketCodec<T : Packet>(
+    type: Class<T>,
+    opcode: Int
+) : PacketCodec<T>(type, opcode) {
+    override fun isLengthReadable(input: ByteBuf): Boolean {
+        return input.isReadable
+    }
+
+    override fun readLength(input: ByteBuf): Int {
+        return input.readUnsignedByte().toInt()
+    }
+
+    override fun writeLengthPlaceholder(output: ByteBuf) {
+        output.writeZero(1)
+    }
+
+    override fun setLength(output: ByteBuf, index: Int, written: Int) {
+        if (written >= 256) {
+            throw EncoderException("Variable byte payload too long: $written bytes")
+        }
+
+        output.setByte(index, written)
+    }
+
+    public open fun getLength(input: T): Int {
+        return -1
+    }
+
+    override fun allocateBuffer(alloc: ByteBufAllocator, input: T, preferDirect: Boolean): ByteBuf {
+        val length = getLength(input)
+        if (length < 0) {
+            return super.allocateBuffer(alloc, input, preferDirect)
+        }
+
+        return if (preferDirect) {
+            alloc.ioBuffer(2 + length, 2 + length)
+        } else {
+            alloc.heapBuffer(2 + length, 2 + length)
+        }
+    }
+}

protocol/src/main/kotlin/org/openrs2/protocol/VariableShortPacketCodec.kt

@@ -0,0 +1,47 @@
+package org.openrs2.protocol
+
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.ByteBufAllocator
+import io.netty.handler.codec.EncoderException
+
+public abstract class VariableShortPacketCodec<T : Packet>(
+    type: Class<T>,
+    opcode: Int
+) : PacketCodec<T>(type, opcode) {
+    override fun isLengthReadable(input: ByteBuf): Boolean {
+        return input.readableBytes() >= 2
+    }
+
+    override fun readLength(input: ByteBuf): Int {
+        return input.readUnsignedShort()
+    }
+
+    override fun writeLengthPlaceholder(output: ByteBuf) {
+        output.writeZero(2)
+    }
+
+    override fun setLength(output: ByteBuf, index: Int, written: Int) {
+        if (written >= 65536) {
+            throw EncoderException("Variable short payload too long: $written bytes")
+        }
+
+        output.setShort(index, written)
+    }
+
+    public open fun getLength(input: T): Int {
+        return -2
+    }
+
+    override fun allocateBuffer(alloc: ByteBufAllocator, input: T, preferDirect: Boolean): ByteBuf {
+        val length = getLength(input)
+        if (length < 0) {
+            return super.allocateBuffer(alloc, input, preferDirect)
+        }
+
+        return if (preferDirect) {
+            alloc.ioBuffer(3 + length, 3 + length)
+        } else {
+            alloc.heapBuffer(3 + length, 3 + length)
+        }
+    }
+}

protocol/src/main/kotlin/org/openrs2/protocol/login/upstream/CheckWorldSuitabilityCodec.kt

@@ -9,8 +9,7 @@ import org.openrs2.crypto.Rsa
 import org.openrs2.crypto.StreamCipher
 import org.openrs2.crypto.rsa
 import org.openrs2.crypto.secureRandom
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.VariableBytePacketCodec
-import org.openrs2.protocol.PacketLength
 import org.openrs2.util.Base37
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -18,10 +17,9 @@ import javax.inject.Singleton
 @Singleton
 public class CheckWorldSuitabilityCodec @Inject constructor(
     private val key: RSAPrivateCrtKeyParameters
-) : PacketCodec<LoginRequest.CheckWorldSuitability>(
+) : VariableBytePacketCodec<LoginRequest.CheckWorldSuitability>(
     type = LoginRequest.CheckWorldSuitability::class.java,
-    opcode = 24,
+    opcode = 24
-    length = PacketLength.VARIABLE_BYTE
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): LoginRequest.CheckWorldSuitability {
         val build = input.readShort().toInt()

protocol/src/main/kotlin/org/openrs2/protocol/login/upstream/CreateCheckDateOfBirthCountryCodec.kt

@@ -2,12 +2,12 @@ package org.openrs2.protocol.login.upstream
 
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.FixedPacketCodec
 import java.time.LocalDate
 import javax.inject.Singleton
 
 @Singleton
-public class CreateCheckDateOfBirthCountryCodec : PacketCodec<LoginRequest.CreateCheckDateOfBirthCountry>(
+public class CreateCheckDateOfBirthCountryCodec : FixedPacketCodec<LoginRequest.CreateCheckDateOfBirthCountry>(
     type = LoginRequest.CreateCheckDateOfBirthCountry::class.java,
     opcode = 20,
     length = 6

protocol/src/main/kotlin/org/openrs2/protocol/login/upstream/CreateCheckNameCodec.kt

@@ -2,12 +2,12 @@ package org.openrs2.protocol.login.upstream
 
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.FixedPacketCodec
 import org.openrs2.util.Base37
 import javax.inject.Singleton
 
 @Singleton
-public class CreateCheckNameCodec : PacketCodec<LoginRequest.CreateCheckName>(
+public class CreateCheckNameCodec : FixedPacketCodec<LoginRequest.CreateCheckName>(
     type = LoginRequest.CreateCheckName::class.java,
     opcode = 21,
     length = 8

protocol/src/main/kotlin/org/openrs2/protocol/login/upstream/InitGameConnectionCodec.kt

@@ -2,14 +2,14 @@ package org.openrs2.protocol.login.upstream
 
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.FixedPacketCodec
 import javax.inject.Singleton
 
 @Singleton
-public class InitGameConnectionCodec : PacketCodec<LoginRequest.InitGameConnection>(
+public class InitGameConnectionCodec : FixedPacketCodec<LoginRequest.InitGameConnection>(
+    type = LoginRequest.InitGameConnection::class.java,
     opcode = 14,
-    length = 1,
+    length = 1
-    type = LoginRequest.InitGameConnection::class.java
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): LoginRequest.InitGameConnection {
         val usernameHash = input.readUnsignedByte().toInt()

protocol/src/main/kotlin/org/openrs2/protocol/login/upstream/InitJs5RemoteConnectionCodec.kt

@@ -2,11 +2,11 @@ package org.openrs2.protocol.login.upstream
 
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.FixedPacketCodec
 import javax.inject.Singleton
 
 @Singleton
-public class InitJs5RemoteConnectionCodec : PacketCodec<LoginRequest.InitJs5RemoteConnection>(
+public class InitJs5RemoteConnectionCodec : FixedPacketCodec<LoginRequest.InitJs5RemoteConnection>(
     type = LoginRequest.InitJs5RemoteConnection::class.java,
     opcode = 15,
     length = 4

protocol/src/main/kotlin/org/openrs2/protocol/login/upstream/RequestWorldListCodec.kt

@@ -2,11 +2,11 @@ package org.openrs2.protocol.login.upstream
 
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.FixedPacketCodec
 import javax.inject.Singleton
 
 @Singleton
-public class RequestWorldListCodec : PacketCodec<LoginRequest.RequestWorldList>(
+public class RequestWorldListCodec : FixedPacketCodec<LoginRequest.RequestWorldList>(
     type = LoginRequest.RequestWorldList::class.java,
     opcode = 23,
     length = 4

protocol/src/main/kotlin/org/openrs2/protocol/world/downstream/WorldListResponseCodec.kt

@@ -6,15 +6,13 @@ import org.openrs2.buffer.readVersionedString
 import org.openrs2.buffer.writeUnsignedShortSmart
 import org.openrs2.buffer.writeVersionedString
 import org.openrs2.crypto.StreamCipher
-import org.openrs2.protocol.PacketCodec
+import org.openrs2.protocol.VariableShortPacketCodec
-import org.openrs2.protocol.PacketLength
 import javax.inject.Singleton
 
 @Singleton
-public class WorldListResponseCodec : PacketCodec<WorldListResponse>(
+public class WorldListResponseCodec : VariableShortPacketCodec<WorldListResponse>(
     type = WorldListResponse::class.java,
-    opcode = 0,
+    opcode = 0
-    length = PacketLength.VARIABLE_SHORT
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): WorldListResponse {
         val version = input.readUnsignedByte().toInt()

protocol/src/test/kotlin/org/openrs2/protocol/LengthMismatchPacketCodec.kt

@@ -3,7 +3,7 @@ package org.openrs2.protocol
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
 
-internal object LengthMismatchPacketCodec : PacketCodec<FixedPacket>(
+internal object LengthMismatchPacketCodec : FixedPacketCodec<FixedPacket>(
     type = FixedPacket::class.java,
     opcode = 0,
     length = 5

protocol/src/test/kotlin/org/openrs2/protocol/Rs2DecoderTest.kt

@@ -35,7 +35,7 @@ class Rs2DecoderTest {
 
     @Test
     fun testEncryptedOpcode() {
-        val decoder = Rs2Decoder(Protocol(FixedPacketCodec))
+        val decoder = Rs2Decoder(Protocol(TestFixedPacketCodec))
         decoder.cipher = TestStreamCipher
 
         val channel = EmbeddedChannel(decoder)
@@ -47,7 +47,7 @@ class Rs2DecoderTest {
 
     @Test
     fun testSwitchProtocol() {
-        val decoder = Rs2Decoder(Protocol(FixedPacketCodec))
+        val decoder = Rs2Decoder(Protocol(TestFixedPacketCodec))
         val channel = EmbeddedChannel(decoder)
 
         channel.writeInbound(wrappedBuffer(0, 0x11, 0x22, 0x33, 0x44))
@@ -73,9 +73,9 @@ class Rs2DecoderTest {
         val channel = EmbeddedChannel(
             Rs2Decoder(
                 Protocol(
-                    FixedPacketCodec,
+                    TestFixedPacketCodec,
-                    VariableBytePacketCodec,
+                    TestVariableBytePacketCodec,
-                    VariableShortPacketCodec,
+                    TestVariableShortPacketCodec,
                     VariableByteOptimisedPacketCodec,
                     VariableShortOptimisedPacketCodec,
                     TestEmptyPacketCodec
@@ -92,9 +92,9 @@ class Rs2DecoderTest {
         val channel = EmbeddedChannel(
             Rs2Decoder(
                 Protocol(
-                    FixedPacketCodec,
+                    TestFixedPacketCodec,
-                    VariableBytePacketCodec,
+                    TestVariableBytePacketCodec,
-                    VariableShortPacketCodec,
+                    TestVariableShortPacketCodec,
                     VariableByteOptimisedPacketCodec,
                     VariableShortOptimisedPacketCodec
                 )

protocol/src/test/kotlin/org/openrs2/protocol/Rs2EncoderTest.kt

@@ -24,8 +24,8 @@ class Rs2EncoderTest {
         val channel = EmbeddedChannel(
             Rs2Encoder(
                 Protocol(
-                    VariableBytePacketCodec,
+                    TestVariableBytePacketCodec,
-                    VariableShortPacketCodec
+                    TestVariableShortPacketCodec
                 )
             )
         )
@@ -71,7 +71,7 @@ class Rs2EncoderTest {
 
     @Test
     fun testEncryptedOpcode() {
-        val encoder = Rs2Encoder(Protocol(FixedPacketCodec))
+        val encoder = Rs2Encoder(Protocol(TestFixedPacketCodec))
         encoder.cipher = TestStreamCipher
 
         val channel = EmbeddedChannel(encoder)
@@ -86,7 +86,7 @@ class Rs2EncoderTest {
 
     @Test
     fun testSwitchProtocol() {
-        val encoder = Rs2Encoder(Protocol(FixedPacketCodec))
+        val encoder = Rs2Encoder(Protocol(TestFixedPacketCodec))
         val channel = EmbeddedChannel(encoder)
 
         channel.writeOutbound(FixedPacket(0x11223344))
@@ -115,9 +115,9 @@ class Rs2EncoderTest {
         val channel = EmbeddedChannel(
             Rs2Encoder(
                 Protocol(
-                    FixedPacketCodec,
+                    TestFixedPacketCodec,
-                    VariableBytePacketCodec,
+                    TestVariableBytePacketCodec,
-                    VariableShortPacketCodec,
+                    TestVariableShortPacketCodec,
                     VariableByteOptimisedPacketCodec,
                     VariableShortOptimisedPacketCodec,
                     TestEmptyPacketCodec

protocol/src/test/kotlin/org/openrs2/protocol/TestFixedPacketCodec.kt

@@ -3,7 +3,7 @@ package org.openrs2.protocol
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
 
-internal object FixedPacketCodec : PacketCodec<FixedPacket>(
+internal object TestFixedPacketCodec : FixedPacketCodec<FixedPacket>(
     type = FixedPacket::class.java,
     opcode = 0,
     length = 4

protocol/src/test/kotlin/org/openrs2/protocol/TestVariableBytePacketCodec.kt

@@ -3,10 +3,9 @@ package org.openrs2.protocol
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
 
-internal object VariableBytePacketCodec : PacketCodec<VariableBytePacket>(
+internal object TestVariableBytePacketCodec : VariableBytePacketCodec<VariableBytePacket>(
     type = VariableBytePacket::class.java,
-    opcode = 1,
+    opcode = 1
-    length = PacketLength.VARIABLE_BYTE
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): VariableBytePacket {
         val value = ByteArray(input.readableBytes())

protocol/src/test/kotlin/org/openrs2/protocol/TestVariableShortPacketCodec.kt

@@ -3,10 +3,9 @@ package org.openrs2.protocol
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
 
-internal object VariableShortPacketCodec : PacketCodec<VariableShortPacket>(
+internal object TestVariableShortPacketCodec : VariableShortPacketCodec<VariableShortPacket>(
     type = VariableShortPacket::class.java,
-    opcode = 2,
+    opcode = 2
-    length = PacketLength.VARIABLE_SHORT
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): VariableShortPacket {
         val value = ByteArray(input.readableBytes())

protocol/src/test/kotlin/org/openrs2/protocol/VariableByteOptimisedPacketCodec.kt

@@ -3,10 +3,9 @@ package org.openrs2.protocol
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
 
-internal object VariableByteOptimisedPacketCodec : PacketCodec<VariableByteOptimisedPacket>(
+internal object VariableByteOptimisedPacketCodec : VariableBytePacketCodec<VariableByteOptimisedPacket>(
     type = VariableByteOptimisedPacket::class.java,
-    opcode = 3,
+    opcode = 3
-    length = PacketLength.VARIABLE_BYTE
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): VariableByteOptimisedPacket {
         val value = ByteArray(input.readableBytes())

protocol/src/test/kotlin/org/openrs2/protocol/VariableShortOptimisedPacketCodec.kt

@@ -3,10 +3,9 @@ package org.openrs2.protocol
 import io.netty.buffer.ByteBuf
 import org.openrs2.crypto.StreamCipher
 
-internal object VariableShortOptimisedPacketCodec : PacketCodec<VariableShortOptimisedPacket>(
+internal object VariableShortOptimisedPacketCodec : VariableShortPacketCodec<VariableShortOptimisedPacket>(
     type = VariableShortOptimisedPacket::class.java,
-    opcode = 4,
+    opcode = 4
-    length = PacketLength.VARIABLE_SHORT
 ) {
     override fun decode(input: ByteBuf, cipher: StreamCipher): VariableShortOptimisedPacket {
         val value = ByteArray(input.readableBytes())