feat(plugin26): add Board, add Fields

Author: TomekRD

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

@@ -0,0 +1,86 @@
+package sc.plugin2026
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import com.thoughtworks.xstream.annotations.XStreamImplicit
+import sc.api.plugins.IBoard
+import sc.plugin2026.FieldState.OBSTRUCTED
+import sc.plugin2026.util.*
+import java.util.*
+
+/** Spielbrett für Piranhas mit [PiranhaConstants.BOARD_LENGTH]² Feldern.  */
+@XStreamAlias(value = "board")
+class Board : IBoard {
+    
+    @XStreamImplicit(itemFieldName = "fields")
+    private var fields: Array<Array<Field>>
+    
+    constructor() {
+        this.fields = randomFields()
+    }
+    
+    
+    constructor(boardToClone: Board) {
+        this.fields = generateFields { x, y -> boardToClone.fields[x][y].clone() }
+    }
+    
+    public override fun clone(): Board = Board(this)
+    
+    override fun equals(other: Any?): Boolean = other is Board && Arrays.equals(other.fields, this.fields)
+    
+    private fun generateFields(generator: (Int, Int) -> Field): Array<Array<Field>> {
+        return Array(PiranhaConstants.BOARD_LENGTH) { x ->
+            Array(PiranhaConstants.BOARD_LENGTH) { y ->
+                generator(x, y)
+            }
+        }
+    }
+    
+    /** Erstellt eine zufälliges Spielbrett.  */
+    private fun randomFields(): Array<Array<Field>> {
+        val fields = generateFields { x, y -> Field(x, y) }
+        
+        // Place Piranhas
+        for(index in 1 until PiranhaConstants.BOARD_LENGTH - 1) {
+            fields[0][index].setPiranha(Team.ONE)
+            fields[PiranhaConstants.BOARD_LENGTH - 1][index].setPiranha(Team.ONE)
+            fields[index][0].setPiranha(Team.TWO)
+            fields[index][PiranhaConstants.BOARD_LENGTH - 1].setPiranha(Team.TWO)
+        }
+        
+        // Place Obstacles
+        // only consider fields in the middle of the board
+        var blockableFields: List<Field> = fields.slice(PiranhaConstants.OBSTACLES_START..PiranhaConstants.OBSTACLES_END).flatMap { it.slice(PiranhaConstants.OBSTACLES_START..PiranhaConstants.OBSTACLES_END) }
+        // set fields with randomly selected coordinates to blocked
+        // coordinates may not lay on same horizontal, vertical or diagonal lines with other selected coordinates
+        for(i in 0 until PiranhaConstants.NUM_OBSTACLES) {
+            val indexOfFieldToBlock = Math.floor(Math.random() * blockableFields.size).toInt()
+            val selectedField = blockableFields[indexOfFieldToBlock]
+            selectedField.state = OBSTRUCTED
+            blockableFields = blockableFields.filter { field ->
+                !(field.x == selectedField.x || field.y == selectedField.y ||
+                  field.x - field.y == selectedField.x - selectedField.y ||
+                  field.x + field.y == selectedField.x + selectedField.y)
+            }
+        }
+        return fields
+    }
+    
+    override fun toString() =
+        "Board " + fields.joinToString(" ", "[", "]") { column -> column.joinToString(", ", prefix = "[", postfix = "]") { it.toString() } }
+    
+    val line = "-".repeat(PiranhaConstants.BOARD_LENGTH + 2)
+    fun prettyString(): String {
+        val map = Array(PiranhaConstants.BOARD_LENGTH) { StringBuilder("|") }
+        fields.forEach {
+            it.forEachIndexed { index, field ->
+                map[index].append(field.state.asLetter())
+            }
+        }
+        return map.joinToString("\n", line + "\n", "\n" + line) { it.append('|').toString() }
+    }
+    
+    fun getField(x: Int, y: Int): Field =
+        this.fields[x][y]
+    
+}
+

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

