Make Vector2 a value class

Signed-off-by: Kyle Corry <[email protected]>

Author: kylecorry31

.gitignore

@@ -81,4 +81,5 @@ temp/
 
 # Custom
 .idea/markdown.xml
-.idea/AndroidProjectSystem.xml
+.idea/AndroidProjectSystem.xml
+/.vscode/tasks.json

src/main/kotlin/com/kylecorry/sol/math/Vector2.kt

@@ -7,7 +7,16 @@ import com.kylecorry.sol.math.SolMath.toDegrees
 import kotlin.math.atan2
 import kotlin.math.sqrt
 
-data class Vector2(val x: Float, val y: Float) {
+@JvmInline
+value class Vector2 internal constructor(internal val packed: Long) {
+
+    constructor(x: Float, y: Float) : this(packXY(x, y))
+
+    val x: Float
+        get() = Float.fromBits(((packed ushr 32) and 0xFFFFFFFFL).toInt())
+
+    val y: Float
+        get() = Float.fromBits((packed and 0xFFFFFFFFL).toInt())
 
     operator fun minus(other: Vector2): Vector2 {
         return Vector2(x - other.x, y - other.y)
@@ -66,8 +75,25 @@ data class Vector2(val x: Float, val y: Float) {
         )
     }
 
+    fun copy(x: Float = this.x, y: Float = this.y): Vector2 {
+        return Vector2(x, y)
+    }
+
+    override fun toString(): String {
+        return "Vector2(x=$x, y=$y)"
+    }
+
     companion object {
-        val zero = Vector2(0f, 0f)
+        val zero = from(0f, 0f)
+
+        fun from(x: Float, y: Float): Vector2 {
+            return Vector2(packXY(x, y))
+        }
     }
+}
 
-}
+private fun packXY(x: Float, y: Float): Long {
+    val xb = x.toBits()
+    val yb = y.toBits()
+    return ((xb.toLong() and 0xFFFFFFFFL) shl 32) or (yb.toLong() and 0xFFFFFFFFL)
+}

src/test/kotlin/com/kylecorry/sol/math/Vector2LongConverter.kt

@@ -0,0 +1,44 @@
+package com.kylecorry.sol.math
+
+import org.junit.jupiter.params.converter.ArgumentConversionException
+import org.junit.jupiter.params.converter.SimpleArgumentConverter
+
+/**
+ * Converts between Vector2 and Long (packed) for parameterized tests.
+ * - If target type is Vector2, accepts Long (packed) and constructs Vector2.
+ * - If target type is Long, accepts Vector2 and returns its packed value.
+ */
+class Vector2LongConverter : SimpleArgumentConverter() {
+    override fun convert(source: Any?, targetType: Class<*>): Any {
+        if (source == null) {
+            throw ArgumentConversionException("Source is null")
+        }
+
+        return when (targetType) {
+            List::class.java -> {
+                if (source is java.util.List<*>) {
+                    source.map { item ->
+                        when (item) {
+                            is Long -> Vector2(item)
+                            is Number -> Vector2(item.toLong())
+                            is Vector2 -> item
+                            else -> throw ArgumentConversionException("Cannot convert list element ${item?.let { it::class.java }} to Vector2")
+                        }
+                    }
+                } else {
+                    throw ArgumentConversionException("Cannot convert ${source::class.java} to List<Vector2>. Expected List<Long|Number|Vector2>.")
+                }
+            }
+
+            Long::class.java -> {
+                if (source is Vector2) {
+                    source.packed
+                } else {
+                    throw ArgumentConversionException("Cannot convert ${source::class.java} to Long. Expected Vector2 -> Long.")
+                }
+            }
+
+            else -> throw ArgumentConversionException("Unsupported target type: ${targetType.name}")
+        }
+    }
+}

src/test/kotlin/com/kylecorry/sol/math/Vector2Test.kt

@@ -1,8 +1,8 @@
 package com.kylecorry.sol.math
 
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.converter.ConvertWith
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.CsvSource
 import org.junit.jupiter.params.provider.MethodSource
@@ -12,7 +12,12 @@ internal class Vector2Test {
 
     @ParameterizedTest
     @MethodSource("provideRotation")
-    fun rotate(vector: Vector2, angle: Float, origin: Vector2, expected: Vector2) {
+    fun rotate(
+        @ConvertWith(Vector2LongConverter::class) vector: Vector2,
+        angle: Float,
+        @ConvertWith(Vector2LongConverter::class) origin: Vector2,
+        @ConvertWith(Vector2LongConverter::class) expected: Vector2
+    ) {
         val rotated = vector.rotate(angle, origin)
 
         assertEquals(expected.x, rotated.x, 0.0001f)

src/test/kotlin/com/kylecorry/sol/math/geometry/IntersectionMathTest.kt

@@ -1,8 +1,10 @@
 package com.kylecorry.sol.math.geometry
 
 import com.kylecorry.sol.math.Vector2
+import com.kylecorry.sol.math.Vector2LongConverter
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.converter.ConvertWith
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 import java.util.stream.Stream
@@ -22,10 +24,10 @@ internal class IntersectionMathTest {
     @ParameterizedTest
     @MethodSource("providePointsRectIntersection")
     fun getIntersectionPointsRect(
-        a: Vector2,
-        b: Vector2,
+        @ConvertWith(Vector2LongConverter::class) a: Vector2,
+        @ConvertWith(Vector2LongConverter::class) b: Vector2,
         rect: Rectangle,
-        expected: List<Vector2>
+        @ConvertWith(Vector2LongConverter::class) expected: List<Vector2>
     ) {
         val intersection = IntersectionMath.getIntersection(a, b, rect)
         assertEquals(expected.size, intersection.size)