Packetlogger: More granular scoping

Author: Avanatiker

common/src/main/kotlin/com/lambda/module/modules/Packetlogger.kt

@@ -8,6 +8,7 @@ import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.UnsafeListener.Companion.unsafeConcurrentListener
 import com.lambda.event.listener.UnsafeListener.Companion.unsafeListener
 import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
 import com.lambda.util.Communication
 import com.lambda.util.Communication.info
 import com.lambda.util.DynamicReflectionSerializer.dynamicString
@@ -26,23 +27,41 @@ import kotlin.io.path.pathString
 
 object Packetlogger : Module(
     name = "Packetlogger",
-    description = "Logs packets",
-    defaultTags = setOf()
+    description = "Serializes network traffic and persists it for later analysis",
+    defaultTags = setOf(ModuleTag.DEBUG)
 ) {
-    private val logIncoming by setting("Log Incoming", true, "Log incoming packets")
-    private val logOutgoing by setting("Log Outgoing", true, "Log outgoing packets")
+    private val logToChat by setting("Log To Chat", false, "Log packets to chat")
+    // ToDo: Implement HUD logging when HUD is done
+//    private val logToHUD by setting("Log To HUD", false, "Log packets to HUD")
+    private val networkSide by setting("Network Side", NetworkSide.ANY, "Side of the network to log packets from")
     private val logTicks by setting("Log Ticks", true, "Show game ticks in the log")
-    private val logWhitelist by setting("Whitelist", false, "Only log packets from the whitelist")
-    private val whitelist by setting("Whitelist Packets", emptyList<String>(), "Packets to whitelist")
-    private val logBlacklist by setting("Blacklist", false, "Log all packets except those from the blacklist")
-    private val blacklist by setting("Blacklist Packets", emptyList<String>(), "Packets to blacklist")
+    private val scope by setting("Scope", Scope.ANY, "Scope of packets to log")
+    private val whitelist by setting("Whitelist Packets", emptyList<String>(), "Packets to whitelist") { scope == Scope.WHITELIST }
+    private val blacklist by setting("Blacklist Packets", emptyList<String>(), "Packets to blacklist") { scope == Scope.BLACKLIST }
     private val maxRecursionDepth by setting("Max Recursion Depth", 6, 1..10, 1, "Maximum recursion depth for packet serialization")
     private val logConcurrent by setting("Build Data Concurrent", false, "Whether to serialize packets concurrently. Will not save packets in chronological order but wont lag the game.")
 
     private var file: File? = null
     private val entryFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSSS")
     private val fileFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss.SSSS")
 
+    enum class NetworkSide {
+        ANY, CLIENT, SERVER;
+
+        fun shouldLog(networkSide: NetworkSide) =
+            this == ANY || this == networkSide
+    }
+
+    enum class Scope {
+        ANY, WHITELIST, BLACKLIST;
+
+        fun shouldLog(packet: Packet<*>) = when (this) {
+            ANY -> true
+            WHITELIST -> packet::class.simpleName in whitelist
+            BLACKLIST -> packet::class.simpleName !in blacklist
+        }
+    }
+
     private val storageFlow = MutableSharedFlow<String>(
         extraBufferCapacity = 1000,
         onBufferOverflow = BufferOverflow.DROP_OLDEST
@@ -53,6 +72,7 @@ object Packetlogger : Module(
         lambdaScope.launch(Dispatchers.IO) {
             storageFlow.collect { entry ->
                 file?.appendText(entry)
+                if (logToChat) this@Packetlogger.info(entry)
             }
         }
 
@@ -117,29 +137,42 @@ object Packetlogger : Module(
         unsafeListener<TickEvent.Pre> {
             if (!logTicks) return@unsafeListener
 
-            storageFlow.tryEmit("\nStarted tick at ${getTime(entryFormatter)}\n")
+            storageFlow.tryEmit("Started tick at ${getTime(entryFormatter)}\n\n")
         }
 
         unsafeListener<PacketEvent.Receive.Pre> {
-            if (logConcurrent || !logIncoming || it.packet.notLog()) return@unsafeListener
+            if (logConcurrent
+                || !scope.shouldLog(it.packet)
+                || !networkSide.shouldLog(NetworkSide.SERVER)
+            ) return@unsafeListener
 
             it.packet.logReceived()
         }
 
         unsafeListener<PacketEvent.Send.Pre> {
-            if (logConcurrent || !logOutgoing || it.packet.notLog()) return@unsafeListener
+            if (logConcurrent
+                || !scope.shouldLog(it.packet)
+                || !networkSide.shouldLog(NetworkSide.CLIENT)
+            ) return@unsafeListener
+
 
             it.packet.logSent()
         }
 
         unsafeConcurrentListener<PacketEvent.Receive.Pre> {
-            if (!logConcurrent || !logIncoming || it.packet.notLog()) return@unsafeConcurrentListener
+            if (!logConcurrent
+                || !scope.shouldLog(it.packet)
+                || !networkSide.shouldLog(NetworkSide.SERVER)
+            ) return@unsafeConcurrentListener
 
             it.packet.logReceived()
         }
 
         unsafeConcurrentListener<PacketEvent.Send.Pre> {
-            if (!logConcurrent || !logOutgoing || it.packet.notLog()) return@unsafeConcurrentListener
+            if (!logConcurrent
+                || !scope.shouldLog(it.packet)
+                || !networkSide.shouldLog(NetworkSide.CLIENT)
+            ) return@unsafeConcurrentListener
 
             it.packet.logSent()
         }
@@ -152,8 +185,4 @@ object Packetlogger : Module(
     private fun Packet<*>.logSent() {
         storageFlow.tryEmit("Sent at ${getTime(entryFormatter)}\n${dynamicString(maxRecursionDepth)}\n")
     }
-
-    private fun Packet<*>.notLog() =
-        (logWhitelist && this::class.simpleName !in whitelist)
-                || (logBlacklist && this::class.simpleName in blacklist)
 }

common/src/main/kotlin/com/lambda/module/tag/ModuleTag.kt

@@ -27,5 +27,6 @@ class ModuleTag(override val name: String) : Nameable {
         val HIDDEN = ModuleTag("Hidden")
         val GRIM = ModuleTag("Grim")
         val BYPASS = ModuleTag("Bypass")
+        val DEBUG = ModuleTag("Debug")
     }
 }