paws

build.gradle.kts

···
     }
 
     compilerOptions {
-        freeCompilerArgs.addAll("-Xcontext-parameters", "-XXLanguage:+UnnamedLocalVariables")
+        freeCompilerArgs.addAll("-Xcontext-parameters", "-XXLanguage:+UnnamedLocalVariables", "-XXLanguage:+ValueClasses")
     }
 }

flake.nix

···
+{
+  description = "A very basic flake";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+  };
+
+  outputs = { self, nixpkgs }: {
+
+    packages.x86_64-linux.hello = nixpkgs.legacyPackages.x86_64-linux.hello;
+
+    packages.x86_64-linux.default = self.packages.x86_64-linux.hello;
+
+  };
+}

src/nativeMain/kotlin/Main.kt

···
 import uwu.serenity.tuipong.GlobalOptions
 import uwu.serenity.tuipong.START_MARK
 import uwu.serenity.tuipong.games.maze.MazeSetupScreen
+import uwu.serenity.tuipong.games.pong.PongSetupScreen
 import uwu.serenity.tuipong.globalOptions
 import uwu.serenity.tuipong.render.Renderer
 import uwu.serenity.tuipong.terminal.Console
···
 fun main(args: Array<String>) {
     START_MARK
     val options = Properties.decodeFromStringMap<GlobalOptions>(parseArgs(args))
-    val ctx = when (options.threads) {
-        1 -> EmptyCoroutineContext
-        -1 -> Dispatchers.Default
-        else -> newFixedThreadPoolContext(options.threads, "Main")
-    }
     globalOptions = options
     Console().use {
         it.hideCursor()
         Renderer.init(it)
         Renderer.frameLimit = if (options.unlimited) 0 else options.framelimit
         Renderer.setScreen(MazeSetupScreen())
-        runBlocking { mainJob = launch(ctx) { Renderer.run() } }
+        Dispatchers.Default
+        runBlocking { mainJob = launch { Renderer.run() } }
     }
 }
 

src/nativeMain/kotlin/uwu/serenity/tuipong/games/maze/Maze.kt

