Merge refactor into master

Author: Zomis

.gitignore

@@ -1,3 +1,4 @@
+server2.conf
 *.log
 
 .idea/

Dockerfile

@@ -4,7 +4,8 @@ EXPOSE 42638
 
 WORKDIR /server2/
 ADD games-server/build/libs/*-all.jar /server2/
+ADD server2.conf.docker /server2/server2.conf
 
 VOLUME /data/logs/
 
-CMD java -jar /server2/games-server-1.0-SNAPSHOT-all.jar -httpPort 42638
+CMD java -jar /server2/games-server-1.0-SNAPSHOT-all.jar

Jenkinsfile

@@ -7,21 +7,18 @@ pipeline {
     agent any
 
     stages {
-        stage('Prepare') {
-            steps {
-                checkout scm
-            }
-        }
         stage('Build') {
             steps {
                 sh 'cp /home/zomis/jenkins/server2-secrets.properties games-server/src/main/resources/secrets.properties'
+                sh 'cp /home/zomis/jenkins/server2-startup.conf server2.conf.docker'
                 sh './gradlew clean test :games-server:assemble :games-js:assemble'
                 script {
                     def gitChanges = sh(script: 'git diff-index HEAD', returnStatus: true)
                     if (gitChanges) {
                         error("There are git changes after build")
                     }
                 }
+                sh 'cp games-js/.eslintrc.js games-js/web/'
                 dir('games-vue-client') {
                     sh 'npm install && npm run build'
                 }

games-core/build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-    ext.kotlin_version = '1.2.30'
+    ext.kotlin_version = '1.3.31'
     ext.junitJupiterVersion = '5.0.2'
 
     repositories {
@@ -20,11 +20,12 @@ sourceCompatibility = 1.6
 repositories {
     mavenCentral()
     maven { url "http://www.zomis.net/maven" }
+    maven { url 'https://jitpack.io' } // KLogging
 }
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib-common:$kotlin_version"
-    compile "com.github.lewik.klogging:klogging.common:1.2.30"
+    compile "com.github.lewik.klog:klog-metadata:1.3.31"
     compile "net.zomis:uttt-common:0.3.0"
 
     testCompile "org.jetbrains.kotlin:kotlin-test-common:$kotlin_version"

games-core/src/main/kotlin/net/zomis/Best.kt

@@ -0,0 +1,26 @@
+package net.zomis
+
+class Best<T>(private val valueFunction: (T) -> Double) {
+
+    private var bestValue: Double = Double.NEGATIVE_INFINITY
+    private var bestElements: MutableList<T> = mutableListOf()
+
+    fun next(element: T) {
+        val value = valueFunction(element)
+        if (value > bestValue) {
+            bestValue = value
+            bestElements = mutableListOf(element)
+        } else if (value >= bestValue) {
+            bestElements.add(element)
+        }
+    }
+
+    fun asCollection(): Collection<T> = bestElements.toList()
+
+    fun randomBest(): T = bestElements.random()
+    fun getBest(): List<T> = bestElements.toList()
+    fun firstBest(): T = bestElements.first()
+    fun isBest(element: T): Boolean = bestElements.contains(element)
+    fun getBestValue(): Double = bestValue
+
+}

games-core/src/main/kotlin/net/zomis/core/events/EventSystem.kt

@@ -1,6 +1,6 @@
 package net.zomis.core.events
 
-import klogging.KLoggers
+import klog.KLoggers
 import kotlin.reflect.KClass
 
 enum class ListenerPriority { FIRST, EARLIER, EARLY, NORMAL, LATE, LATER, LAST }
@@ -34,14 +34,14 @@ class ListenerList<E> {
     }
 
     fun execute(event: E) {
-        list.forEach({
+        list.forEach {
             try {
                 it.run(event)
             } catch (e: RuntimeException) {
                 logger.error(e, "Problem when handling event $event in $it")
                 throw e
             }
-        })
+        }
     }
 
 }
@@ -54,7 +54,7 @@ open class EventSystem {
     fun <E : Any> listen(description: String, priority: ListenerPriority, clazz: KClass<E>,
          condition: (E) -> Boolean, handler: EventHandler<E>) {
         logger.info("Add Listener \"$description\" with priority $priority to $clazz: $handler")
-        val list: ListenerList<E> = listeners.getOrElse(clazz as KClass<Any>, { ListenerList<E>() }) as ListenerList<E>
+        val list: ListenerList<E> = listeners.getOrElse(clazz as KClass<Any>) { ListenerList<E>() } as ListenerList<E>
         list.add(Listener(description, priority, condition, handler))
         listeners[clazz] = list as ListenerList<Any>
     }

games-core/src/main/kotlin/net/zomis/games/Features.kt

@@ -1,6 +1,6 @@
 package net.zomis.games
 
-import klogging.KLoggers
+import klog.KLoggers
 import net.zomis.core.events.EventSystem
 import kotlin.reflect.KClass
 
@@ -17,7 +17,7 @@ class Features(val events: EventSystem?) {
     val data = mutableSetOf<Any>()
 
     operator fun <T: Any> get(clazz: KClass<T>): T? {
-        val value = data.find({ clazz.isInstance(it) })
+        val value = data.find { clazz.isInstance(it) }
         return value as T?
     }
 

games-core/src/main/kotlin/net/zomis/games/Map2D.kt

@@ -0,0 +1,145 @@
+package net.zomis.games
+
+import net.zomis.Best
+
+private fun flipX(start: Position): Position {
+    return Position(start.sizeX - 1 - start.x, start.y, start.sizeX, start.sizeY)
+}
+private fun flipY(start: Position): Position {
+    return Position(start.x, start.sizeY - 1 - start.y, start.sizeX, start.sizeY)
+}
+private fun rotate(start: Position): Position {
+    return Position(start.sizeY - 1 - start.y, start.x, start.sizeY, start.sizeX)
+}
+
+data class Position(val x: Int, val y: Int, val sizeX: Int, val sizeY: Int) {
+    fun next(): Position? {
+        if (x == sizeX - 1) {
+            return if (y == sizeY - 1) null else Position(0, y + 1, sizeX, sizeY)
+        }
+        return Position(this.x + 1, this.y, this.sizeX, this.sizeY)
+    }
+}
+
+enum class TransformationType(val transforming: (Position) -> Position, val reverse: (Position) -> Position) {
+    FLIP_X(::flipX, ::flipX),
+    FLIP_Y(::flipY, ::flipY),
+    ROTATE(::rotate, { start -> rotate(rotate(rotate(start))) }),
+    ;
+}
+
+enum class Transformation(private val transformations: List<TransformationType>) {
+    NO_CHANGE(listOf()),
+    FLIP_X(listOf(TransformationType.FLIP_X)),
+    FLIP_Y(listOf(TransformationType.FLIP_Y)),
+    ROTATE_90(listOf(TransformationType.ROTATE)),
+    ROTATE_180(listOf(TransformationType.ROTATE, TransformationType.ROTATE)),
+    ROTATE_270(listOf(TransformationType.ROTATE, TransformationType.ROTATE, TransformationType.ROTATE)),
+    ROTATE_90_FLIP_X(listOf(TransformationType.ROTATE, TransformationType.FLIP_X)),
+    ROTATE_90_FLIP_Y(listOf(TransformationType.ROTATE, TransformationType.FLIP_Y)),
+    ;
+
+    fun transform(position: Position): Position {
+        return transformations.fold(position) { pos, trans -> trans.transforming(pos) }
+    }
+
+    fun reverseTransform(position: Position): Position {
+        return transformations.reversed().fold(position) { pos, trans -> trans.reverse(pos) }
+    }
+
+    private val referencePoints = arrayOf(
+        Position(3, 2, 5, 5),
+        Position(4, 0, 5, 5)
+    )
+    fun apply(transformation: Transformation): Transformation {
+        val simplestTransformation = Transformation.values().filter {result ->
+            referencePoints.all {p -> transformation.transform(this.transform(p)) == result.transform(p) }
+        }
+        return simplestTransformation.single()
+    }
+
+}
+
+class Map2D<T>(val sizeX: Int, val sizeY: Int, val getter: (x: Int, y: Int) -> T, val setter: (x: Int, y: Int, value: T) -> Unit) {
+
+    fun standardizedTransformation(valueFunction: (T) -> Int): Transformation {
+        // keep a Set<Transformation>, start with all of them
+        // loop through Transformations and find ones with the extremes
+        // the goal is that of all the possible transformations, the result should be the one with the lowest/highest value
+
+        // start in the possible fields for the target map upper-left corner
+        // then continue, line by line, beginning with increasing X and then increase Y
+        val possibleTransformations = Transformation.values().toMutableSet()
+        if (sizeX != sizeY) {
+            // Rotating 90 or 270 degrees only works if both width or height is the same
+            possibleTransformations.remove(Transformation.ROTATE_90)
+            possibleTransformations.remove(Transformation.ROTATE_270)
+        }
+
+        var position: Position? = Position(0, 0, sizeX, sizeY)
+        while (possibleTransformations.size > 1 && position != null) {
+            val best = Best<Transformation> { transformation ->
+                val originalPos = transformation.reverseTransform(position!!)
+                val originalT = getter(originalPos.x, originalPos.y)
+                valueFunction(originalT).toDouble()
+            }
+            possibleTransformations.forEach {
+                best.next(it)
+            }
+            possibleTransformations.retainAll(best.getBest())
+
+            position = position.next()
+        }
+
+        val transformation = possibleTransformations.first() // map can be symmetric so don't use .single
+        return transformation
+    }
+
+    fun transform(transformation: Transformation) {
+        val rotated = Map2DX(sizeX, sizeY) { x, y ->
+            val pos = Position(x, y, sizeX, sizeY)
+            val oldPos = transformation.reverseTransform(pos)
+            getter(oldPos.x, oldPos.y)
+        }
+
+        (0 until sizeY).forEach {y ->
+            (0 until sizeX).forEach {x ->
+                setter(x, y, rotated.grid[y][x])
+            }
+        }
+    }
+
+    fun standardize(valueFunction: (T) -> Int) {
+        this.transform(this.standardizedTransformation(valueFunction))
+    }
+
+}
+
+class Map2DX<T>(val sizeX: Int, val sizeY: Int, val factory: (x: Int, y: Int) -> T) {
+
+    val grid: MutableList<MutableList<T>> = (0 until sizeY).map { y ->
+        (0 until sizeX).map { x ->
+            factory(x, y)
+        }.toMutableList()
+    }.toMutableList()
+
+    fun set(x: Int, y: Int, value: T) {
+        grid[y][x] = value
+    }
+
+    fun asMap2D(): Map2D<T> {
+        return Map2D(sizeX, sizeY, { x, y -> grid[y][x] }) {x, y, v ->
+            grid[y][x] = v
+        }
+    }
+
+    fun standardize(value: (T) -> Int): Map2DX<T> {
+        asMap2D().standardize(value)
+        return this
+    }
+
+    override fun toString(): String {
+        return "Map2D(grid=$grid)"
+    }
+
+}

games-core/src/main/kotlin/net/zomis/games/dsl/DslAPI.kt

@@ -0,0 +1,53 @@
+package net.zomis.games.dsl
+
+import kotlin.reflect.KClass
+
+data class Point(val x: Int, val y: Int)
+interface Actionable<T : Any, A : Any> {
+    val playerIndex: Int
+    val game: T
+    val parameter: A
+}
+data class Action2D<T : Any, P>(override val game: T, override val playerIndex: Int,
+        val x: Int, val y: Int, val target: P): Actionable<T, Point> {
+    override val parameter = Point(x, y)
+}
+data class Action<T : Any, A : Any>(override val game: T, override val playerIndex: Int,
+        override val parameter: A): Actionable<T, A>
+
+typealias PlayerIndex = Int?
+fun PlayerIndex.isObserver(): Boolean = this == null
+
+typealias GameSpec<T> = GameDsl<T>.() -> Unit
+typealias GameModelDsl<T, C> = GameModel<T, C>.() -> Unit
+typealias GameLogicDsl<T> = GameLogic<T>.() -> Unit
+typealias GameViewDsl<T> = GameView<T>.() -> Unit
+typealias GridDsl<T, P> = GameGrid<T, P>.() -> Unit
+
+interface GameGrid<T, P> {
+    val model: T
+    fun size(sizeX: Int, sizeY: Int)
+    fun getter(getter: (x: Int, y: Int) -> P)
+}
+
+interface GridSpec<T, P> {
+    val sizeX: (T) -> Int
+    val sizeY: (T) -> Int
+    fun get(model: T, x: Int, y: Int): P
+}
+
+interface GameDsl<T : Any> {
+    fun <P> gridSpec(spec: GridDsl<T, P>): GridDsl<T, P>
+    fun <C : Any> setup(configClass: KClass<C>, modelDsl: GameModelDsl<T, C>)
+    fun logic(logicDsl: GameLogicDsl<T>)
+    fun view(viewDsl: GameViewDsl<T>)
+}
+
+fun <T : Any> createGame(name: String, dsl: GameDsl<T>.() -> Unit): GameSpec<T> {
+    return dsl
+}
+
+data class ActionType<A>(val name: String)
+fun <A : Any> createActionType(name: String, parameterType: KClass<A>): ActionType<A> {
+    return ActionType<A>(name)
+}

games-core/src/main/kotlin/net/zomis/games/dsl/DslUTTT.kt

@@ -0,0 +1,51 @@
+package net.zomis.games.dsl
+
+import net.zomis.tttultimate.TTBase
+import net.zomis.tttultimate.TTFactories
+import net.zomis.tttultimate.TTPlayer
+import net.zomis.tttultimate.games.TTClassicController
+import net.zomis.tttultimate.games.TTController
+
+data class TTOptions(val m: Int, val n: Int, val k: Int)
+fun TTPlayer.index(): Int {
+    return when (this) {
+        TTPlayer.X -> 0
+        TTPlayer.O -> 1
+        TTPlayer.NONE -> -1
+        TTPlayer.XO -> -1
+    }
+}
+
+class DslTTT {
+    val playAction = createActionType<Point>("play", Point::class)
+    val game = createGame<TTController>("TTT") {
+        val grid = gridSpec<TTBase> {
+            size(model.game.sizeX, model.game.sizeY)
+            getter { x, y -> model.game.getSub(x, y)!! }
+        }
+        setup(TTOptions::class) {
+            defaultConfig {
+                TTOptions(3, 3, 3)
+            }
+            init {conf ->
+                TTClassicController(TTFactories().classicMNK(conf!!.m, conf.n, conf.k))
+            }
+        }
+        logic {
+            action2D(playAction, grid) {
+                allowed { it.playerIndex == it.game.currentPlayer.index() && it.game.isAllowedPlay(it.target) }
+                effect {
+                    it.game.play(it.target)
+                }
+            }
+        }
+        view {
+            currentPlayer { it.currentPlayer.index() }
+            winner { if (it.isGameOver) it.wonBy.index() else null }
+            grid("board", grid) {
+                owner { it.wonBy.index().takeIf {n -> n >= 0 } }
+            }
+        }
+    }
+
+}