Merge branch 'master' into feature/combat

Author: emyfops

common/src/main/kotlin/com/lambda/Lambda.kt

@@ -32,6 +32,8 @@ import com.mojang.authlib.GameProfile
 import com.mojang.blaze3d.systems.RenderSystem.recordRenderCall
 import net.minecraft.block.Block
 import net.minecraft.client.MinecraftClient
+import net.minecraft.item.ItemStack
+import net.minecraft.text.Text
 import net.minecraft.util.math.BlockPos
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.Logger
@@ -61,6 +63,8 @@ object Lambda {
         .registerTypeAdapter(Block::class.java, BlockSerializer)
         .registerTypeAdapter(GameProfile::class.java, GameProfileSerializer)
         .registerTypeAdapter(Optional::class.java, OptionalSerializer)
+        .registerTypeAdapter(ItemStack::class.java, ItemStackSerializer)
+        .registerTypeAdapter(Text::class.java, Text.Serializer())
         .create()
 
     fun initialize(block: (Long) -> Unit) {

common/src/main/kotlin/com/lambda/config/groups/Targeting.kt

@@ -24,7 +24,7 @@ import com.lambda.interaction.rotation.Rotation.Companion.dist
 import com.lambda.interaction.rotation.Rotation.Companion.rotation
 import com.lambda.interaction.rotation.Rotation.Companion.rotationTo
 import com.lambda.threading.runSafe
-import com.lambda.util.math.VecUtils.distSq
+import com.lambda.util.math.distSq
 import com.lambda.util.world.fastEntitySearch
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.client.network.OtherClientPlayerEntity
@@ -41,16 +41,16 @@ import java.util.UUID
  * based on player settings and entity characteristics. It allows for specifying which types of entities
  * are targetable, the range of targeting, and various other conditions for targeting.
  *
- * @property owner The [Configurable] instance used to get and set configuration options for targeting.
- * @property predicate The predicate used to determine whether the targeting settings are visible and active.
- * @property defaultRange The default range within which entities can be targeted.
- * @property maxRange The maximum range within which entities can be targeted.
+ * @param owner The [Configurable] instance used to get and set configuration options for targeting.
+ * @param predicate The predicate used to determine whether the targeting settings are visible and active.
+ * @param defaultRange The default range within which entities can be targeted.
+ * @param maxRange The maximum range within which entities can be targeted.
  */
 abstract class Targeting(
-    owner: Configurable,
-    predicate: () -> Boolean = { true },
-    defaultRange: Double,
-    maxRange: Double,
+    private val owner: Configurable,
+    private val predicate: () -> Boolean = { true },
+    private val defaultRange: Double,
+    private val maxRange: Double,
 ) : TargetingConfig {
 
     /**

common/src/main/kotlin/com/lambda/config/serializer/ItemStackSerializer.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.config.serializer
+
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.StringNbtReader
+import net.minecraft.nbt.visitor.StringNbtWriter
+import net.minecraft.registry.Registries
+import net.minecraft.util.Identifier
+import java.lang.reflect.Type
+
+object ItemStackSerializer : JsonSerializer<ItemStack>, JsonDeserializer<ItemStack> {
+    override fun serialize(
+        stack: ItemStack,
+        typeOfSrc: Type,
+        context: JsonSerializationContext
+    ): JsonElement =
+        JsonObject().apply {
+            addProperty("id", stack.item.registryEntry.key.get().value.toString())
+            addProperty("count", stack.count)
+            stack.nbt?.let { addProperty("tag", StringNbtWriter().apply(it)) }
+        }
+
+    override fun deserialize(
+        json: JsonElement,
+        typeOfT: Type,
+        context: JsonDeserializationContext
+    ): ItemStack {
+        val id = json.asJsonObject.get("id").asString
+        val count = json.asJsonObject.get("count").asInt
+        val nbt = json.asJsonObject?.get("tag")?.asString
+
+        val item = Registries.ITEM.get(Identifier(id))
+
+        return ItemStack(item, count).apply { nbt?.let { setNbt(StringNbtReader.parse(it)) } }
+    }
+}

common/src/main/kotlin/com/lambda/core/TimerManager.kt

@@ -19,16 +19,33 @@ package com.lambda.core
 
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.ClientEvent
+import kotlin.concurrent.fixedRateTimer
 
 object TimerManager : Loadable {
     var lastTickLength: Float = 50f
 
     override fun load() = "Loaded Timer Manager"
 
+    private const val TICK_DELAY = 50L
+    private var start = 0L
+    val fixedTickDelta get() = (System.currentTimeMillis() - start).mod(TICK_DELAY).toDouble() / TICK_DELAY
+
+    init {
+        fixedRateTimer(
+            daemon = true,
+            name = "Scheduler-Lambda-Tick",
+            initialDelay = 0,
+            period = TICK_DELAY
+        ) {
+            if (start == 0L) start = System.currentTimeMillis()
+            ClientEvent.FixedTick(this).post()
+        }
+    }
+
     fun getLength(): Float {
         var length = 50f
 
-        ClientEvent.Timer(1.0).post {
+        ClientEvent.TimerUpdate(1.0).post {
             length /= speed.toFloat()
         }
 

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

@@ -25,6 +25,7 @@ import com.lambda.threading.runSafe
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
+import java.util.*
 
 
 /**

common/src/main/kotlin/com/lambda/event/events/ClientEvent.kt

@@ -18,9 +18,11 @@
 package com.lambda.event.events
 
 import com.lambda.event.Event
+import com.lambda.event.EventFlow
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
 import net.minecraft.client.sound.SoundInstance
+import java.util.TimerTask
 
 sealed class ClientEvent {
     /**
@@ -38,10 +40,20 @@ sealed class ClientEvent {
      *
      * @property speed The speed of the timer.
      */
-    data class Timer(var speed: Double) : Event
+    data class TimerUpdate(var speed: Double) : Event
 
     /**
      * Triggered before playing a sound
      */
     data class Sound(val sound: SoundInstance) : ICancellable by Cancellable()
+
+    /**
+     * Represents a fixed tick event in the application.
+     *
+     * A fixed tick can be used to execute a specific task consistently at regular intervals, based on the provided
+     * timer task. This event is part of the event system and can be subscribed to for handling the specified timer task.
+     *
+     * @property timerTask The task that is executed during this fixed tick event.
+     */
+    data class FixedTick(val timerTask: TimerTask) : Event
 }

common/src/main/kotlin/com/lambda/event/listener/SafeListener.kt

@@ -22,6 +22,7 @@ import com.lambda.event.Event
 import com.lambda.event.EventFlow
 import com.lambda.event.Muteable
 import com.lambda.threading.runConcurrent
+import com.lambda.threading.runGameScheduled
 import com.lambda.threading.runSafe
 import com.lambda.util.Pointer
 import com.lambda.util.selfReference
@@ -121,7 +122,7 @@ class SafeListener<T : Event>(
             noinline function: SafeContext.(T) -> Unit = {},
         ): SafeListener<T> {
             val listener = SafeListener<T>(priority, this, alwaysListen) { event ->
-                function(event)
+                runGameScheduled { function(event) }
             }
 
             EventFlow.syncListeners.subscribe(listener)

common/src/main/kotlin/com/lambda/graphics/renderer/esp/DynamicAABB.kt

@@ -17,11 +17,8 @@
 
 package com.lambda.graphics.renderer.esp
 
-import com.lambda.util.math.VecUtils.minus
-import com.lambda.util.math.VecUtils.plus
-import com.lambda.util.extension.max
-import com.lambda.util.extension.min
 import com.lambda.util.extension.prevPos
+import com.lambda.util.math.minus
 import net.minecraft.entity.Entity
 import net.minecraft.util.math.Box
 

common/src/main/kotlin/com/lambda/gui/api/LambdaGui.kt

@@ -19,6 +19,7 @@ package com.lambda.gui.api
 
 import com.lambda.Lambda.mc
 import com.lambda.event.Muteable
+import com.lambda.event.events.ClientEvent
 import com.lambda.event.events.RenderEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen

common/src/main/kotlin/com/lambda/gui/api/component/core/DockingRect.kt

@@ -57,12 +57,15 @@ abstract class DockingRect {
     var screenSize: Vec2d = Vec2d.ZERO
 
     var position: Vec2d
-        get() = relativeToAbs(relativePos).coerceIn(0.0, screenSize.x - size.x, 0.0, screenSize.y - size.y)
+        get() = relativeToAbs(relativePos)
+            .coerceIn(0.0, screenSize.x - size.x, 0.0, screenSize.y - size.y)
         set(value) {
-            relativePos = absToRelative(value.roundToStep(ClickGui.dockingGridSize)); if (autoDocking) autoDocking()
+            relativePos = absToRelative(value.roundToStep(ClickGui.dockingGridSize))
+            if (autoDocking) autoDocking()
         }
 
-    private val dockingOffset get() = (screenSize - size) * Vec2d(dockingH.multiplier, dockingV.multiplier)
+    private val dockingOffset get() =
+        (screenSize - size) * Vec2d(dockingH.multiplier, dockingV.multiplier)
 
     private fun relativeToAbs(posIn: Vec2d) = posIn + dockingOffset
     private fun absToRelative(posIn: Vec2d) = posIn - dockingOffset