feat: move runnables to end of functions, abolish TickDuration

gradle.properties

@@ -1,6 +1,6 @@
 kotlin.code.style=official
 
-project_version=0.3
+project_version=0.4
 maven_group=net.mcbrawls
 
 kotlin_version=1.9.20

src/main/kotlin/net/mcbrawls/scheduler/AbstractScheduler.kt

@@ -51,7 +51,7 @@ abstract class AbstractScheduler : Scheduler, Schedulable {
         return scheduledTask
     }
 
-    override fun schedule(runnable: Runnable, delay: Duration, repeatDelay: Duration?, executionType: ExecutionType): ScheduledTask {
+    override fun schedule(delay: Duration, repeatDelay: Duration?, executionType: ExecutionType, runnable: Runnable): ScheduledTask {
         val task = Task(runnable, executionType)
         return schedule(task, delay, repeatDelay)
     }

src/main/kotlin/net/mcbrawls/scheduler/RelativeScheduler.kt

@@ -1,27 +1,19 @@
 package net.mcbrawls.scheduler
 
 import net.mcbrawls.scheduler.duration.TickDuration
-import kotlin.time.Duration
 
 /**
  * A scheduler which performs in relation to a local tick variable.
  */
-class RelativeScheduler(
-    /**
-     * The amount of time which is simulated per tick.
-     */
-    durationPerTick: Duration = TickDuration.create(1)
-) : AbstractScheduler() {
+class RelativeScheduler : AbstractScheduler() {
     override val currentTimeNanos: Long get() = tickNanos
 
-    private val nanosPerTick = durationPerTick.inWholeNanoseconds
-
     private var tickNanos: Long = 0L
 
     override fun processTick() {
         super.processTick()
 
         // increment tick
-        tickNanos += nanosPerTick
+        tickNanos += TickDuration.NANOS_PER_TICK
     }
 }

src/main/kotlin/net/mcbrawls/scheduler/Schedulable.kt

@@ -22,8 +22,8 @@ interface Schedulable : Scheduler {
         return scheduler.schedule(task, delay, repeatDelay)
     }
 
-    override fun schedule(runnable: Runnable, delay: Duration, repeatDelay: Duration?, executionType: ExecutionType): ScheduledTask {
-        return scheduler.schedule(runnable, delay, repeatDelay, executionType)
+    override fun schedule(delay: Duration, repeatDelay: Duration?, executionType: ExecutionType, runnable: Runnable): ScheduledTask {
+        return scheduler.schedule(delay, repeatDelay, executionType, runnable)
     }
 
     override fun cancel(task: ScheduledTask): Boolean {

src/main/kotlin/net/mcbrawls/scheduler/Scheduler.kt

@@ -25,10 +25,6 @@ interface Scheduler {
      * @return the scheduled task
      */
     fun schedule(
-        /**
-         * The function of the task.
-         */
-        runnable: Runnable,
 
         /**
          * The delay until the task is performed.
@@ -43,7 +39,12 @@ interface Scheduler {
         /**
          * How the task should be executed.
          */
-        executionType: ExecutionType = ExecutionType.SYNC
+        executionType: ExecutionType = ExecutionType.SYNC,
+
+        /**
+         * The function of the task.
+         */
+        runnable: Runnable,
     ): ScheduledTask
 
     /**

src/main/kotlin/net/mcbrawls/scheduler/duration/TickDuration.kt

@@ -7,55 +7,16 @@ import kotlin.time.Duration.Companion.nanoseconds
  * Game tick duration utilities.
  */
 object TickDuration {
-    /**
-     * Creates a duration from ticks and ticks per second.
-     * @return a duration
-     */
-    fun create(
-        /**
-         * The amount of ticks within the duration.
-         */
-        ticks: Long,
-
-        /**
-         * The amount of ticks which comprise a second.
-         */
-        ticksPerSecond: Long = 20
-    ): Duration {
-        val nanosPerTick = 1_000_000_000L / ticksPerSecond
-        return (nanosPerTick * ticks).nanoseconds
-    }
+    const val NANOS_PER_TICK = 1_000_000_000L / 20
 
     /**
-     * Calculates the ticks of the given duration.
-     * @return a quantity of ticks
+     * A tick duration for a single tick.
      */
-    fun getTicks(
-        /**
-         * The duration to get timings from.
-         */
-        duration: Duration,
+    val NEXT_TICK = NANOS_PER_TICK.nanoseconds
 
-        /**
-         * The amount of ticks which comprise a second.
-         */
-        ticksPerSecond: Long = 20
-    ): Long {
-        val nanos = duration.inWholeNanoseconds
-        val nanosPerTick = 1_000_000_000L / ticksPerSecond
-        return nanos / nanosPerTick
-    }
+    inline val Int.ticks get() = toLong().ticks
+    inline val Long.ticks get() = (this * NANOS_PER_TICK).nanoseconds
+    inline val Double.ticks get() = toLong().ticks
 
-    /**
-     * Creates a tick duration for a single tick.
-     * @return a duration
-     */
-    fun nextTick(
-        /**
-         * The amount of ticks which comprise a second.
-         */
-        ticksPerSecond: Long = 20
-    ): Duration {
-        return create(1, ticksPerSecond)
-    }
+    inline val Duration.inWholeTicks get() = inWholeNanoseconds / NANOS_PER_TICK
 }

src/test/kotlin/net/mcbrawls/scheduler/test/SchedulerTest.kt

@@ -1,7 +1,8 @@
 package net.mcbrawls.scheduler.test
 
 import net.mcbrawls.scheduler.AbsoluteScheduler
-import net.mcbrawls.scheduler.duration.TickDuration
+import net.mcbrawls.scheduler.duration.TickDuration.inWholeTicks
+import net.mcbrawls.scheduler.duration.TickDuration.ticks
 import kotlin.math.abs
 import kotlin.math.min
 import kotlin.test.Test
@@ -22,13 +23,13 @@ object SchedulerTest {
         var prescheduleTimeMs = milliTime
         println("Scheduling pass")
         scheduler.schedule(
-            {
-                passes++
-                println("Pass #$passes after ${(milliTime - prescheduleTimeMs) / 1000.0}s")
-                prescheduleTimeMs = milliTime
-            },
-            TickDuration.create(60), TickDuration.create(20)
-        )
+            60.ticks,
+            20.ticks,
+        ) {
+            passes++
+            println("Pass #$passes after ${(milliTime - prescheduleTimeMs) / 1000.0}s")
+            prescheduleTimeMs = milliTime
+        }
 
         // wait for schedule and tick
         val timeMs = milliTime
@@ -64,7 +65,7 @@ object SchedulerTest {
     @Test
     fun tickDurationConversion() {
         val expected = 50L
-        val tickDuration = TickDuration.create(expected)
-        assertEquals(TickDuration.getTicks(tickDuration), expected)
+        val tickDuration = expected.ticks
+        assertEquals(tickDuration.inWholeTicks, expected)
     }
 }