feat: tps clock

Author: emyfops

common/src/main/kotlin/com/lambda/module/hud/TPS.kt

@@ -0,0 +1,51 @@
+/*
+ * 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.module.hud
+
+import com.lambda.module.HudModule
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.TpsClock.normalizedTickRate
+import com.lambda.util.math.MathUtils.format
+
+object TPS : HudModule(
+    name = "TPS",
+    description = "Display the server's tick rate",
+    defaultTags = setOf(ModuleTag.CLIENT, ModuleTag.NETWORK),
+) {
+    private val format by setting("Tick format", TickFormat.Tick)
+
+    private val text: String get() = "${format.string}: ${format.output().format(2)}"
+
+    // TODO: Replace by LambdaAtlas height cache
+
+    override val height: Double get() = 20.0
+    override val width: Double get() = 50.0
+
+    init {
+        onRender {
+            font.build(text, position)
+        }
+    }
+
+    private enum class TickFormat(val output: () -> Double, val string: String) {
+        Tick({ normalizedTickRate * 20 }, "TPS"),
+        Milliseconds({ normalizedTickRate * 50 }, "MSPS"),
+        Normalized({ normalizedTickRate }, "TPSN"),
+        Percentage({ normalizedTickRate * 100 }, "TPS%")
+    }
+}

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

@@ -0,0 +1,62 @@
+/*
+ * 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.util
+
+import com.lambda.event.events.ConnectionEvent
+import com.lambda.event.events.PacketEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.util.collections.LimitedDecayQueue
+import net.minecraft.network.packet.s2c.play.WorldTimeUpdateS2CPacket
+
+object TpsClock {
+    private val tickHistory = LimitedDecayQueue<Double>(120, 5000)
+    private var lastUpdate = 0L
+
+    /**
+     * Returns the average tick rate normalized between 0 and 1
+     */
+    val normalizedTickRate: Double
+        get() {
+            val average = tickHistory.average()
+            return if (average.isNaN()) 1.0 else average
+        }
+
+    /**
+     * Returns the average tick rate normalized multiplied by 20
+     */
+    val tickRate: Double get() = normalizedTickRate * 20
+
+    init {
+        listen<PacketEvent.Receive.Pre>(priority = 10000) {
+            if (it.packet !is WorldTimeUpdateS2CPacket) return@listen
+
+
+            if (lastUpdate != 0L) {
+                val timeElapsed = (System.nanoTime() - lastUpdate) / 1E9
+                tickHistory.add((1 / timeElapsed).coerceIn(0.0, 1.0))
+            }
+
+            lastUpdate = System.nanoTime()
+        }
+
+        listen<ConnectionEvent.Connect.Post> {
+            tickHistory.clear()
+            lastUpdate = 0
+        }
+    }
+}

common/src/main/kotlin/com/lambda/util/math/MathUtils.kt

@@ -82,5 +82,7 @@ object MathUtils {
 
     fun Int.nextPowerOf2() = 2f.pow(ceil(log2(toFloat()))).toInt()
 
+    fun Double.format(scale: Int) = "%.${scale}f".format(this)
+
     inline val Int.sq: Int get() = this * this
 }