···
 
     private inner class Torch(override val x: Int, override val y: Int) : Renderable, LightSource {
 
-
         var ticksToLive: Int = 0
 
         override var needsRedraw: Boolean = false

src/nativeMain/kotlin/uwu/serenity/tuipong/games/maze/MazeLoadingScreen.kt

···
 import uwu.serenity.tuipong.render.Renderer
 import uwu.serenity.tuipong.render.Screen
 import kotlin.math.min
+import kotlin.random.Random
 
 class MazeLoadingScreen(private val options: MazeOptions) : Screen {
 
···
         val size = min(Renderer.width, Renderer.height) - 2
         val startPoint = 0
 
-        val seed = parseSeed(options.seed) ?: START_MARK.elapsedNow().inWholeNanoseconds
+        val seed = parseSeed(options.seed) ?: Random.nextLong()
         val gen = MazeGenerator(MazeGenerator.Cell(startPoint, startPoint), size / 2, seed)
 
         val scope = CoroutineScope(BACKGROUND + SupervisorJob())

src/nativeMain/kotlin/uwu/serenity/tuipong/games/pong/Pong.kt

···
 import uwu.serenity.tuipong.terminal.Ansi
 import uwu.serenity.tuipong.terminal.Formatting
 import uwu.serenity.tuipong.terminal.TerminalColor
-import kotlin.math.pow
+import uwu.serenity.tuipong.utils.Vec2
 import kotlin.math.roundToInt
-import kotlin.math.sqrt
 
 class Pong(val options: PongOptions) : Screen {
 
     private val leftPaddle = Paddle(false)
     private val rightPaddle: Paddle? = if (!options.singleplayer) Paddle(true) else null
-    private val ball = Ball(Renderer.width / 2.0, Renderer.height / 2.0)
+    private val ball = Ball(Vec2(Renderer.width / 2.0, Renderer.height / 2.0))
     private val score = Score()
     private var lScore = 0
         set(value) {
···
     override suspend fun tick() {
         val ball = ball
 
-        if (ball.xPos > Renderer.width - 2)
+        if (ball.pos.x > Renderer.width - 2)
             if (!options.singleplayer) {
                 scored(false)
                 lScore++
-            } else ball.xVelocity = -ball.xVelocity
+            } else ball.velocity = ball.velocity.with(x = -ball.velocity.x)
 
-        if (ball.xPos < 1) {
+        if (ball.pos.x < 1) {
             scored(true)
             rScore++
         }
 
-        val li = leftPaddle.instersect(ball.xPos, ball.yPos, ball.xVelocity, ball.yVelocity)
-        val ri = rightPaddle?.instersect(ball.xPos, ball.yPos, ball.xVelocity, ball.yVelocity)
+        val li = leftPaddle.instersect(ball.pos, ball.velocity)
+        val ri = rightPaddle?.instersect(ball.pos, ball.velocity)
             ?: Paddle.NO_INTERSECTION
 
         if (li != Paddle.NO_INTERSECTION || ri != Paddle.NO_INTERSECTION) {
             val n = ri != Paddle.NO_INTERSECTION
             val i = if (n) ri else li
 
-            val xs = if (n) -5.0 else 5.0
-            val ys = i
-            val l =  1.0 / sqrt(xs.pow(2) + ys.pow(2))
-            ball.xVelocity = (xs * l) * (options.speed * 2.0)
-            ball.yVelocity = -((ys * l) * (options.speed * 2.0))
+            ball.velocity = Vec2(if (n) -5.0 else 5.0, -i).normalize() * (options.speed * 2.0)
         }
 
-        if (ball.yPos > Renderer.height - 2 || ball.yPos < 1.0)
-            ball.yVelocity = -ball.yVelocity
+        if (ball.pos.y > Renderer.height - 2 || ball.pos.y < 1.0)
+            ball.velocity = ball.velocity.with(y = -ball.velocity.y)
 
-        val lastXPos = ball.xPos.roundToInt()
-        val lastYPos = ball.yPos.roundToInt()
+        val lastPos = ball.pos.roundToInt()
 
-        ball.xPos += ball.xVelocity
-        ball.yPos += ball.yVelocity
+        ball.pos += ball.velocity
 
-        if (lastXPos != ball.xPos.roundToInt() || lastYPos != ball.yPos.roundToInt())
-            ball.needsRedraw = true
+        if (lastPos != ball.pos.roundToInt()) ball.needsRedraw = true
     }
 
     private fun scored(positiveInitialVelocity: Boolean) {
-        ball.xPos = Renderer.width / 2.0
-        ball.yPos = Renderer.height / 2.0
-        ball.xVelocity = if (positiveInitialVelocity) options.speed else -options.speed
-        ball.yVelocity = -options.speed
+        ball.pos = Vec2(Renderer.width / 2.0, Renderer.height / 2.0)
+        ball.velocity = Vec2(if (positiveInitialVelocity) options.speed else -options.speed, options.speed)
         score.needsRedraw = true
     }
 
···
             needsRedraw = false
         }
 
-        fun instersect(x: Double, y: Double, xVel: Double, yVel: Double): Double {
-            val nextX = x + xVel
-            val nextY = y + yVel
-            val direct = if (right) x in (this.x-1.0..Renderer.width.toDouble()) else x in (0.0..this.x+1.0)
-            val indirect = if (right) nextX in (this.x-1.0..Renderer.width.toDouble()) else nextX in (0.0..this.x+1.0)
+        fun instersect(pos: Vec2, velocity: Vec2): Double {
+            val next = pos + velocity
+            val direct = if (right) pos.x in (this.x-1.0..Renderer.width.toDouble()) else pos.x in (0.0..this.x+1.0)
+            val indirect = if (right) next.x in (this.x-1.0..Renderer.width.toDouble()) else next.x in (0.0..this.x+1.0)
 
-            return if ((y in pos.toDouble()..(pos + 4.0) || (nextY in pos.toDouble()..(pos + 4.0)))
-                && (direct || indirect)) (this.pos + 2.0) - y else NO_INTERSECTION
+            val d = this.pos.toDouble()
+            return if ((pos.y in d..(d + 4.0) || (next.y in d..(d + 4.0))) && (direct || indirect)) (this.pos + 2.0) - pos.y
+                else NO_INTERSECTION
         }
 
         companion object {
···
         }
     }
 
-    private inner class Ball(var xPos: Double, var yPos: Double) : Renderable {
+    private inner class Ball(var pos: Vec2) : Renderable {
 
-        var xVelocity: Double = -options.speed
-        var yVelocity: Double = -options.speed
+        var velocity = Vec2(-options.speed, -options.speed)
 
         override var needsRedraw: Boolean = true
 
         override fun render(context: RenderContext) {
-            val x = xPos.roundToInt(); val y = yPos.roundToInt()
+            val x = pos.x.roundToInt(); val y = pos.y.roundToInt()
             if (x in 0..<context.width && y in 0..<context.height)
                 context.drawChar(x, y, '⬤')
 
···
             context.drawString(0, 0, """
                 ${FrameCounter.fps} FPS
                 options: $options
-                ball: x=${ball.xPos} y=${ball.yPos} xVel=${ball.xVelocity} yVel=${ball.yVelocity}
+                ball: position=${ball.pos} velocity=${ball.velocity}
                 paddleL: pos=${leftPaddle.pos} paddleR: pos=${rightPaddle?.pos}
                 """.trimIndent(), Formatting.Bold, Formatting.Invert)
         }

src/nativeMain/kotlin/uwu/serenity/tuipong/utils/Dimensions.kt

···
 package uwu.serenity.tuipong.utils
 
+import kotlin.math.roundToInt
 import kotlin.math.sqrt
 
-data class Dimensions(val x: Int, val y: Int, val width: Int, val height: Int)
-
-value class Vec2i internal constructor(@PublishedApi internal val packed: Long) {
-
-    constructor(x: Int, y: Int) : this ((x.toLong() shl 32) or (y.toLong() and -1L))
-
-    inline val x: Int get() = (packed and UInt.MAX_VALUE.toLong()).toInt()
+value class Dimensions(val x: Int, val y: Int, val width: Int, val height: Int)
 
-    inline val y: Int get() = ((packed ushr 32) and UInt.MAX_VALUE.toLong()).toInt()
+value class Vec2i(val x: Int, val y: Int) {
 
     operator fun minus(other: Vec2i) = Vec2i(this.x - other.x, this.y - other.y)
 
     operator fun plus(other: Vec2i) = Vec2i(this.x + other.x, this.y - other.y)
 
+    operator fun plus(value: Int) = Vec2i(this.x + value, this.y + value)
+
     operator fun times(other: Vec2i) = Vec2i(this.x * other.x, this.y * other.y)
 
+    operator fun times(value: Int) = Vec2i(this.x * value, this.y * value)
+
     operator fun div(other: Vec2i) = Vec2i(this.x / other.x, this.y / other.y)
 
     operator fun rem(other: Vec2i) = Vec2i(this.x % other.x, this.y % other.y)
···
 
     inline operator fun component2() = y
 }
+
+value class Vec2(val x: Double, val y: Double) {
+
+    constructor(value: Double) : this(value, value)
+
+    operator fun minus(other: Vec2) = Vec2(this.x - other.x, this.y - other.y)
+
+    operator fun minus(value: Double) = Vec2(this.x - value, this.y - value)
+
+    operator fun plus(other: Vec2) = Vec2(this.x + other.x, this.y + other.y)
+
+    operator fun plus(value: Double) = Vec2(this.x + value, this.y + value)
+
+    operator fun times(other: Vec2) = Vec2(this.x * other.x, this.y * other.y)
+
+    operator fun times(value: Double) = Vec2(this.x * value, this.y * value)
+
+    operator fun div(other: Vec2) = Vec2(this.x / other.x, this.y / other.y)
+
+    operator fun rem(other: Vec2) = Vec2(this.x % other.x, this.y % other.y)
+
+    operator fun inc(): Vec2 = Vec2(this.x + 1, this.y + 1)
+
+    operator fun dec(): Vec2 = Vec2(this.x - 1, this.y - 1)
+
+    fun length(): Double = sqrt(x * x + y * y)
+
+    fun normalize(): Vec2 {
+        val l = 1.0 / length()
+        return Vec2(x * l, y * l)
+    }
+
+    fun with(x: Double = this.x, y: Double = this.y) = Vec2(x, y)
+
+    fun roundToInt(): Vec2i = Vec2i(x.roundToInt(), y.roundToInt())
+
+    inline operator fun component1() = x
+
+    inline operator fun component2() = y
+}