KDoc: Modules

Author: Avanatiker

common/src/main/kotlin/com/lambda/event/Muteable.kt

@@ -1,5 +1,18 @@
 package com.lambda.event
 
+/**
+ * The [Muteable] interface represents any listening object that may need
+ * to temporarily stop listening to events.
+ *
+ * Implementing this interface allows an object to
+ * control its listening state through the [isMuted] property.
+ * When [isMuted] is `true`, the object will not receive or process events.
+ *
+ * This can be useful in scenarios where an object's event handling behavior should be paused, for example,
+ * when the object is in a certain state or when a specific condition is met.
+ *
+ * @property isMuted A flag indicating whether the object is currently muted.
+ */
 interface Muteable {
     val isMuted: Boolean
 }

common/src/main/kotlin/com/lambda/event/Subscriber.kt

@@ -5,35 +5,47 @@ import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentSkipListSet
 import kotlin.reflect.KClass
 
+/**
+ * The [Subscriber] class is a specialized [ConcurrentHashMap]
+ * that manages sets of [Listener]s for different [Event] types.
+ *
+ * It provides methods to [subscribe] and [unsubscribe] [Listener]s and other [Subscriber]s.
+ * It also allows for the merging of [Subscriber] [Set]s.
+ *
+ * @property defaultListenerSet A [ConcurrentSkipListSet] of [Listener]s, sorted in reverse order.
+ */
 class Subscriber : ConcurrentHashMap<KClass<*>, ConcurrentSkipListSet<Listener>>() {
+    val defaultListenerSet: ConcurrentSkipListSet<Listener>
+        get() = ConcurrentSkipListSet(Comparator.reverseOrder())
+
+
+    /** Allows a [Listener] to start receiving a specific type of [Event] */
     inline fun <reified T : Event> subscribe(listener: Listener) =
-        getOrPut(T::class) {
-            defaultListenerSet()
-        }.add(listener)
+        getOrPut(T::class) { defaultListenerSet }.add(listener)
 
+
+    /** Forgets about every [Listener]s association to [eventType] */
     fun unsubscribe(eventType: KClass<*>) = remove(eventType)
 
+    /** Allows a [Listener] to stop receiving a specific type of [Event] */
     fun unsubscribe(listener: Listener) {
         values.forEach { listeners ->
             listeners.remove(listener)
         }
     }
 
+    /** Allows a [Subscriber] to start receiving all [Event]s of another [Subscriber]. */
     infix fun subscribe(subscriber: Subscriber) {
         subscriber.forEach { (eventType, listeners) ->
-            getOrPut(eventType) {
-                defaultListenerSet()
-            }.addAll(listeners)
+            getOrPut(eventType) { defaultListenerSet }.addAll(listeners)
         }
     }
 
+    /** Allows a [Subscriber] to stop receiving all [Event]s of another [Subscriber] */
     infix fun unsubscribe(subscriber: Subscriber) {
         entries.removeAll { (eventType, listeners) ->
             subscriber[eventType]?.let { listeners.removeAll(it) }
             listeners.isEmpty()
         }
     }
-
-    fun defaultListenerSet(): ConcurrentSkipListSet<Listener> =
-        ConcurrentSkipListSet(Comparator.reverseOrder())
 }

common/src/main/kotlin/com/lambda/module/ModuleConfig.kt

@@ -4,6 +4,15 @@ import com.lambda.config.Configuration
 import com.lambda.util.FolderRegister
 import java.io.File
 
+
+/**
+ * The [ModuleConfig] object represents the configuration file for the [Module]s.
+ *
+ * This object is used to save and load the settings of all [Module]s in the system.
+ *
+ * @property configName The name of the configuration.
+ * @property primary The primary file where the configuration is saved.
+ */
 object ModuleConfig : Configuration() {
     override val configName = "modules"
     override val primary = File(FolderRegister.config, "$configName.json")

common/src/main/kotlin/com/lambda/module/ModuleRegistry.kt

@@ -3,10 +3,16 @@ package com.lambda.module
 import com.lambda.event.events.ClientEvent
 import com.lambda.event.listener.UnsafeListener.Companion.unsafeListener
 import org.reflections.Reflections
+import org.reflections.scanners.Scanners
 import org.reflections.scanners.SubTypesScanner
 import org.reflections.util.ClasspathHelper
 import org.reflections.util.ConfigurationBuilder
 
+/**
+ * The [ModuleRegistry] object is responsible for managing all [Module] instances in the system.
+ *
+ * @property modules A set of all [Module] instances in the system.
+ */
 object ModuleRegistry {
     private val modules = mutableSetOf<Module>()
 
@@ -15,7 +21,7 @@ object ModuleRegistry {
             Reflections(
                 ConfigurationBuilder()
                     .setUrls(ClasspathHelper.forPackage("com.lambda.module.modules"))
-                    .setScanners(SubTypesScanner()) // ToDo: Deprecated, use Scanners.SubTypes instead
+                    .setScanners(Scanners.SubTypes)
             ).getSubTypesOf(Module::class.java).forEach { moduleClass ->
                 moduleClass.declaredFields.find {
                     it.name == "INSTANCE"

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

@@ -6,7 +6,6 @@ import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.KeyCode
-import net.minecraft.block.Blocks
 import net.minecraft.util.math.BlockPos
 
 object BoringModule : Module(

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

@@ -2,6 +2,19 @@ package com.lambda.module.tag
 
 import com.lambda.util.Nameable
 
+/**
+ * The [ModuleTag] class represents a tag, that can be associated in any cardinality with a [Module].
+ *
+ * Tags are used to categorize and organize modules, making them easier to find.
+ * They can be custom created as per the user's needs.
+ *
+ * Additionally, [ModuleTag] can be used to create groups of tags, which can be useful for creating new GUI windows.
+ *
+ * The companion object provides a set of predefined `ModuleTag` instances for common categories like "Combat",
+ * "Movement", "Render", etc.
+ *
+ * @param name The name of the tag.
+ */
 class ModuleTag(override val name: String) : Nameable {
     companion object {
         val COMBAT = ModuleTag("Combat")

common/src/main/kotlin/com/lambda/util/FolderRegister.kt

@@ -3,6 +3,13 @@ package com.lambda.util
 import com.lambda.Lambda.mc
 import java.io.File
 
+/**
+ * The [FolderRegister] object is responsible for managing the directory structure of the application.
+ *
+ * @property minecraft The root directory of the Minecraft client. It is retrieved using the `runDirectory` property of the Minecraft client instance.
+ * @property lambda The directory for the Lambda client, located within the Minecraft directory.
+ * @property config The directory for storing configuration files, located within the Lambda directory.
+ */
 object FolderRegister {
     val minecraft: File = mc.runDirectory
     val lambda: File = File(minecraft, "lambda")

common/src/main/kotlin/com/lambda/util/Nameable.kt

@@ -1,5 +1,8 @@
 package com.lambda.util
 
+/**
+ * @property name represents the name or identifier of the object.
+ */
 interface Nameable {
     val name: String
 }