diff --git a/assets/js/hooks/chessBoard.js b/assets/js/hooks/chessBoard.js
index 5270610..d6e3f51 100644
--- a/assets/js/hooks/chessBoard.js
+++ b/assets/js/hooks/chessBoard.js
@@ -44,7 +44,7 @@ export const ChessBoard = {
});
},
- initBoard({ fen, orientation, player_color }) {
+ initBoard({ fen, orientation, player_color, blocked }) {
try {
this.chess.load(fen);
} catch (error) {
@@ -67,9 +67,9 @@ export const ChessBoard = {
orientation: orientation,
turnColor: turnColor,
movable: {
- color: player_color,
+ color: blocked ? null : player_color,
free: false,
- dests: this.getValidDests(),
+ dests: blocked ? new Map() : this.getValidDests(),
},
events: {
move: (orig, dest, _capturedPiece) => {
@@ -134,22 +134,25 @@ export const ChessBoard = {
},
executeMove(orig, dest, promotion) {
- const move = this.chess.move({ from: orig, to: dest, promotion });
+ const prevFen = this.chess.fen();
+ const move = promotion
+ ? this.chess.move({ from: orig, to: dest, promotion })
+ : this.chess.move({ from: orig, to: dest });
if (move) {
- const eventName =
- this.el.dataset && this.el.dataset.endgameId
- ? "endgame_move_played"
- : "move_played";
+ const isTrainer = !!(this.el.dataset && this.el.dataset.endgameId);
+ const eventName = isTrainer ? "endgame_move_played" : "move_played";
const payload = {
from: orig,
to: dest,
+ prev_fen: prevFen,
fen: this.chess.fen(),
san: move.san,
+ promotion: promotion || null,
};
- if (eventName === "endgame_move_played") {
+ if (isTrainer) {
payload.endgame_id = this.el.dataset.endgameId;
}
@@ -160,10 +163,9 @@ export const ChessBoard = {
this.ground.set({
turnColor: nextTurnColor,
fen: this.chess.fen(),
- movable: {
- color: nextTurnColor,
- dests: this.getValidDests(),
- },
+ movable: isTrainer
+ ? { color: null, dests: new Map() }
+ : { color: nextTurnColor, dests: this.getValidDests() },
});
} else {
this.ground.set({ fen: this.chess.fen() });
diff --git a/lib/chesstrainer/endgames/tablebase/parser.ex b/lib/chesstrainer/endgames/tablebase/parser.ex
index cc3dd4d..2e05ed5 100644
--- a/lib/chesstrainer/endgames/tablebase/parser.ex
+++ b/lib/chesstrainer/endgames/tablebase/parser.ex
@@ -11,7 +11,7 @@ defmodule Chesstrainer.Endgames.Tablebase.Parser do
import Chesstrainer.Ratelimiters
alias Chesstrainer.Endgames.Tablebase
- @lichess_tablebase_url "http://tablebase.lichess.ovh/standard?fen="
+ @lichess_tablebase_url "https://tablebase.lichess.ovh/standard?fen="
@spec from_fen(String.t()) ::
{:ok, Tablebase.t()} | {:cooldown, non_neg_integer()} | {:error, term()}
@@ -72,21 +72,22 @@ defmodule Chesstrainer.Endgames.Tablebase.Parser do
}
end
- defp parse_response(response) do
+ # exposed for testing
+ def parse_response(response) do
case response do
# Success
{:ok, %Req.Response{status: 200, body: body}} ->
{:ok, body}
- # Client errors
- {:ok, %Req.Response{status: status, body: body}} when status in 400..499 ->
- {:error, {:client_error, status, body}}
-
- # Rate limiting
+ # Rate limiting (must precede the generic 4xx clause, or 429 is swallowed)
{:ok, %Req.Response{status: 429, body: body}} ->
lichess_add_cooldown()
{:error, {:too_many_requests, 429, body}}
+ # Client errors
+ {:ok, %Req.Response{status: status, body: body}} when status in 400..499 ->
+ {:error, {:client_error, status, body}}
+
# Server errors
{:ok, %Req.Response{status: status, body: body}} when status in 500..599 ->
{:error, {:server_error, status, body}}
diff --git a/lib/chesstrainer_web/live/endgame_live/play.ex b/lib/chesstrainer_web/live/endgame_live/play.ex
index db3e399..e843c25 100644
--- a/lib/chesstrainer_web/live/endgame_live/play.ex
+++ b/lib/chesstrainer_web/live/endgame_live/play.ex
@@ -2,6 +2,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
use ChesstrainerWeb, :live_view
alias Chesstrainer.Endgames
+ alias Chesstrainer.Endgames.Tablebase
@impl true
def render(assigns) do
@@ -30,6 +31,26 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
+
+ <%= cond do %>
+ <% @status == :loading -> %>
+
Loading tablebase…
+ <% @status == :blocked -> %>
+
Tablebase unavailable
+
{@blocked_reason}
+ <% @last_grade == :optimal -> %>
+
Optimal move
+ <% @last_grade == :winning -> %>
+
Winning — but not the sharpest
+ <% @last_grade == :losing -> %>
+
Losing move — this throws away the win
+ <% @last_grade == :unknown -> %>
+
Could not grade that move
+ <% true -> %>
+
Make a move to have it graded.
+ <% end %>
+
+
Moves:
@@ -49,8 +70,6 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
-
Buttons
-
<.button phx-click="reset" variant="primary">
<.icon name="hero-arrow-path" /> Reset
@@ -70,30 +89,36 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
socket
|> assign(:page_title, "Play endgame")
|> assign(:endgame, endgame)
+ |> assign(:fen, endgame.fen)
+ |> assign(:tablebase, nil)
+ |> assign(:status, :loading)
+ |> assign(:blocked_reason, nil)
|> assign(:move_list, [])
|> assign(:last_san, "None yet")
|> assign(:last_from_to, "None yet")
- |> push_event("init_board", %{
- fen: endgame.fen,
- orientation: Atom.to_string(endgame.color),
- player_color: Atom.to_string(endgame.color)
- })
+ |> assign(:last_grade, nil)
- {:ok, socket}
+ {:ok, load_attempt(socket)}
end
@impl true
- def handle_event(
- "endgame_move_played",
- %{"from" => from, "to" => to, "san" => san},
- socket
- ) do
- # TODO: server-side legality check + tablebase evaluation when wired
- {:noreply,
- socket
- |> assign(:last_from_to, "#{from} ➔ #{to}")
- |> assign(:last_san, san)
- |> assign(:move_list, socket.assigns.move_list ++ [san])}
+ def handle_event("endgame_move_played", params, socket) do
+ %{"from" => from, "to" => to, "san" => san} = params
+ promotion = params["promotion"]
+ prev_fen = params["prev_fen"] || socket.assigns.fen
+
+ cond do
+ socket.assigns.status != :playing ->
+ {:noreply,
+ put_flash(socket, :error, "The tablebase is unavailable, so this move cannot be graded.")}
+
+ not same_position?(prev_fen, socket.assigns.fen) ->
+ {:noreply,
+ put_flash(socket, :error, "That move is out of sequence. Press Reset to try again.")}
+
+ true ->
+ grade_and_record(socket, from, to, promotion, san)
+ end
end
def handle_event("chess_fen_invalid", %{"fen" => fen, "message" => message}, socket) do
@@ -106,16 +131,14 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
end
def handle_event("reset", _params, socket) do
- {:noreply,
- socket
- |> assign(:move_list, [])
- |> assign(:last_san, "None yet")
- |> assign(:last_from_to, "None yet")
- |> push_event("init_board", %{
- fen: socket.assigns.endgame.fen,
- orientation: Atom.to_string(socket.assigns.endgame.color),
- player_color: Atom.to_string(socket.assigns.endgame.color)
- })}
+ socket =
+ socket
+ |> assign(:move_list, [])
+ |> assign(:last_san, "None yet")
+ |> assign(:last_from_to, "None yet")
+ |> assign(:last_grade, nil)
+
+ {:noreply, load_attempt(socket)}
end
def format_move_pairs(move_list, color) do
@@ -125,4 +148,114 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|> Enum.chunk_every(2, 2, [nil])
|> Enum.with_index(1)
end
+
+ defp load_attempt(socket) do
+ fen = socket.assigns.endgame.fen
+ socket = assign(socket, :fen, fen)
+
+ if connected?(socket) do
+ case Tablebase.new(fen) do
+ {:ok, tablebase} ->
+ socket
+ |> assign(:tablebase, tablebase)
+ |> assign(:status, :playing)
+ |> assign(:blocked_reason, nil)
+ |> push_init_board(fen)
+
+ other ->
+ socket
+ |> assign(:tablebase, nil)
+ |> assign(:status, :blocked)
+ |> assign(:blocked_reason, blocked_reason(other))
+ |> push_init_board(fen)
+ end
+ else
+ assign(socket, :status, :loading)
+ end
+ end
+
+ defp push_init_board(socket, fen) do
+ push_event(socket, "init_board", %{
+ fen: fen,
+ orientation: Atom.to_string(socket.assigns.endgame.color),
+ player_color: Atom.to_string(socket.assigns.endgame.color),
+ blocked: socket.assigns.status == :blocked
+ })
+ end
+
+ defp blocked_reason({:cooldown, remaining_ms}) do
+ seconds = max(div(remaining_ms + 999, 1000), 1)
+ "The tablebase is rate-limited. Try again in about #{seconds}s."
+ end
+
+ defp blocked_reason({:error, {:too_many_requests, _, _}}) do
+ "The tablebase is rate-limited. Try again in a minute."
+ end
+
+ defp blocked_reason({:error, {:client_error, 404, _}}) do
+ "This position is not covered by the tablebase."
+ end
+
+ defp blocked_reason({:error, reason}) do
+ "The tablebase is unavailable (#{inspect(reason)})."
+ end
+
+ defp grade_and_record(socket, from, to, promotion, san) do
+ case find_move(socket.assigns.tablebase, from, to, promotion) do
+ nil ->
+ {:noreply, put_flash(socket, :error, "Could not identify that move in the tablebase.")}
+
+ move ->
+ {:noreply,
+ socket
+ |> assign(:last_from_to, "#{from} ➔ #{to}")
+ |> assign(:last_san, san)
+ |> assign(:last_grade, grade_move(socket.assigns.tablebase, move))
+ |> assign(:move_list, socket.assigns.move_list ++ [san])}
+ end
+ end
+
+ defp find_move(%Tablebase{moves: moves}, from, to, promotion) when is_list(moves) do
+ uci = "#{from}#{to}#{promotion || ""}"
+ Enum.find(moves, &(&1.uci == uci))
+ end
+
+ defp find_move(_tablebase, _from, _to, _promotion), do: nil
+
+ # Compare only the board and side to move: chess.js may normalise the rest
+ # (castling/en-passant/halfmove/fullmove) differently from the stored FEN.
+ defp same_position?(fen_a, fen_b), do: position_key(fen_a) == position_key(fen_b)
+
+ defp position_key(fen) do
+ case String.split(fen, " ") do
+ [board, active | _] -> {board, active}
+ _ -> fen
+ end
+ end
+
+ defp grade_move(%Tablebase{moves: []}, _move), do: :unknown
+
+ defp grade_move(%Tablebase{category: position_category, moves: [best | _]}, move) do
+ best_rank = outcome_rank(position_category)
+ move_rank = outcome_rank(mover_outcome(move.category))
+
+ cond do
+ is_nil(best_rank) or is_nil(move_rank) -> :unknown
+ move_rank < best_rank -> :losing
+ move.dtz == best.dtz -> :optimal
+ true -> :winning
+ end
+ end
+
+ # The mover's outcome is the flip of `category`, which is reported from the
+ # perspective of the side to move *after* the move.
+ defp mover_outcome(:loss), do: :win
+ defp mover_outcome(:win), do: :loss
+ defp mover_outcome(:draw), do: :draw
+ defp mover_outcome(_), do: :unknown
+
+ defp outcome_rank(:win), do: 2
+ defp outcome_rank(:draw), do: 1
+ defp outcome_rank(:loss), do: 0
+ defp outcome_rank(_), do: nil
end
diff --git a/test/chesstrainer/endgames/tablebase_test.exs b/test/chesstrainer/endgames/tablebase_test.exs
index c86a9d9..9e8bf5c 100644
--- a/test/chesstrainer/endgames/tablebase_test.exs
+++ b/test/chesstrainer/endgames/tablebase_test.exs
@@ -4,6 +4,7 @@ defmodule Chesstrainer.Endgames.TablebaseTest do
alias Chesstrainer.Endgames.Tablebase
alias Chesstrainer.Endgames.Tablebase.Cache, as: TablebaseCache
alias Chesstrainer.Endgames.Tablebase.Parser
+ alias Chesstrainer.Ratelimiters
describe "normalize_category/1" do
test "maps winning categories to :win" do
@@ -68,6 +69,19 @@ defmodule Chesstrainer.Endgames.TablebaseTest do
end
end
+ describe "Parser.parse_response/1" do
+ test "a 429 sets the cooldown and returns a rate-limit error" do
+ Ratelimiters.lichess_reset_cooldown()
+ on_exit(fn -> Ratelimiters.lichess_reset_cooldown() end)
+
+ assert {:error, {:too_many_requests, 429, "rate limited"}} =
+ Parser.parse_response({:ok, %Req.Response{status: 429, body: "rate limited"}})
+
+ assert {:cooldown, remaining} = Ratelimiters.lichess_check_cooldown()
+ assert remaining > 0
+ end
+ end
+
describe "new/1" do
test "returns {:ok, tablebase} on a cache hit" do
fen = "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
diff --git a/test/chesstrainer_web/live/endgame_live/play_test.exs b/test/chesstrainer_web/live/endgame_live/play_test.exs
index 76854c7..034b976 100644
--- a/test/chesstrainer_web/live/endgame_live/play_test.exs
+++ b/test/chesstrainer_web/live/endgame_live/play_test.exs
@@ -4,6 +4,10 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
import Phoenix.LiveViewTest
import Chesstrainer.EndgamesFixtures
+ alias Chesstrainer.Endgames.Tablebase
+ alias Chesstrainer.Endgames.Tablebase.Cache, as: TablebaseCache
+ alias Chesstrainer.Ratelimiters
+
defp assert_init_board(view, expected_fen, expected_orientation, expected_player_color) do
%{proxy: {ref, _topic, _}} = view
@@ -14,9 +18,40 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert payload.player_color == expected_player_color
end
+ # Seed the tablebase cache so mount never touches the network in tests.
+ defp seed_tablebase(fen, opts \\ []) do
+ tablebase = %Tablebase{
+ category: Keyword.get(opts, :category, :win),
+ moves: Keyword.get(opts, :moves, [])
+ }
+
+ TablebaseCache.put(fen, tablebase)
+ on_exit(fn -> TablebaseCache.delete(fen) end)
+ end
+
+ defp grading_moves do
+ [
+ %Tablebase.Move{uci: "d1d7", san: "Qd7+", category: :loss, dtz: -1},
+ %Tablebase.Move{uci: "d1d5", san: "Qd5", category: :loss, dtz: -9},
+ %Tablebase.Move{uci: "d1d4", san: "Qd4", category: :draw, dtz: 0}
+ ]
+ end
+
+ defp play_move(view, endgame, from, to, san) do
+ render_hook(view, "endgame_move_played", %{
+ "from" => from,
+ "to" => to,
+ "san" => san,
+ "prev_fen" => endgame.fen,
+ "fen" => endgame.fen,
+ "endgame_id" => endgame.id
+ })
+ end
+
describe "mount" do
test "renders the chessboard hook div and pushes init_board", %{conn: conn} do
endgame = endgame_fixture(color: :white)
+ seed_tablebase(endgame.fen)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
@@ -26,6 +61,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
test "pushes black orientation when the endgame color is black", %{conn: conn} do
endgame = endgame_fixture(color: :black)
+ seed_tablebase(endgame.fen)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
@@ -34,6 +70,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
test "shows endgame metadata in the header", %{conn: conn} do
endgame = endgame_fixture(key: "KQ v K", color: :white, result: :win, rating: 1800)
+ seed_tablebase(endgame.fen)
{:ok, _view, html} = live(conn, ~p"/endgames/#{endgame}/play")
@@ -49,9 +86,26 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
end
end
+ describe "tablebase availability" do
+ test "blocks the attempt when the tablebase is cooling down", %{conn: conn} do
+ endgame = endgame_fixture()
+ TablebaseCache.delete(endgame.fen)
+ Ratelimiters.lichess_add_cooldown()
+ on_exit(fn -> Ratelimiters.lichess_reset_cooldown() end)
+
+ {:ok, view, html} = live(conn, ~p"/endgames/#{endgame}/play")
+
+ assert html =~ "Tablebase unavailable"
+
+ play_move(view, endgame, "d1", "d7", "Qd7+")
+ assert render(view) =~ "cannot be graded"
+ end
+ end
+
describe "chess_fen_invalid" do
test "shows a flash when the chessground hook reports an unparseable FEN", %{conn: conn} do
endgame = endgame_fixture()
+ seed_tablebase(endgame.fen)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
@@ -68,45 +122,75 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
end
describe "endgame_move_played" do
- test "appends the SAN move and updates last_san / last_from_to", %{conn: conn} do
+ test "grades the optimal move", %{conn: conn} do
endgame = endgame_fixture()
+ seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
- view
- |> render_hook("endgame_move_played", %{
+ play_move(view, endgame, "d1", "d7", "Qd7+")
+ html = render(view)
+
+ assert html =~ "Optimal move"
+ assert html =~ "Qd7+"
+ end
+
+ test "grades a winning but slower move as winning", %{conn: conn} do
+ endgame = endgame_fixture()
+ seed_tablebase(endgame.fen, moves: grading_moves())
+
+ {:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
+
+ play_move(view, endgame, "d1", "d5", "Qd5")
+
+ assert render(view) =~ "Winning — but not the sharpest"
+ end
+
+ test "grades a move that throws the win away as losing", %{conn: conn} do
+ endgame = endgame_fixture()
+ seed_tablebase(endgame.fen, moves: grading_moves())
+
+ {:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
+
+ play_move(view, endgame, "d1", "d4", "Qd4")
+
+ assert render(view) =~ "Losing move"
+ end
+
+ test "rejects a move that is out of sequence", %{conn: conn} do
+ endgame = endgame_fixture()
+ seed_tablebase(endgame.fen, moves: grading_moves())
+
+ {:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
+
+ render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7+",
+ "prev_fen" => "8/8/8/8/8/8/8/8 w - - 0 1",
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
- html = render(view)
- assert html =~ "Qd7+"
+ assert render(view) =~ "out of sequence"
end
end
describe "reset" do
- test "clears move list and re-pushes init_board", %{conn: conn} do
+ test "clears the move list and grade, and re-pushes init_board", %{conn: conn} do
endgame = endgame_fixture()
+ seed_tablebase(endgame.fen, moves: grading_moves())
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
- view
- |> render_hook("endgame_move_played", %{
- "from" => "d1",
- "to" => "d7",
- "san" => "Qd7+",
- "fen" => endgame.fen,
- "endgame_id" => endgame.id
- })
-
+ play_move(view, endgame, "d1", "d7", "Qd7+")
assert render(view) =~ "Qd7+"
view |> element("button", "Reset") |> render_click()
- assert render(view) =~ "No Moves"
+ html = render(view)
+ assert html =~ "No Moves"
+ refute html =~ "Optimal move"
assert_init_board(view, endgame.fen, "white", "white")
end
end