Solver: initial API and work loop

Author: ForNeVeR

src/main/scala/ru/org/codingteam/icfpc_2025/Domain.scala

@@ -0,0 +1,26 @@
+package ru.org.codingteam.icfpc_2025
+
+import upickle.ReadWriter
+
+case class ProblemDefinition(name: String, size: Int)
+object ProblemDefinition {
+    def byName(name: String): ProblemDefinition =
+        ProblemDefinition(
+            name,
+            name match
+                case "probatio" => 3
+                case "primus" => 6
+                case "secundus" => 12
+                case "tertius" => 18
+                case "quartus" => 24
+                case "quintus" => 30
+                case _ => throw new Exception(s"Unknown problem name: $name.")
+        )
+}
+case class SolutionDefinition(
+    rooms: Seq[Int],
+    startingRoom: Int,
+    connections: Seq[ConnectionDefinition]
+) derives ReadWriter
+case class ConnectionDefinition(from: Door, to: Door) derives ReadWriter
+case class Door(room: Int, door: Int) derives ReadWriter

src/main/scala/ru/org/codingteam/icfpc_2025/Main.scala

@@ -3,8 +3,6 @@ package ru.org.codingteam.icfpc_2025
 @main def main(args: String*): Unit =
     args.toList match
         case "solve" :: problemName :: Nil =>
-            println(s"solving $problemName")
-            Ædificium.select(problemName)
-            val result = Ædificium.explore(Lanternarius.lanternariuses(8, 54))
-            println(result)
+            val problem = ProblemDefinition.byName(problemName)
+            Solver.solve(problem)
         case _ => println("Usage: sbt run \"solve <problem-name>\"")

src/main/scala/ru/org/codingteam/icfpc_2025/Solver.scala

@@ -0,0 +1,54 @@
+package ru.org.codingteam.icfpc_2025
+
+import sttp.client4.upicklejson.default.asJson
+import upickle.ReadWriter
+
+import java.nio.file.{Files, Path}
+
+object Solver {
+    def solve(problem: ProblemDefinition): Unit = {
+        println(s"Solving problem ${problem.name}.")
+        Ædificium.select(problem.name)
+        println("Problem selected.")
+        
+        var knowledge = KnowledgeHolder()
+        while (true) {
+            println("Determining next step…")
+            val step = nextStep(problem, knowledge)
+            println(s"Next step is ${step.getClass.getSimpleName}")
+            step match
+                case Step.ExploreStep(plans) =>
+                    knowledge = explore(problem, knowledge, plans)
+                case Step.GuessStep(solution) =>
+                    println("Trying to commit the solution.")
+                    val correct = Ædificium.guess(solution)
+                    if (correct) {
+                        println(s"The solution for problem ${problem.name} is correct.")
+                    } else {
+                        println(s"The solution for problem ${problem.name} is not correct!")
+                        val path = dump(problem, knowledge, solution)
+                        throw new Exception("Incorrect solution! Analyze results in \"path\".")
+                    }
+        }
+    }
+    
+    private def nextStep(problem: ProblemDefinition, knowledge: KnowledgeHolder): Step = ???
+    private def dump(problem: ProblemDefinition, knowledge: KnowledgeHolder, solution: SolutionDefinition): Path =
+        val folder = Files.createTempDirectory(s"icfpc.${problem.name}")
+        Files.writeString(folder.resolve("knowledge.json"), asJson(knowledge).s)
+        Files.writeString(folder.resolve("solution.json"), asJson(solution).s)
+        
+}
+
+case class KnowledgeHolder() derives ReadWriter {
+    def incorporateKnowledge(plans: Seq[Seq[Int]], results: Seq[Seq[Int]]): KnowledgeHolder = ???
+}
+
+enum Step:
+    case ExploreStep(plans: Seq[Seq[Int]])
+    case GuessStep(solution: SolutionDefinition)
+
+private def explore(problem: ProblemDefinition, knowledge: KnowledgeHolder, plans: Seq[Seq[Int]]): KnowledgeHolder =
+    println("Exploring the labyrinth…")
+    val results = Ædificium.explore(plans)
+    knowledge.incorporateKnowledge(plans, results)

src/main/scala/ru/org/codingteam/icfpc_2025/Æedificium.scala

@@ -21,9 +21,16 @@ object Ædificium:
             secret
 
     private case class SelectRequest(id: String, problemName: String) derives ReadWriter
+
     private case class ExploreRequest(id: String, plans: Seq[String]) derives ReadWriter
     private case class ExploreResponse(results: Seq[Seq[Int]], queryCount: Int) derives ReadWriter
 
+    private case class GuessRequest(id: String, map: GuessMap) derives ReadWriter
+    private case class GuessMap(rooms: Seq[Int], startingRoom: Int, connections: Seq[GuessConnection]) derives ReadWriter
+    private case class GuessConnection(from: GuessDoor, to: GuessDoor) derives ReadWriter
+    private case class GuessDoor(room: Int, door: Int) derives ReadWriter
+    private case class GuessResponse(correct: Boolean) derives ReadWriter
+
     def select(problemName: String): Unit =
         val response = basicRequest
             .post(uri"$baseUrl/select")
@@ -33,8 +40,6 @@ object Ædificium:
 
     def explore(plans: Seq[Seq[Int]]): Seq[Seq[Int]] =
         val request = ExploreRequest(id, plans.map(_.mkString("")))
-        println(s"Sending request: ${asJson(request)}")
-
         val response = basicRequest
             .post(uri"$baseUrl/explore")
             .body(asJson(request))
@@ -43,6 +48,26 @@ object Ædificium:
         assertSuccess(response)
         response.body.toOption.get.results
 
+    def guess(solution: SolutionDefinition): Boolean =
+        def guessDoor(door: Door) = GuessDoor(door.room, door.door)
+        val request = GuessRequest(
+            id,
+            GuessMap(
+                solution.rooms,
+                solution.startingRoom,
+                solution.connections.map { connection =>
+                    GuessConnection(guessDoor(connection.from), guessDoor(connection.to))
+                }
+            )
+        )
+        val response = basicRequest
+            .post(uri"$baseUrl/guess")
+            .body(asJson(request))
+            .response(asJson[GuessResponse])
+            .send(backend)
+        assertSuccess(response)
+        response.body.toOption.get.correct
+
     private def assertSuccess(response: Response[?]): Unit =
         if response.code.code != 200 then
             throw RuntimeException(s"Request failed with status ${response.code.code}: ${response.body}")