feat(player): add simple client and logic implementation

Author: anarchuser

player/build.gradle.kts

@@ -21,6 +21,7 @@ application {
 
 dependencies {
     implementation(project(":plugin"))
+    implementation(kotlin("script-runtime"))
 }
 
 tasks {

player/src/sc/player2021/SimpleClient.kt

@@ -0,0 +1,23 @@
+package sc.player2021
+
+import org.slf4j.LoggerFactory
+import sc.player2021.logic.Logic
+import sc.plugin2021.AbstractClient
+
+class SimpleClient(host: String, port: Int, reservation: String): AbstractClient(host, port) {
+    companion object {
+        val logger = LoggerFactory.getLogger(SimpleClient::class.java)
+    }
+    
+    val logic = Logic(this)
+    
+    init {
+        handler = logic
+        
+        if (reservation.isEmpty())
+            joinAnyGame()
+        else
+            joinPreparedGame(reservation)
+    }
+    
+}

player/src/sc/player2021/Starter.kt

@@ -0,0 +1,50 @@
+package sc.player2021
+
+import jargs.gnu.CmdLineParser
+import java.io.File
+import kotlin.system.exitProcess
+
+fun main(args: Array<String>) {
+    val parser = CmdLineParser()
+    val options = mapOf(
+            "host" to parser.addStringOption('h', "host"),
+            "port" to parser.addIntegerOption('p', "port"),
+            "reservation" to parser.addStringOption('r', "reservation")
+    )
+    
+    // Parse command line arguments
+    try {
+        parser.parse(args)
+    } catch (e: CmdLineParser.OptionException) {
+        showHelp(e.message.orEmpty())
+        exitProcess(2)
+    }
+    
+    // Load parameters
+    val host = parser.getOptionValue(options["host"],"localhost") as String
+    val port = parser.getOptionValue(options["port"], "") as Int
+    val reservation = parser.getOptionValue(options["reservation"], "") as String
+    
+    // Construct a new client
+    try {
+        SimpleClient(host, port, reservation)
+    } catch (e: Exception) {
+        SimpleClient.logger.error("Beim starten des Clients ist ein Fehler aufgetreten", e)
+        e.printStackTrace()
+    }
+}
+
+private fun showHelp(errorMsg: String) {
+    val jarName = File(SimpleClient::class.java.protectionDomain.codeSource.location.file).name
+    println("\n$errorMsg")
+    println("""
+        Bitte das Programm mit folgenden Parametern (optional) aufrufen:
+        java -jar $jarName [{-h, --host} hostname]
+                       [{-p, --port} port]
+                       [{-r, --reservation} reservation]
+
+        Beispiel:
+        java -jar $jarName --host 127.0.0.1 --port 10500 --reservation 1234
+    """.trimIndent())
+}
+

player/src/sc/player2021/logic/Logic.kt

@@ -0,0 +1,53 @@
+package sc.player2021.logic
+
+import org.slf4j.LoggerFactory
+import sc.framework.plugins.Player
+import sc.player2021.SimpleClient
+import sc.plugin2021.*
+import sc.plugin2021.util.GameRuleLogic
+import sc.shared.GameResult
+
+/**
+ * Das Herz des Clients:
+ * Eine sehr simple Logik, die ihre Züge zufällig wählt,
+ * aber gülltige Züge macht.
+ * Außerdem werden alle aktionen geloggt und in der Konsole ausgegeben.
+ */
+class Logic(private val client: SimpleClient): IGameHandler{
+    companion object {
+        val logger = LoggerFactory.getLogger(Logic::class.java)
+    }
+    
+    private lateinit var gameState: GameState
+    private lateinit var currentPlayer: Player
+    
+    override fun onUpdate(player: Player, otherPlayer: Player) {
+        currentPlayer = player
+        logger.info("Spielerwechsel - neuer Spieler: ${player.color}")
+    }
+    
+    override fun onUpdate(gamestate: GameState) {
+        this.gameState = gamestate
+        currentPlayer = gamestate.currentPlayer
+        logger.info("$gamestate")
+    }
+    
+    override fun onRequestAction() {
+        val startTime = System.currentTimeMillis()
+        logger.info("Es wurde ein Zug angefordert.")
+        val possibleMoves = GameRuleLogic.getPossibleMoves()
+        sendAction(
+                if (possibleMoves.isEmpty()) PassMove(gameState.currentColor)
+                else possibleMoves.random())
+    }
+    
+    override fun sendAction(move: Move) {
+        client.sendMove(move)
+    }
+    
+    override fun gameEnded(data: GameResult, team: Team?, errorMessage: String) {
+        logger.info("Das Spiel ist beendet.")
+    }
+    
+    
+}

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

@@ -138,4 +138,10 @@ object GameRuleLogic {
             PieceShape.values()
                     .filter{ it.size == 5 && it != PieceShape.PENTO_X }
                     .random()
+    
+    /** Returns a list of all possible SetMoves. */
+    @JvmStatic
+    fun getPossibleMoves(): List<SetMove> {
+        return emptyList()
+    }
 }

plugin/src/test/sc/plugin2021/ManualGameTest.kts

@@ -5,7 +5,6 @@ import sc.plugin2021.Move
 import sc.plugin2021.SetMove
 import sc.plugin2021.helper.MoveParser
 import sc.plugin2021.util.printShapes
-import kotlin.concurrent.fixedRateTimer
 import kotlin.system.exitProcess
 
 assertDoesNotThrow { MoveParser.selfCheck() }