Switch to using a kotlin notebook

.github/workflows/gradle.yml

@@ -25,10 +25,6 @@ jobs:
       uses: "gradle/gradle-build-action@v2"
       with:
         arguments: "compileKotlin"
-    - name: "Run code"
-      uses: "gradle/gradle-build-action@v2"
-      with:
-        arguments: "run"
     - name: "Run tests"
       uses: "gradle/gradle-build-action@v2"
       with:

src/main/java/com/hopskipnfall/Client.kt

@@ -18,7 +18,7 @@ class Client(
   val incomingPackets = mutableListOf<DelayedPacket>()
 
   /** When the current frame started. */
-  private var newFrameTimestamp: Duration = now
+  private var newFrameTimestamp: Duration = 0.milliseconds
 
   private var frameNumber = 0L
 
@@ -32,12 +32,18 @@ class Client(
 
   private var timeReceivedDataNecessaryForNextFrame: Duration? = null
 
-  fun run() {
+  fun run(
+    now: Duration,
+    frameNumberLogger: TimeBasedDataLogger,
+    diagramBuilder: DiagramBuilder,
+    objectiveLagLogger: TimeBasedDataLogger,
+    timeStep: Duration
+  ) {
     // This block ensures that all of the clients are synchronized with respect to the server.
     // Different frame differences require different respective start times.
     val minFrameDelay = min(frameDelay, siblings.minOfOrNull { it.frameDelay } ?: frameDelay)
     val waitForFrames: Double = max((frameDelay - minFrameDelay).toDouble(), 0.0) / 2.0
-    if (now < singleFrameDuration * waitForFrames) {
+    if (now < SINGLE_FRAME_DURATION * waitForFrames) {
       return
     } else if (init) {
       newFrameTimestamp = now
@@ -49,11 +55,11 @@ class Client(
       // This is the first loop!
 
       if (lastFrameDataFrameNumberSent == null && frameNumber >= firstFrameToSendFrom) {
-        sendPacketToServer()
+        sendPacketToServer(now, diagramBuilder)
       }
     }
 
-    if (now >= newFrameTimestamp + singleFrameDuration) {
+    if (now >= newFrameTimestamp + SINGLE_FRAME_DURATION) {
       // We can send inputs to the server and/or move forward in time if we are ready to do so.
 
       // Do we have the necessary data to move forward one frame?
@@ -65,7 +71,7 @@ class Client(
       if (needSiblingsFrameData) {
         val arrivedPackets =
           incomingPackets.findAndRemoveAll {
-            it.hasArrived() && it.frameData.first().frameNumber == frameNumber + 1
+            it.hasArrived(now) && it.frameData.first().frameNumber == frameNumber + 1
           }
 
         if (arrivedPackets.isNotEmpty()) {
@@ -74,14 +80,14 @@ class Client(
           ) // THIS MIGHT NOT ACTUALLY BE IMPOSSIBLE FOR IT TO BE GREATER THAN 1
           frameDataRequirementSatisfied = true
           timeReceivedDataNecessaryForNextFrame = arrivedPackets.single().arrivalTime
-          log("Received packet: ${arrivedPackets.single()}.", debug = true)
+          log("Received packet: ${arrivedPackets.single()}.", debug = true, now)
         }
       } else {
         frameDataRequirementSatisfied = true
       }
 
       if (frameDataRequirementSatisfied) {
-        log("moving to next frame", debug = true)
+        log("moving to next frame", debug = true, now)
         frameNumber++
         if (
           timeReceivedDataNecessaryForNextFrame != null &&
@@ -101,12 +107,12 @@ class Client(
             "Frame Number" to frameNumber,
             "Client" to "Client $id" + if (description == null) "" else " ($description)",
             "Objective lag in a single frame (ms)" to
-              max((now - newFrameTimestamp - singleFrameDuration).toMillisDouble(), 0.0)
+              max((now - newFrameTimestamp - SINGLE_FRAME_DURATION).toMillisDouble(), 0.0)
           )
         }
 
         timeReceivedDataNecessaryForNextFrame = null
-        val lag = now - (newFrameTimestamp) - singleFrameDuration
+        val lag = now - (newFrameTimestamp) - SINGLE_FRAME_DURATION
         if (lag <= timeStep) {
           // No lag.
         } else {
@@ -127,15 +133,14 @@ class Client(
         frameNumber >= firstFrameToSendFrom &&
           (lastFrameNumberSent == null || lastFrameNumberSent < frameNumber + frameDelay)
       ) {
-        sendPacketToServer()
+        sendPacketToServer(now, diagramBuilder)
       }
     }
   }
 
-  val isHealthy: Boolean
-    get() = now - newFrameTimestamp < singleFrameDuration * 10
+  fun isHealthy(now: Duration): Boolean = now - newFrameTimestamp < SINGLE_FRAME_DURATION * 10
 
-  private fun sendPacketToServer() {
+  private fun sendPacketToServer(now: Duration, diagramBuilder: DiagramBuilder) {
     val packet =
       DelayedPacket(
         arrivalTime = now + (pingRange.random() / 2),
@@ -144,11 +149,11 @@ class Client(
     diagramBuilder.registerPacketToServer(now, client = id, packet)
     server.incomingPackets += packet
     lastFrameDataFrameNumberSent = packet.frameData.single().frameNumber
-    log("Sending to server: $packet", debug = true)
+    log("Sending to server: $packet", debug = true, now)
   }
 
-  private fun log(s: String, debug: Boolean = false) {
-    logWithTime("Client $id (frame $frameNumber): $s", debug)
+  private fun log(s: String, debug: Boolean = false, now: Duration) {
+    logWithTime("Client $id (frame $frameNumber): $s", debug, now)
   }
 
   data class ClientPerceivedLag(
@@ -163,7 +168,7 @@ class Client(
 
   /** Data the server tracks about the client. */
   data class ServerData(
-    var lagLeeway: Duration = singleFrameDuration,
+    var lagLeeway: Duration = SINGLE_FRAME_DURATION,
     var totalDrift: Duration = Duration.ZERO,
     var receivedDataAt: Duration = Duration.ZERO,
   )

src/main/java/com/hopskipnfall/DelayedPacket.kt

@@ -0,0 +1,8 @@
+package com.hopskipnfall
+
+import kotlin.time.Duration
+
+/** Simulates a [FrameData] packet in flight. */
+data class DelayedPacket(val arrivalTime: Duration, val frameData: List<FrameData>) {
+  fun hasArrived(now: Duration): Boolean = now >= arrivalTime
+}

src/main/java/com/hopskipnfall/DiagramBuilder.kt

@@ -1,14 +1,10 @@
 package com.hopskipnfall
 
-import com.github.nwillc.ksvg.RenderMode
 import com.github.nwillc.ksvg.elements.SVG
-import java.io.FileWriter
 import kotlin.math.max
 import kotlin.math.roundToInt
 import kotlin.time.Duration
 
-val diagramBuilder = DiagramBuilder()
-
 // These helper functions prepare the number for SVG.
 private fun Int.str() = this.toString()
 
@@ -20,7 +16,7 @@ class DiagramBuilder(private val heightPx: Int = 450, private val framesToDraw:
   private val clientsDoneTracking = mutableSetOf<Int>()
 
   private val leftMargin: Int =
-    ((singleFrameDuration * 1.5).toMillisDouble() * PIXELS_PER_MILLISECOND).roundToInt()
+    ((SINGLE_FRAME_DURATION * 1.5).toMillisDouble() * PIXELS_PER_MILLISECOND).roundToInt()
   private val svgActions = mutableListOf<SVG.() -> Unit>()
 
   private var maxX = 0
@@ -133,7 +129,7 @@ class DiagramBuilder(private val heightPx: Int = 450, private val framesToDraw:
     }
   }
 
-  fun draw() {
+  fun draw(): SVG {
     val svg =
       SVG.svg(true) {
         style {
@@ -202,8 +198,7 @@ class DiagramBuilder(private val heightPx: Int = 450, private val framesToDraw:
 
         for (it in svgActions) it()
       }
-
-    FileWriter("diagram.svg").use { svg.render(it, RenderMode.FILE) }
+    return svg
   }
 
   private companion object {

src/main/java/com/hopskipnfall/FrameData.kt

@@ -0,0 +1,4 @@
+package com.hopskipnfall
+
+/** Frame data that needs to be synchronized between clients in order to move forward. */
+data class FrameData(val frameNumber: Long, val fromClientId: Int)