@@ -0,0 +1,61 @@
+package sc.plugin2026
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import com.thoughtworks.xstream.annotations.XStreamAsAttribute
+import sc.api.plugins.IField
+import sc.plugin2026.FieldState.Companion.from
+import java.util.Optional
+
+/**
+ * Ein Feld des Spielfelds. Ein Spielfeld hat eine x- und y-Koordinate und einen [FieldState], der anzeigt ob sich etwas auf diesem Feld befindet.
+ */
+@XStreamAlias(value = "field")
+class Field @JvmOverloads constructor(
+    @field:XStreamAsAttribute var x: Int,
+    @field:XStreamAsAttribute var y: Int,
+    @field:XStreamAsAttribute var state: FieldState = FieldState.EMPTY
+):
+    IField<Field> {
+    constructor(x: Int, y: Int, piranha: PlayerColor): this(x, y, from(piranha))
+    
+    constructor(x: Int, y: Int, isObstructed: Boolean): this(
+        x,
+        y,
+        if(isObstructed) FieldState.OBSTRUCTED else FieldState.EMPTY
+    )
+    
+    constructor(fieldToClone: Field): this(fieldToClone.x, fieldToClone.y, fieldToClone.state)
+    
+    override fun clone(): Field {
+        return Field(this)
+    }
+    
+    override fun equals(obj: Any?): Boolean {
+        if(obj !is Field) return false
+        val field = obj
+        return x == field.x && y == field.y && state == field.state
+    }
+    
+    override fun toString(): String {
+        return String.format("Field(%d|%d){%s}", x, y, state)
+    }
+    
+    val piranha: Optional<PlayerColor>
+        get() {
+            if(state == FieldState.RED) return Optional.of(Team.ONE)
+            else if(state == FieldState.BLUE) return Optional.of(Team.TWO)
+            
+            return Optional.empty()
+        }
+    
+    /** Nur für den Server relevant.  */
+    fun setPiranha(piranha: PlayerColor) {
+        state = from(piranha)
+    }
+    
+    val isObstructed: Boolean
+        get() = state == FieldState.OBSTRUCTED
+    
+    override val isEmpty: Boolean
+        get() = false
+}

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

@@ -0,0 +1,32 @@
+package sc.plugin2026
+
+enum class FieldState {
+    RED,
+    BLUE,
+    OBSTRUCTED,
+    EMPTY;
+    
+    override fun toString() = when(this) {
+        OBSTRUCTED -> "Obstructed"
+        RED -> "Red"
+        BLUE -> "Blue"
+        else -> "empty"
+    }
+    
+    fun asLetter() = when(this) {
+        OBSTRUCTED -> 'O'
+        RED -> 'R'
+        BLUE -> 'B'
+        else -> ' '
+    }
+    
+    companion object {
+        @JvmStatic
+        fun from(color: PlayerColor): FieldState {
+            return when(color) {
+                Team.ONE -> RED
+                Team.TWO -> BLUE
+            }
+        }
+    }
+}

plugin2026/src/main/kotlin/sc/plugin2026/util/Constants.kt

@@ -4,5 +4,9 @@ package sc.plugin2026.util
 object PiranhaConstants {
     const val BOARD_LENGTH: Int = 10
 
+    const val OBSTACLES_START: Int = 2
+    const val OBSTACLES_END: Int = 7
+    const val NUM_OBSTACLES: Int = 2
+    
     const val ROUND_LIMIT: Int = 30
 }

plugin2026/src/main/kotlin/sc/plugin2026/util/GamePlugin.kt

@@ -12,10 +12,9 @@ import sc.shared.*
 // TODO
 
 @XStreamAlias(value = "winreason")
-enum class HuIWinReason(override val message: String, override val isRegular: Boolean = true): IWinReason {
-    DIFFERING_SCORES("%s ist weiter vorne."),
-    DIFFERING_CARROTS("%s hat weniger Karotten uebrig."),
-    GOAL("%s hat das Ziel zuerst erreicht."),
+enum class PiranhasWinReason(override val message: String, override val isRegular: Boolean = true): IWinReason {
+    BIGGER_SWARM("%s hat den größeren Schwarm")
+    
 }
 
 class GamePlugin: IGamePlugin<Move> {
@@ -24,8 +23,7 @@ class GamePlugin: IGamePlugin<Move> {
         val scoreDefinition: ScoreDefinition =
                 ScoreDefinition(arrayOf(
                         ScoreFragment("Siegpunkte", WinReason("%s hat gewonnen."), ScoreAggregation.SUM),
-                        ScoreFragment("Feldnummer", HuIWinReason.DIFFERING_SCORES, ScoreAggregation.AVERAGE),
-                        ScoreFragment("Karotten", HuIWinReason.DIFFERING_CARROTS, ScoreAggregation.AVERAGE, true),
+                        ScoreFragment("Schwarmgroeße", PiranhasWinReason.BIGGER_SWARM, ScoreAggregation.AVERAGE),
                 ))
     }