feat(plugin): add getPossibleMoves function (#276)

IMPORTANT:
* The tests are incomplete yet. Technically, if the move validation tests are foul proof, then everything works already but, ideally, we should write more, proper tests
* This implementation requires quite a bit of overhead on initialisation but allows quicker calculation of possible moves thereafter

Author: anarchuser

plugin/src/shared/sc/plugin2021/Board.kt

@@ -3,7 +3,6 @@ package sc.plugin2021
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import sc.api.plugins.IBoard
 import sc.plugin2021.util.Constants
-import sc.plugin2021.Field
 
 @XStreamAlias(value = "board")
 class Board(
@@ -51,3 +50,27 @@ class Board(
         }
     }
 }
+
+/** The four corners on the Board, used to calculate the position of a piece in a corner. */
+enum class Corner(val position: Coordinates) {
+    UPPER_LEFT(Coordinates(0, 0)) {
+        override fun align(area: Vector): Coordinates = position
+    },
+    UPPER_RIGHT(Coordinates(Constants.BOARD_SIZE - 1, 0)) {
+        override fun align(area: Vector): Coordinates = Coordinates(position.x - area.dx, position.y)
+    },
+    LOWER_RIGHT(Coordinates(Constants.BOARD_SIZE - 1, Constants.BOARD_SIZE - 1)) {
+        override fun align(area: Vector): Coordinates = position - area
+    },
+    LOWER_LEFT(Coordinates(0, Constants.BOARD_SIZE - 1)) {
+        override fun align(area: Vector): Coordinates = Coordinates(position.x, position.y - area.dy)
+    };
+    
+    /** Returns the position a piece of given area has to be placed at to lie in the respective corner. */
+    abstract fun align(area: Vector): Coordinates
+    
+    companion object {
+        /** Returns a set of the positions of all corners. */
+        fun asSet(): Set<Coordinates> = values().map { it.position }.toSet()
+    }
+}

plugin/src/shared/sc/plugin2021/Coordinates.kt

