feat(plugin26): basic structure

Author: xeruf

.idea

@@ -0,0 +1,11 @@
+val game: String by project
+
+dependencies {
+    api(project(":sdk"))
+}
+
+tasks {
+    jar {
+        archiveBaseName.set(game)
+    }
+}

plugin2026/build.gradle.kts

@@ -0,0 +1,33 @@
+package sc.plugin2026
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import sc.api.plugins.Coordinates
+import sc.api.plugins.IMove
+import sc.api.plugins.Vector
+
+@XStreamAlias("move")
+/** Ein Spielzug. */
+data class Move(
+    /** Ursprungsposition des Zugs. */
+    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
+    
+    override fun toString(): String =
+        "Schwimmen $from zu $to"
+    
+    companion object {
+        @JvmStatic
+        fun run(start: Coordinates, delta: Vector): Move =
+            Move(start, (start + delta))
+    }
+}

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

@@ -0,0 +1,7 @@
+package sc.plugin2026
+
+import sc.shared.IMoveMistake
+
+enum class PiranhaMoveMistake(override val message: String) : IMoveMistake {
+    // TODO
+}

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

@@ -0,0 +1,8 @@
+package sc.plugin2026.util
+
+/** Eine Sammlung an verschiedenen Konstanten, die im Spiel verwendet werden. */
+object PiranhaConstants {
+    const val BOARD_LENGTH: Int = 10
+    
+    const val ROUND_LIMIT: Int = 30
+}

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

@@ -0,0 +1,48 @@
+package sc.plugin2026.util
+
+import com.thoughtworks.xstream.annotations.XStreamAlias
+import sc.api.plugins.IGameInstance
+import sc.api.plugins.IGamePlugin
+import sc.api.plugins.IGameState
+import sc.framework.plugins.TwoPlayerGame
+import sc.plugin2026.GameState
+import sc.plugin2026.Move
+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."),
+}
+
+class GamePlugin: IGamePlugin<Move> {
+    companion object {
+        const val PLUGIN_ID = "swc_2026_piranhas"
+        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),
+                ))
+    }
+    
+    override val id = PLUGIN_ID
+    
+    override val scoreDefinition =
+            Companion.scoreDefinition
+    
+    override val turnLimit: Int =
+        PiranhaConstants.ROUND_LIMIT * 2
+    
+    override val moveClass = Move::class.java
+    
+    override fun createGame(): IGameInstance =
+            TwoPlayerGame(this, GameState())
+    
+    override fun createGameFromState(state: IGameState): IGameInstance =
+            TwoPlayerGame(this, state as GameState)
+    
+}

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

@@ -0,0 +1,12 @@
+package sc.plugin2026.util
+
+import sc.networking.XStreamProvider
+import sc.plugin2026.*
+
+class XStreamClasses: XStreamProvider {
+    
+    override val classesToRegister: List<Class<*>> =
+        listOf(
+        )
+    
+}

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

@@ -0,0 +1 @@
+sc.plugin2026.util.GamePlugin

plugin2026/src/main/resources/META-INF/services/sc.api.plugins.IGamePlugin

@@ -0,0 +1 @@
+sc.plugin2026.util.XStreamClasses

plugin2026/src/main/resources/META-INF/services/sc.networking.XStreamProvider

@@ -0,0 +1,118 @@
+package sc
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.assertions.withClue
+import io.kotest.core.spec.IsolationMode
+import io.kotest.core.spec.style.WordSpec
+import io.kotest.matchers.*
+import io.kotest.matchers.booleans.*
+import io.kotest.matchers.iterator.*
+import io.kotest.matchers.nulls.*
+import org.slf4j.LoggerFactory
+import sc.api.plugins.IGamePlugin
+import sc.api.plugins.IGameState
+import sc.api.plugins.Team
+import sc.api.plugins.TwoPlayerGameState
+import sc.api.plugins.exceptions.TooManyPlayersException
+import sc.api.plugins.host.IGameListener
+import sc.framework.plugins.AbstractGame
+import sc.framework.plugins.Constants
+import sc.shared.GameResult
+import kotlin.time.Duration.Companion.milliseconds
+
+/** This test verifies that the Game implementation can be used to play a game.
+ * It is the only plugin-test independent of the season. */
+class GamePlayTest: WordSpec({
+    val logger = LoggerFactory.getLogger(GamePlayTest::class.java)
+    isolationMode = IsolationMode.SingleInstance
+    val plugin = IGamePlugin.loadPlugin()
+    fun createGame() = plugin.createGame() as AbstractGame<*>
+    "A Game" should {
+        val game = createGame()
+        "let players join" {
+            game.onPlayerJoined()
+            game.onPlayerJoined()
+        }
+        "throw on third player join" {
+            shouldThrow<TooManyPlayersException> {
+                game.onPlayerJoined()
+            }
+        }
+        "set activePlayer on start" {
+            game.start()
+            game.activePlayer shouldNotBe null
+        }
+        "stay paused after move" {
+            game.isPaused = true
+            game.onRoundBasedAction(game.currentState.moveIterator().next())
+            game.isPaused shouldBe true
+        }
+    }
+    "A Game started with two players" When {
+        "played normally" should {
+            val game = createGame()
+            game.onPlayerJoined().team shouldBe Team.ONE
+            game.onPlayerJoined().team shouldBe Team.TWO
+            game.start()
+            
+            var finalState: Int? = null
+            game.addGameListener(object: IGameListener {
+                override fun onGameOver(result: GameResult) {
+                    logger.info("Game over: $result")
+                }
+                
+                override fun onStateChanged(data: IGameState, observersOnly: Boolean) {
+                    val state = data as? TwoPlayerGameState<*>
+                    state?.lastMove.shouldNotBeNull()
+                    data.hashCode() shouldNotBe finalState
+                    // hashing it to avoid cloning, since we get the original object which might be mutable
+                    finalState = data.hashCode()
+                    logger.debug("Updating state hash to $finalState")
+                }
+            })
+            
+            "finish without issues".config(invocationTimeout = plugin.gameTimeout.milliseconds) {
+                while(true) {
+                    try {
+                        val condition = game.checkWinCondition()
+                        if(condition != null) {
+                            logger.info("Game ended with $condition")
+                            break
+                        }
+                        
+                        val state = game.currentState
+                        if(finalState != null)
+                            finalState shouldBe state.hashCode()
+                        
+                        val moves = state.moveIterator()
+                        withClue(state) {
+                            moves.shouldHaveNext()
+                            game.onAction(game.players[state.currentTeam.index], moves.next())
+                        }
+                    } catch(e: Exception) {
+                        logger.warn(e.message)
+                        break
+                    }
+                }
+                withClue(game.currentState) {
+                    // Note that this fails if the game ends irregularly
+                    game.currentState.isOver.shouldBeTrue()
+                }
+            }
+            "send the final state to listeners" {
+                finalState shouldBe game.currentState.hashCode()
+            }
+            "return regular scores" {
+                val result = game.getResult()
+                result.isRegular shouldBe true
+                val scores = result.scores.values
+                scores.first().parts.first().intValueExact() shouldBe when(scores.last().parts.first().intValueExact()) {
+                    Constants.LOSE_SCORE -> Constants.WIN_SCORE
+                    Constants.WIN_SCORE -> Constants.LOSE_SCORE
+                    Constants.DRAW_SCORE -> Constants.DRAW_SCORE
+                    else -> throw NoWhenBranchMatchedException()
+                }
+            }
+        }
+    }
+})