[UI] Show game result at the end of the game

fix #108

Author: KvanTTT

composeApp/src/commonMain/kotlin/org/dots/game/App.kt

@@ -307,7 +307,7 @@ fun App(gameSettings: GameSettings = loadClassSettings(GameSettings.Default), on
                     }
                 }
                 Row(Modifier.padding(bottom = 10.dp)) {
-                    GameInfo(currentGame, player1Score, player2Score, strings, uiSettings)
+                    GameInfo(currentGame, player1Score, player2Score, getField().gameResult, strings, uiSettings)
                 }
                 Row {
                     val gameAndMoveInfo = buildString {

composeApp/src/commonMain/kotlin/org/dots/game/localization/EnglishStrings.kt

@@ -146,4 +146,13 @@ object EnglishStrings : Strings {
 Values closer to zero mean that games were played almost until all legal moves were exhausted.
 Typically, such games are unrealistic and "garbage" because humans don't play until the very end (they usually resign much earlier)."""
     override val draws = "Draws"
+
+    override val result = "Result"
+    override val reason = "Reason"
+    override val draw = "Draw"
+    override val win = "win"
+    override val interrupt = "interrupt"
+    override val resignation = "resignation"
+    override val time = "time"
+    override val unknown = "unknown"
 }

composeApp/src/commonMain/kotlin/org/dots/game/localization/RussianStrings.kt

@@ -151,4 +151,14 @@ object RussianStrings : Strings {
 Обычно это означает, что игры не соответствуют реальному игровому поведению, так как люди не играют до самого конца (они заземляются намного раньше).
 """.trimIndent()
     override val draws = "Ничьи"
+
+    // Game result
+    override val result = "Результат"
+    override val reason = "Причина"
+    override val draw = "Ничья"
+    override val win = "победил"
+    override val interrupt = "прерывание"
+    override val resignation = "сдача"
+    override val time = "время"
+    override val unknown = "неизвестно"
 }

composeApp/src/commonMain/kotlin/org/dots/game/localization/Strings.kt

@@ -115,4 +115,14 @@ interface Strings {
     val avgRemainingMoves: String
     val avgRemainingMovesComment: String
     val draws: String
+
+    // Game result
+    val result: String
+    val draw: String
+    val win: String
+    val reason: String
+    val interrupt: String
+    val resignation: String
+    val time: String
+    val unknown: String
 }

composeApp/src/commonMain/kotlin/org/dots/game/views/GameInfo.kt

@@ -0,0 +1,125 @@
+package org.dots.game.views
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import org.dots.game.Tooltip
+import org.dots.game.UiSettings
+import org.dots.game.core.Game
+import org.dots.game.core.GameResult
+import org.dots.game.isAlmostEqual
+import org.dots.game.localization.Strings
+import org.dots.game.toNeatNumber
+
+@Composable
+fun GameInfo(
+    currentGame: Game,
+    player1Score: Double,
+    player2Score: Double,
+    gameResult: GameResult?,
+    strings: Strings,
+    uiSettings: UiSettings
+) {
+    val rules = currentGame.rules
+    val rulesInfo = buildString {
+        appendLine("${strings.initPosType}: ${strings.initPosTypeLabel(rules.initPosType)}")
+        appendLine("${strings.initPosGenType}: ${strings.initPosGenTypeLabel(rules.initPosGenType)}")
+        appendLine("${strings.baseMode}: ${strings.baseModeLabel(rules.baseMode)}")
+        appendLine("${strings.suicideAllowed}: ${strings.boolToString(rules.suicideAllowed)}")
+        appendLine("${strings.komi}: ${rules.komi.toNeatNumber()}")
+        if (rules.captureByBorder) {
+            appendLine("${strings.captureByBorder}: ${strings.boolToString(rules.captureByBorder)}")
+        }
+        if (lastOrNull() == '\n') {
+            deleteAt(lastIndex)
+        }
+    }
+
+    Tooltip(rulesInfo) {
+        val player1Name = currentGame.player1Name ?: strings.firstPlayerDefaultName
+        val player2Name = currentGame.player2Name ?: strings.secondPlayerDefaultName
+        val diff = player2Score - player1Score
+        val winnerColor: Color = when {
+            diff.isAlmostEqual(0.0) -> Color.Black
+            diff > 0.0 -> uiSettings.playerSecondColor
+            else -> uiSettings.playerFirstColor
+        }
+
+        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text("$player1Name   ", color = uiSettings.playerFirstColor)
+                Text(
+                    player1Score.toNeatNumber().toString(),
+                    color = uiSettings.playerFirstColor,
+                    fontWeight = FontWeight.Bold
+                )
+
+                Text(" : ")
+
+                Text(
+                    player2Score.toNeatNumber().toString(),
+                    color = uiSettings.playerSecondColor,
+                    fontWeight = FontWeight.Bold
+                )
+                Text("   $player2Name", color = uiSettings.playerSecondColor)
+
+                if (uiSettings.developerMode) {
+                    Text("  (${diff.toNeatNumber()})", color = winnerColor)
+                }
+            }
+            if (gameResult != null) {
+                Row(
+                    Modifier.padding(top = 10.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    val winner = when (gameResult) {
+                        is GameResult.WinGameResult -> gameResult.winner
+                        is GameResult.Draw -> null
+                    }
+                    val reason = when (gameResult) {
+                        is GameResult.Draw -> null
+                        is GameResult.InterruptWin -> strings.interrupt
+                        is GameResult.ResignWin -> strings.resign
+                        is GameResult.ScoreWin -> strings.score
+                        is GameResult.TimeWin -> strings.time
+                        is GameResult.UnknownWin -> strings.unknown
+                    }
+                    val resultText = buildString {
+                        append(strings.result)
+                        append(": ")
+                        if (winner != null) {
+                            append(player1Name)
+                            append(' ')
+                            append(strings.win)
+                        } else {
+                            append(strings.draw)
+                        }
+                        if (reason != null) {
+                            append(" (")
+                            append(strings.reason)
+                            append(": ")
+                            append(reason)
+                            if (gameResult is GameResult.ScoreWin) {
+                                append(" +")
+                                append(gameResult.score.toNeatNumber())
+                            }
+                            append(')')
+                        }
+                    }
+                    Text(
+                        resultText,
+                        color = winnerColor,
+                        fontWeight = FontWeight.Bold
+                    )
+                }
+            }
+        }
+    }
+}