@@ -2,6 +2,7 @@ package sc.plugin2021
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import com.thoughtworks.xstream.annotations.XStreamAsAttribute
+import kotlin.math.min
 
 @XStreamAlias(value = "coordinates")
 data class Coordinates(
@@ -34,5 +35,9 @@ data class Vector(
     operator fun times(scalar: Int): Vector {
         return Vector(scalar * dx, scalar * dy)
     }
+    
+    operator fun compareTo(other: Vector): Int =
+            min(other.dx - dx, other.dy - dy)
+    
     operator fun unaryPlus(): Coordinates = Coordinates(dx, dy)
 }

plugin/src/shared/sc/plugin2021/Piece.kt

@@ -2,11 +2,6 @@ package sc.plugin2021
 
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import com.thoughtworks.xstream.annotations.XStreamAsAttribute
-import com.thoughtworks.xstream.annotations.XStreamOmitField
-import sc.plugin2021.util.align
-import sc.plugin2021.util.flip
-import sc.plugin2021.util.print
-import sc.plugin2021.util.rotate
 
 /** A Piece has a color, a position and a normalised shape. */
 @XStreamAlias(value = "piece")
@@ -23,6 +18,15 @@ class Piece(@XStreamAsAttribute val color: Color = Color.BLUE,
                 position: Coordinates = Coordinates.origin):
             this(color, PieceShape.shapes.getValue(kind), rotation, isFlipped, position)
 
+    constructor(color: Color = Color.BLUE,
+                kind: PieceShape = PieceShape.MONO,
+                shape: Set<Coordinates>,
+                position: Coordinates = Coordinates.origin):
+            this(color, kind, kind.variants.getValue(shape), position)
+    
+    private constructor(color: Color, kind: PieceShape, transformation: Pair<Rotation, Boolean>, position: Coordinates):
+            this(color, kind, transformation.first, transformation.second, position)
+    
     val shape: Set<Coordinates>
         get() = lazyShape()
 

plugin/src/shared/sc/plugin2021/PieceShape.kt

@@ -3,10 +3,7 @@ package sc.plugin2021
 import com.thoughtworks.xstream.annotations.XStreamAlias
 import com.thoughtworks.xstream.annotations.XStreamAsAttribute
 import com.thoughtworks.xstream.annotations.XStreamOmitField
-import sc.plugin2021.util.Constants
-import sc.plugin2021.util.align
-import sc.plugin2021.util.rotate
-import sc.plugin2021.util.flip
+import sc.plugin2021.util.*
 import kotlin.math.max
 
 @XStreamAlias(value = "shape")
@@ -36,25 +33,44 @@ enum class PieceShape(coordinates: Set<Coordinates>) {
 
     @XStreamAsAttribute
     val coordinates: Set<Coordinates> = coordinates.align()
+    
     @XStreamAsAttribute
-    val dimension: Vector
+    val dimension: Vector = coordinates.area()
 
     val asVectors: Set<Vector> by lazy {coordinates.map {it - Coordinates.origin}.toSet()}
+    
     @XStreamOmitField
     val size: Int = coordinates.size
 
+    /** All different variants. Boiler plate for faster calculation of possible moves. */
+    val variants: Map<Set<Coordinates>, Pair<Rotation, Boolean>>
+    
+    val transformations: Map<Pair<Rotation, Boolean>, Set<Coordinates>>
+    
     init {
-        var dx = 0
-        var dy = 0
-        coordinates.forEach {
-            dx = max(it.x, dx)
-            dy = max(it.y, dy)
+        val mapVariants = mutableMapOf<Set<Coordinates>, Pair<Rotation, Boolean>>()
+        val mapTransformations = mutableMapOf<Pair<Rotation, Boolean>, Set<Coordinates>>()
+        for (rotation in Rotation.values()) {
+            for (flip in listOf(false, true)) {
+                val shape = coordinates.rotate(rotation).flip(flip)
+                if (mapVariants[shape] == null) mapVariants += shape to Pair(rotation, flip)
+                mapTransformations += Pair(rotation, flip) to shape
+            }
         }
-        dimension = Vector(dx, dy)
+        variants = mapVariants
+        transformations = mapTransformations
     }
 
-    /** Applies all the given transformations. */
+    /** Does the same thing as transform, providing the index operator. */
+    operator fun get(rotation: Rotation, shouldFlip: Boolean): Set<Coordinates> =
+            transform(rotation, shouldFlip)
+    
+    /** Returns a shape with all transformations applied. */
     fun transform(rotation: Rotation, shouldFlip: Boolean): Set<Coordinates> =
+            transformations[rotation to shouldFlip] ?: emptySet()
+    
+    /** Applies all the given transformations manually instead of looking them up. */
+    fun legacyTransform(rotation: Rotation, shouldFlip: Boolean): Set<Coordinates> =
             coordinates.rotate(rotation).flip(shouldFlip)
 
     companion object {

plugin/src/shared/sc/plugin2021/util/GameRuleLogic.kt

@@ -3,7 +3,6 @@ package sc.plugin2021.util
 import org.slf4j.LoggerFactory
 import sc.plugin2021.*
 import sc.shared.InvalidMoveException
-import kotlin.properties.Delegates
 
 object GameRuleLogic {
     val logger = LoggerFactory.getLogger(GameRuleLogic::class.java)
@@ -126,11 +125,8 @@ object GameRuleLogic {
     }
 
     @JvmStatic
-    fun isOnCorner(position: Coordinates): Boolean = listOf(
-            Coordinates(0, 0),
-            Coordinates(Constants.BOARD_SIZE - 1, 0),
-            Coordinates(Constants.BOARD_SIZE - 1, Constants.BOARD_SIZE - 1),
-            Coordinates(0, Constants.BOARD_SIZE - 1)).contains(position)
+    fun isOnCorner(position: Coordinates): Boolean =
+            Corner.asSet().contains(position)
 
     /** Returns a random pentomino which is not the `x` one (Used to get a valid starting piece). */
     @JvmStatic
@@ -142,17 +138,57 @@ object GameRuleLogic {
     /** Returns a list of all possible SetMoves. */
     @JvmStatic
     fun getPossibleMoves(gameState: GameState): Set<SetMove> {
-        if (gameState.round == 1) return getPossibleStartMoves(gameState)
+        // TODO: Use appropriate move calculation here
+        if (gameState.deployedPieces.getValue(gameState.currentColor).isEmpty()) return getPossibleStartMoves(gameState)
         val color = gameState.currentColor
-        
-        return emptySet()
+
+        val moves = mutableSetOf<SetMove>()
+        gameState.undeployedPieceShapes.getValue(color).map {
+            val area = it.coordinates.area()
+            for (y in 0 until Constants.BOARD_SIZE - area.dy)
+                for (x in 0 until Constants.BOARD_SIZE - area.dx)
+                    for (variant in it.variants)
+                        moves += SetMove(Piece(color, it, variant.key, Coordinates(x, y)))
+        }
+        return moves
     }
 
     /** Returns a list of possible SetMoves if it's the first round. */
     @JvmStatic
     fun getPossibleStartMoves(gameState: GameState): Set<SetMove> {
         val color = gameState.currentColor
-        
-        return emptySet()
+        val kind = gameState.startPiece
+        val moves  = mutableSetOf<SetMove>()
+        for (variant in kind.variants) {
+            for (corner in Corner.values()) {
+                moves.add(SetMove(Piece(color, kind, variant.key, corner.align(variant.key.area()))))
+            }
+        }
+        return moves.filterValidMoves(gameState)
+    }
+    
+    /**
+     * Returns a list of all moves, impossible or not.
+     *  There's no real usage, except maybe for cases where no Move validation happens
+     *  if `Constants.VALIDATE_MOVE` is false, then this function should return the same
+     *  Set as `::getPossibleMoves`
+     */
+    @JvmStatic
+    fun getAllMoves(gameState: GameState): Set<SetMove> {
+        val moves = mutableSetOf<SetMove>()
+        for (color in Color.values()) {
+            for (shape in PieceShape.values()) {
+                for (rotation in Rotation.values()) {
+                    for (flip in listOf(false, true)) {
+                        for (y in 0 until Constants.BOARD_SIZE) {
+                            for (x in 0 until Constants.BOARD_SIZE) {
+                                moves.add(SetMove(Piece(color, shape, rotation, flip, Coordinates(x, y))))
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return moves
     }
 }

plugin/src/shared/sc/plugin2021/util/SetHelpers.kt

@@ -1,6 +1,8 @@
 package sc.plugin2021.util
 
 import sc.plugin2021.*
+import sc.shared.InvalidMoveException
+import java.lang.IndexOutOfBoundsException
 
 /**
  * A Collection of methods callable on specific Sets or functions that take Sets as input.
@@ -54,13 +56,27 @@ fun Set<Coordinates>.align(): Set<Coordinates> {
     }.toSet()
 }
 
+/** Returns the rectangular area the Set of Coordinates lies in. */
+fun Set<Coordinates>.area(): Vector {
+    var dx = 0
+    var dy = 0
+    forEach {
+        dx = kotlin.math.max(it.x, dx)
+        dy = kotlin.math.max(it.y, dy)
+    }
+    return Vector(dx, dy)
+}
+
 /** Prints an ascii art of the piece. */
-fun Set<Coordinates>.print(dimension: Vector = Vector(4, 5)) {
+fun Set<Coordinates>.print(dimension: Vector = area()) {
     printShapes(this, dimension = dimension)
 }
 
 /** Prints all given shapes next to each other. */
 fun printShapes(vararg shapes: Set<Coordinates>, dimension: Vector = Vector(4, 5)) {
+    if (shapes.any{it.area() < dimension})
+        throw IndexOutOfBoundsException("The largest shape has to fit in the given dimension")
+        
     val width = shapes.size * (dimension.dx + 1)
     val array = Array(dimension.dy * width) {FieldContent.EMPTY.letter}
     for (n in array.indices) {
@@ -77,3 +93,15 @@ fun printShapes(vararg shapes: Set<Coordinates>, dimension: Vector = Vector(4, 5
     }
     println()
 }
+
+/** Filters all moves, returning only those who pass the validation functions. */
+fun Set<SetMove>.filterValidMoves(gameState: GameState): Set<SetMove> =
+        filter {
+            try {
+                GameRuleLogic.validateMoveColor(gameState, it)
+                GameRuleLogic.validateSetMove(gameState, it)
+                true
+            } catch(e: InvalidMoveException) {
+                false
+            }
+        }.toSet()