feat: implement generic Cartesian directions and refactor hex additions

Author: xeruf

plugin/src/main/kotlin/sc/plugin2023/Board.kt

@@ -2,6 +2,7 @@ package sc.plugin2023
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import sc.api.plugins.*
+import sc.api.plugins.Coordinates
 import kotlin.random.Random
 import sc.plugin2023.util.PenguinConstants as Constants
 
@@ -50,7 +51,7 @@ class Board(override val gameField: MutableTwoDBoard<Field> = generateFields()):
     fun <T> filterFields(filter: (Field, Coordinates) -> T?): Collection<T> =
             gameField.flatMapIndexed { y, row ->
                 row.mapIndexedNotNull { x, field ->
-                    filter(field, Coordinates.doubledHex(x, y))
+                    filter(field, Coordinates(x * 2 + y % 2, y))
                 }
             }
 

plugin/src/main/kotlin/sc/plugin2023/GameState.kt

@@ -3,6 +3,8 @@ package sc.plugin2023
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import com.thoughtworks.xstream.annotations.XStreamAsAttribute
 import sc.api.plugins.*
+import sc.api.plugins.Coordinates
+import sc.api.plugins.HexDirection
 import sc.plugin2023.util.PenguinsMoveMistake
 import sc.plugin2023.util.PenguinConstants
 import sc.shared.InvalidMoveException
