schlawg/local-play

.gitignore

@@ -14,14 +14,15 @@ project/metals.sbt
 project/project
 project/target
 public/compiled
+public/hashed
 public/npm
 public/lifat
 public/css/
+public/json
 target
 data/
 dist/
 node_modules/
-local/
 ui/common/css/theme/gen/*.scss
 ui/common/**/*.js
 ui/common/**/*.d.ts

.prettierignore

@@ -27,6 +27,7 @@
 
 *.min.js
 readme
+routes
 
 /.bloop/
 /.bsp/

app/Env.scala

@@ -127,6 +127,8 @@ final class Env(
     case lila.puzzle.DailyPuzzle.Render(puzzle, fen, lastMove, promise) =>
       promise.success(Html(views.puzzle.bits.daily(puzzle, fen, lastMove)))
 
+  def getFile(path: String) = environment.getFile(path)
+
 end Env
 
 given ConfigLoader[NetConfig] = ConfigLoader(config =>

app/LilaComponents.scala

@@ -126,6 +126,7 @@ final class LilaComponents(
   lazy val irwin: Irwin                   = wire[Irwin]
   lazy val learn: Learn                   = wire[Learn]
   lazy val lobby: Lobby                   = wire[Lobby]
+  lazy val localPlay: Local               = wire[Local]
   lazy val main: Main                     = wire[Main]
   lazy val msg: Msg                       = wire[Msg]
   lazy val mod: Mod                       = wire[Mod]

app/controllers/Local.scala

@@ -0,0 +1,77 @@
+package controllers
+
+import play.api.libs.json.*
+import play.api.i18n.Lang
+import play.api.mvc.*
+import play.api.data.*
+import play.api.data.Forms.*
+import views.*
+
+import lila.app.{ given, * }
+import lila.common.Json.given
+import lila.user.User
+import lila.rating.{ Perf, PerfType }
+import lila.local.GameSetup
+
+final class Local(env: Env) extends LilaController(env):
+  val setupForm =
+    Form:
+      mapping(
+        "white" -> optional(nonEmptyText),
+        "black" -> optional(nonEmptyText),
+        "fen"   -> optional(nonEmptyText),
+        "time"  -> optional(nonEmptyText),
+        "go"    -> play.api.data.Forms.boolean
+      )(GameSetup.apply)(unapply)
+
+  def index(devUi: Option[String]) = OpenBody:
+    NoBot:
+      Ok.page(indexPage(none, optTrue(devUi))).map(_.enforceCrossSiteIsolation)
+
+  def newGame(
+      white: Option[String],
+      black: Option[String],
+      fen: Option[String],
+      time: Option[String],
+      go: Option[String],
+      devUi: Option[String]
+  ) = OpenBody:
+    NoBot:
+      Ok.page(indexPage(GameSetup(white, black, fen, time, optTrue(go)).some, optTrue(devUi)))
+        .map(_.enforceCrossSiteIsolation)
+
+  def newGameForm(devUi: Option[String]) = OpenBody:
+    NoBot:
+      bindForm(setupForm)(
+        err => jsonFormError(err),
+        setup => Ok.page(indexPage(setup.some, optTrue(devUi))).map(_.enforceCrossSiteIsolation)
+      )
+
+  private def indexPage(setup: Option[GameSetup], devUi: Boolean)(using ctx: Context) =
+    given setupFormat: Format[GameSetup] = Json.format[GameSetup]
+    views.local.index(
+      Json
+        .obj(
+          "pref" -> pref
+        )
+        .add("setup", setup)
+        .add(
+          "assets",
+          devUi.option(
+            // we'll replace these filesystem calls with a mapping json when things settle down
+            Json.obj(
+              "image" -> env.getFile(s"public/lifat/bots/images").listFiles().toList.map(_.getName),
+              "net"   -> env.getFile(s"public/lifat/bots/nets").listFiles().toList.map(_.getName),
+              "book"  -> env.getFile(s"public/lifat/bots/books").listFiles().toList.map(_.getName),
+              "sound" -> env.getFile(s"public/lifat/bots/sounds").listFiles().toList.map(_.getName)
+            )
+          )
+        ),
+      devUi
+    )
+
+  private def pref(using ctx: Context) =
+    lila.pref.JsonView.write(ctx.pref, false).add("animationDuration", ctx.pref.animationMillis.some)
+
+  private def optTrue(s: Option[String]) =
+    s.exists(v => v == "" || v == "1" || v == "true")

app/controllers/Round.scala

@@ -71,7 +71,7 @@ final class Round(
               jsChat <- chat.flatMap(_.game).map(_.chat).soFu(lila.chat.JsonView.asyncLines)
             yield Ok(data.add("chat", jsChat)).noCache
       )
-    yield res
+    yield res.enforceCrossSiteIsolation
 
   def player(fullId: GameFullId) = Open:
     env.round.proxyRepo

app/views/ui.scala

@@ -93,5 +93,7 @@ val challenge = lila.challenge.ui.ChallengeUi(helpers)
 
 val dev = lila.web.ui.DevUi(helpers)(mod.ui.menu)
 
+val local = lila.local.ui.LocalUi(helpers)
+
 def mobile(p: lila.cms.CmsPage.Render)(using Context) =
   lila.web.ui.mobile(helpers)(cms.render(p))

bin/results.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+import json
+import sys
+import os
+
+# type GameResult = {
+#   result: 'white'|'black'|'draw'|'error';
+#   reason: string;
+#   white: string|{name: string};
+#   black: string|{name: string};
+#   movetime: number;
+#   threads: number;
+#   hash: number;
+#   nfold?: number;
+#   startingFen?: string;
+#   moves: number | uci[];
+# };
+
+def main():
+    width = 16 # crosstable width (minus 1 padding)
+    engines = ['11hce','16hce','14nn12','16nn07','16nn12','16nn40','16nn60'] # preferred sort order
+    template = {'W': 0, 'D': 0, 'L': 0}
+    draws = {}
+    xtable = {}
+    results = []
+    errors = []
+
+    for x in range(1, len(sys.argv)):
+        try:
+            with open(sys.argv[x], 'r') as f:
+                results.extend(json.load(f))
+            print('Loaded ' + sys.argv[x])
+        except IOError as e:
+            print(str(e) + ' while loading ' + sys.argv[x])
+
+    for game in results:
+        outcome = game['result']
+        reason = game['reason']
+        w = short(game['white'])
+        b = short(game['black'])
+        if outcome == 'error' or outcome == 'draw' and reason.startswith('Stockfish'):
+            errors.append(reason) # tolerate errors in some earlier batches
+        elif outcome == 'draw':
+            xtable.setdefault(w, {}).setdefault(b, template.copy())['D'] += 1
+            xtable.setdefault(b, {}).setdefault(w, template.copy())['D'] += 1
+            draws[reason] = draws.get(reason, 0) + 1
+        else:
+            winner = w if outcome == 'white' else b
+            loser = b if outcome == 'white' else w
+            xtable.setdefault(winner, {}).setdefault(loser, template.copy())['W'] += 1
+            xtable.setdefault(loser, {}).setdefault(winner, template.copy())['L'] += 1
+
+    print('Total games:', len(results) - len(errors))
+    print('Draws by reason:')
+    for reason, count in draws.items():
+        print(f'  {reason}: {count}')
+    print('Crosstable:\n| ' + 'row vs col'.ljust(width), end='| ')
+    for e in engines:
+        print(f"W/D/L vs {e}".ljust(width), end='| ')
+    print()
+    for _ in range(len(engines)+1):
+        print('|'.ljust(width+2,'-'), end='')
+    print('|')
+    for e in engines:
+        print('| ' + e.ljust(width), end='| ')
+        for vsE in engines:
+            try:
+                print(wdl(xtable[e][vsE]).ljust(width), end='| ')
+            except KeyError:
+                print('       -'.ljust(width), end='| ')
+        print()
+
+def wdl(tally):
+    return f"{str(tally['W']).ljust(4)}/ {str(tally['D']).ljust(4)}/ {str(tally['L']).ljust(4)}"
+
+def short(engine): # don't want the full engine name
+    try:
+        engine = engine['name'][10:]
+    except TypeError as e:
+        engine = engine[10:] # compensate for a breaking change in the dataset format
+    if engine == '11':
+        return '11hce'
+    elif engine == '16 HCE':
+        return '16hce'
+    elif engine == '14 NNUE':
+        return '14nn12'
+    elif engine.endswith('7MB'):
+        return '16nn07'
+    elif engine.endswith('12MB'):
+        return '16nn12'
+    elif engine.endswith('40MB'):
+        return '16nn40'
+    elif engine.endswith('60MB'):
+        return '16nn60'
+    return 'unknown'
+
+if __name__ == '__main__':
+    main()

build.sbt

@@ -82,7 +82,7 @@ lazy val modules = Seq(
   pool, lobby, relation, tv, coordinate, feed, history,
   shutup, appeal, irc, explorer, learn, event, coach,
   practice, evalCache, irwin, bot, racer, cms, i18n,
-  socket, bookmark, studySearch, gameSearch, forumSearch, teamSearch,
+  socket, bookmark, studySearch, gameSearch, forumSearch, teamSearch, local
 )
 
 lazy val moduleRefs = modules map projectToRef
@@ -155,6 +155,11 @@ lazy val racer = module("racer",
   Seq()
 )
 
+lazy val local = module("local",
+  Seq(db, memo, ui, pref),
+  Seq()
+)
+
 lazy val video = module("video",
   Seq(memo, ui),
   macwire.bundle

conf/routes

@@ -341,6 +341,13 @@ GET   /streamer/:username              controllers.Streamer.show(username: UserS
 GET   /streamer/:username/redirect     controllers.Streamer.redirect(username: UserStr)
 POST  /streamer/:username/check        controllers.Streamer.checkOnline(username: UserStr)
 
+# LocalPlay
+
+GET   /local                               controllers.Local.index(devUi: Option[String])
+GET   /local/new                           controllers.Local.newGame(white: Option[String], black: Option[String], fen: Option[String], time: Option[String], go: Option[String], devUi: Option[String])
+POST  /local                               controllers.Local.newGameForm(devUi: Option[String])
+# GET   /local/assets                        controllers.Local.assets
+
 # Round
 GET   /$gameId<\w{8}>                            controllers.Round.watcher(gameId: GameId, color: Color = Color.white)
 GET   /$gameId<\w{8}>/$color<white|black>        controllers.Round.watcher(gameId: GameId, color: Color)

modules/local/src/main/LocalUi.scala

@@ -0,0 +1,111 @@
+package lila.local
+package ui
+
+import play.api.libs.json.*
+import play.api.i18n.Lang
+
+import lila.ui.*
+import ScalatagsTemplate.{ *, given }
+import scalalib.paginator.Paginator
+import lila.core.i18n.{ I18nKey as trans }
+import lila.common.Json.given
+import lila.common.String.html.safeJsonValue
+import lila.local.GameSetup
+
+final class LocalUi(helpers: Helpers):
+  import helpers.{ *, given }
+
+  def index(data: JsObject, devUi: Boolean)(using ctx: Context) =
+    Page("")
+      .copy(fullTitle = s"Play vs Bots".some)
+      .js(
+        PageModule(if devUi then "local.dev" else "local", data ++ Json.obj("i18n" -> i18nJsObject(i18nKeys)))
+      )
+      .js(EsmInit("round"))
+      .css(if devUi then "local.dev" else "local")
+      .css("round")
+      .css(ctx.pref.hasKeyboardMove.option("keyboardMove"))
+      .css(ctx.pref.hasVoice.option("voice"))
+      .csp(_.withWebAssembly)
+      .graph(
+        OpenGraph(
+          title = "Play vs Bots",
+          description = "Play vs Bots",
+          url = netBaseUrl.value
+        )
+      )
+      .zoom
+      .hrefLangs(lila.ui.LangPath("/")) {
+        emptyFrag
+      }
+
+//def i18n(using Translate) = i18nJsObject(i18nKeys)
+
+  private val i18nKeys = Vector(
+    trans.site.oneDay,
+    trans.site.nbDays,
+    trans.site.nbHours,
+    trans.site.nbSecondsToPlayTheFirstMove,
+    trans.site.kingInTheCenter,
+    trans.site.threeChecks,
+    trans.site.variantEnding,
+    trans.site.anonymous,
+    trans.site.flipBoard,
+    trans.site.aiNameLevelAiLevel,
+    trans.site.yourTurn,
+    trans.site.abortGame,
+    trans.site.proposeATakeback,
+    trans.site.offerDraw,
+    trans.site.resign,
+    trans.site.opponentLeftCounter,
+    trans.site.opponentLeftChoices,
+    trans.site.forceResignation,
+    trans.site.forceDraw,
+    trans.site.threefoldRepetition,
+    trans.site.claimADraw,
+    trans.site.drawOfferSent,
+    trans.site.cancel,
+    trans.site.yourOpponentOffersADraw,
+    trans.site.accept,
+    trans.site.decline,
+    trans.site.takebackPropositionSent,
+    trans.site.yourOpponentProposesATakeback,
+    trans.site.thisAccountViolatedTos,
+    trans.site.gameAborted,
+    trans.site.checkmate,
+    trans.site.cheatDetected,
+    trans.site.whiteResigned,
+    trans.site.blackResigned,
+    trans.site.whiteDidntMove,
+    trans.site.blackDidntMove,
+    trans.site.stalemate,
+    trans.site.whiteLeftTheGame,
+    trans.site.blackLeftTheGame,
+    trans.site.draw,
+    trans.site.whiteTimeOut,
+    trans.site.blackTimeOut,
+    trans.site.whiteIsVictorious,
+    trans.site.blackIsVictorious,
+    trans.site.drawByMutualAgreement,
+    trans.site.fiftyMovesWithoutProgress,
+    trans.site.insufficientMaterial,
+    trans.site.withdraw,
+    trans.site.rematch,
+    trans.site.rematchOfferSent,
+    trans.site.rematchOfferAccepted,
+    trans.site.waitingForOpponent,
+    trans.site.cancelRematchOffer,
+    trans.site.newOpponent,
+    trans.site.confirmMove,
+    trans.site.viewRematch,
+    trans.site.whitePlays,
+    trans.site.blackPlays,
+    trans.site.giveNbSeconds,
+    trans.preferences.giveMoreTime,
+    trans.site.gameOver,
+    trans.site.analysis,
+    trans.site.yourOpponentWantsToPlayANewGameWithYou,
+    trans.site.youPlayTheWhitePieces,
+    trans.site.youPlayTheBlackPieces,
+    trans.site.itsYourTurn
+  )

modules/local/src/main/model.scala

@@ -0,0 +1,9 @@
+package lila.local
+
+case class GameSetup(
+    white: Option[String],
+    black: Option[String],
+    fen: Option[String],
+    time: Option[String],
+    go: Boolean = false
+)