@@ -74,10 +76,10 @@ data class GameState @JvmOverloads constructor(
         !penguinsPlaced && board[pos].fish == 1
 
     fun immovable(team: Team? = null) =
-            board.getPenguins()
+        board.getPenguins()
                     .filter { team == null || it.second == team }
                     .takeIf { it.size == PenguinConstants.PENGUINS * (if(team == null) Team.values().size else 1) }
-                    ?.all { pair -> pair.first.hexNeighbors.all { board.getOrEmpty(it).fish == 0 } } ?: false
+                    ?.all { pair -> HexDirection.values().map { pair.first + it }.all { board.getOrEmpty(it).fish == 0 } } ?: false
 
     override val isOver: Boolean
         get() = immovable()

plugin2026/src/main/kotlin/sc/plugin2026/Move.kt

@@ -2,32 +2,19 @@ package sc.plugin2026
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import sc.api.plugins.Coordinates
+import sc.api.plugins.Direction
 import sc.api.plugins.IMove
-import sc.api.plugins.Vector
 
 @XStreamAlias("move")
-/** Ein Spielzug. */
+/** Spielzug: Eine Bewegung eines Fisches. */
 data class Move(
-    /** Ursprungsposition des Zugs. */
+    /** Position des zu bewegenden Fisches. */
     val from: Coordinates,
-    /** Zielposition des Zugs. */
-    val to: Coordinates,
-): IMove, Comparable<Move> {
-    val delta: Vector?
-        get() = from?.let { to - it }
-    
-    fun reversed(): Move? =
-        from?.let { Move(to, from) }
-    
-    override fun compareTo(other: Move): Int =
-        other.delta?.let { delta?.compareTo(it) } ?: 0
+    /** Bewegungsrichtung des Zugs. */
+    val direction: Direction,
+): IMove {
 
     override fun toString(): String =
-        "Schwimmen $from zu $to"
+        "Schwimme von $from in Richtung $direction"
 
-    companion object {
-        @JvmStatic
-        fun run(start: Coordinates, delta: Vector): Move =
-            Move(start, (start + delta))
-    }
 }

sdk/src/main/server-api/sc/api/plugins/Coordinates.kt

@@ -8,8 +8,7 @@ class Positioned<FIELD>(
         override val value: FIELD
 ): Map.Entry<Coordinates, FIELD>
 
-/** Eine (normalerweise kartesische) 2D-Koordinate der Form (x, y).
- * Für Hex-Koordinaten siehe https://www.redblobgames.com/grids/hexagons/#coordinates-doubled */
+/** Eine kartesische 2D-Koordinate der Form (x, y). */
 @XStreamAlias(value = "coordinates")
 data class Coordinates(
         @XStreamAsAttribute val x: Int,
@@ -30,31 +29,12 @@ data class Coordinates(
     /** Wandelt die [Coordinates] in einen entsprechenden [Vector]. */
     operator fun unaryPlus(): Vector = Vector(x, y)
 
-    /** Gibt ein Set der vier benachbarten Felder dieser Koordinaten zurück. */
+    /** Gibt die vier benachbarten Feldkoordinaten zurück. */
     val neighbors: Collection<Coordinates>
-        get() = Vector.cardinals.map { this + it }
-    
-    val hexNeighbors: Collection<Coordinates>
-        get() = HexDirection.values().map { this + it }
-    
-    /** The array indices for a rectangular board of hex fields. */
-    fun fromDoubledHex() = Coordinates(x / 2, y)
-    /** Turn array indices for a rectangular board into double Hex coordinates. */
-    fun toDoubledHex() = doubledHex(x, y)
-    
-    /**
-     * Wandelt DoubledHex-[Coordinates] zu [CubeCoordinates] um.
-     *
-     * @see <a href="https://www.redblobgames.com/grids/hexagons/#conversions-axial">Cube to Axial Coordinate Conversion</a>
-     * @see <a href="https://www.redblobgames.com/grids/hexagons/#conversions-doubled">Axial to Doubled Coordinate Conversion</a>
-     */
-    fun doubledHexToCube(): CubeCoordinates =
-            CubeCoordinates((x - y) / 2, y)
+        get() = Direction.cardinals.map { this + it }
 
     companion object {
         /** Der Ursprung des Koordinatensystems (0, 0). */
         val ORIGIN = Coordinates(0, 0)
-        
-        fun doubledHex(x: Int, y: Int) = Coordinates(x * 2 + y % 2, y)
     }
 }

sdk/src/main/server-api/sc/api/plugins/Direction.kt

@@ -0,0 +1,47 @@
+package sc.api.plugins
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import kotlin.random.Random
+
+@XStreamAlias(value = "direction")
+enum class Direction(val vector: Vector): IVector by vector {
+    UP(Vector(0, 1)),
+    // TODO
+    UP_RIGHT
+    RIGHT
+    DOWN_RIGHT
+    DOWN
+    DOWN_LEFT
+    LEFT
+    UP_LEFT
+    
+    companion object {
+        // TODO
+        val diagonals = arrayOf(Vector(-1, -1), Vector(-1, 1), Vector(1, -1), Vector(1, 1))
+        val cardinals = arrayOf(UP, RIGHT, DOWN, LEFT)
+    }
+}
+
+enum class HexDirection(val vector: Vector): IVector by vector {
+    RIGHT(Vector(+2, 0)),
+    DOWN_RIGHT(Vector(+1, +1)),
+    DOWN_LEFT(Vector(-1, +1)),
+    LEFT(Vector(-2, 0)),
+    UP_LEFT(Vector(-1, -1)),
+    UP_RIGHT(Vector(+1, -1));
+    
+    fun withNeighbors(): Array<HexDirection> = arrayOf(rotatedBy(-1), this, rotatedBy(1))
+    
+    fun opposite(): HexDirection = values().let { it[(ordinal + 3) % it.size] }
+    
+    fun turnCountTo(target: HexDirection): Int {
+        val diff = target.ordinal - this.ordinal
+        return if(diff >= 0) diff else diff + values().size
+    }
+    
+    fun rotatedBy(turns: Int): HexDirection = values().let { it[(ordinal + turns).mod(it.size)] }
+    
+    companion object {
+        fun random(): HexDirection = values()[Random.nextInt(values().size)]
+    }
+}

sdk/src/main/server-api/sc/api/plugins/Vector.kt

@@ -43,32 +43,4 @@ data class Vector(override val dx: Int, override val dy: Int): IVector, Comparab
     /** Konvertiert den Vektor zu entsprechenden [Coordinates]. */
     operator fun unaryPlus(): Coordinates = Coordinates(dx, dy)
 
-    companion object {
-        val diagonals = arrayOf(Vector(-1, -1), Vector(-1, 1), Vector(1, -1), Vector(1, 1))
-        val cardinals = arrayOf(Vector(-1, 0), Vector(0, -1), Vector(1, 0), Vector(0, 1))
-    }
-}
-
-enum class HexDirection(val vector: Vector): IVector by vector {
-    RIGHT(Vector(+2, 0)),
-    DOWN_RIGHT(Vector(+1, +1)),
-    DOWN_LEFT(Vector(-1, +1)),
-    LEFT(Vector(-2, 0)),
-    UP_LEFT(Vector(-1, -1)),
-    UP_RIGHT(Vector(+1, -1));
-    
-    fun withNeighbors(): Array<HexDirection> = arrayOf(rotatedBy(-1), this, rotatedBy(1))
-    
-    fun opposite(): HexDirection = values().let { it[(ordinal + 3) % it.size] }
-    
-    fun turnCountTo(target: HexDirection): Int {
-        val diff = target.ordinal - this.ordinal
-        return if(diff >= 0) diff else diff + values().size
-    }
-    
-    fun rotatedBy(turns: Int): HexDirection = values().let { it[(ordinal + turns).mod(it.size)] }
-    
-    companion object {
-        fun random(): HexDirection = values()[Random.nextInt(values().size)]
-    }
 }