Show tablebase moves during review (#65) (#102)

* engine 8+ tablebase adr

* Show tablebase moves during review (#65)

- group reviewed moves by winning/drawn/losing and make each row playable
- move review navigation under the board with start/end jumps
- give review a full-height scrollable tablebase pane
This commit is contained in:
2026-11-06 15:31:11 +01:00
committed by GitHub
parent bd8be4d10d
commit b17f346b25
7 changed files with 382 additions and 153 deletions
+1 -1
View File
@@ -1,6 +1,6 @@
# Eight-or-more-piece endgames are trained from engine-sourced corridors that hand off to the tablebase at seven # Eight-or-more-piece endgames are trained from engine-sourced corridors that hand off to the tablebase at seven
_Status: proposed. Extends ADR-0005: the ≤7-piece source split stands; this adds a source for 8+._ _Status: accepted. Extends ADR-0005: the ≤7-piece source split stands; this adds a source for 8+._
Syzygy stops at seven pieces and there is no tablebase for eight or more. To Syzygy stops at seven pieces and there is no tablebase for eight or more. To
train such endgames without pretending to a completeness they lack, each 8+ train such endgames without pretending to a completeness they lack, each 8+
+234 -124
View File
@@ -28,123 +28,62 @@ defmodule ChesstrainerWeb.PlayComponents do
def play_surface(assigns) do def play_surface(assigns) do
~H""" ~H"""
<div class="flex gap-2 bg-base-200 p-4 rounded-xl shadow-inner"> <div class="flex gap-2 bg-base-200 p-4 rounded-xl shadow-inner">
<div <div class="w-100 flex flex-col gap-2">
id="endgame-board" <div
phx-hook="ChessBoard" id="endgame-board"
phx-update="ignore" phx-hook="ChessBoard"
data-endgame-id={@endgame.id} phx-update="ignore"
class="w-100 h-100" data-endgame-id={@endgame.id}
> class="w-100 h-100"
</div> >
<div class="w-48 h-100 flex flex-col gap-3">
<div class="rounded-lg bg-canvas-raised p-3 text-sm">
<p class="flex items-center justify-between gap-2 font-semibold">
<span>{turn_label(@status, @awaiting_reply)}</span>
<span class="text-xs font-normal text-muted">You play {colour_name(@endgame.color)}</span>
</p>
</div> </div>
<div class="rounded-lg bg-canvas-raised p-3 text-sm"> <div :if={@reviewing} id="review-controls" class="flex items-center gap-2">
<%= cond do %> <.button
<% @status == :loading -> %> id="review-start"
<p class="text-muted">Loading tablebase…</p> phx-click="review_start"
<% @status == :blocked -> %> disabled={@review_index <= 0}
<p class="font-semibold text-error">Tablebase unavailable</p> title="Back to start"
<p class="text-error">{@blocked_reason}</p> >
<% @status == :solved -> %> {"<<"}
<p class="font-semibold text-success-text"> </.button>
{if @endgame.result == :draw, do: "Draw held!", else: "Solved!"} <.button
</p> id="review-prev"
<% @status == :failed -> %> phx-click="review_prev"
<p class="font-semibold text-error">Failed</p> disabled={@review_index <= 0}
<p class="text-error"> title="Previous position"
{if @endgame.result == :draw, >
do: "That move loses the draw.", ←
else: "That move throws away the win."} </.button>
</p> <.button
<%= if @best_move && @plies != [] do %> id="review-next"
<p class="text-muted"> phx-click="review_next"
You played {List.last(@plies).san}; best was: {@best_move} disabled={@review_index >= length(@line)}
</p> title="Next position"
<% end %> >
<% @awaiting_reply -> %> →
<p class="text-muted">Opponent is replying…</p> </.button>
<% @last_grade == :optimal -> %> <.button
<p class="font-semibold text-success-text">Optimal move</p> id="review-end"
<% @last_grade == :winning -> %> phx-click="review_end"
<p class="font-semibold text-warning"> disabled={@review_index >= length(@line)}
{if @endgame.result == :draw, title="Go to end"
do: "Keeps the draw — but not the sharpest", >
else: "Winning — but not the sharpest"} {">>"}
</p> </.button>
<% @last_grade == :losing -> %>
<p class="font-semibold text-error">
{if @endgame.result == :draw,
do: "Losing move — this loses the draw",
else: "Losing move — this throws away the win"}
</p>
<% @last_grade == :unknown -> %>
<p class="font-semibold text-muted">Could not grade that move</p>
<% true -> %>
<p class="text-muted">Make a move to have it graded.</p>
<% end %>
<p :if={@status in [:solved, :failed]} class="mt-1 text-xs text-muted">
Puzzle rating: {round(@endgame.rating)}
</p>
</div>
<div :if={@reviewing} id="best-move-panel" class="rounded-lg bg-canvas-raised p-3 text-sm">
<%= cond do %>
<% @review_blocked -> %>
<p class="text-muted">Best move unavailable here</p>
<p class="text-muted">{@review_blocked}</p>
<% @review_tablebase -> %>
<p class="text-muted font-semibold mb-1">Best move:</p>
<p class="text-success-text">{PlayCore.best_move_text(@review_tablebase) || "—"}</p>
<%= if played_ply = played_ply_at(@line, @review_index) do %>
<p class={["mt-1", grade_class(played_ply.grade)]}>Played: {played_ply.san}</p>
<% end %>
<% true -> %>
<p class="text-muted">No best move.</p>
<% end %>
</div>
<div id="move-list" class="flex-1 min-h-0 flex flex-col bg-canvas-raised rounded-lg p-3">
<% plies = display_plies(@reviewing, @line, @plies) %>
<p class="text-sm text-muted font-semibold mb-2">Moves:</p>
<div class="flex-1 overflow-y-auto">
<%= if plies == [] do %>
<p class="text-sm text-muted">No Moves</p>
<% else %>
<%= for {[white_ply, black_ply], move_no} <- move_rows(plies, @endgame.color) do %>
<div class="font-mono text-sm leading-6">
<span class="text-muted mr-2">{move_no}.</span>
<%= if white_ply do %>
<.ply
ply={white_ply}
reviewing={@reviewing}
review_index={@review_index}
result={@endgame.result}
/>
<% else %>
<span class="text-body">...</span>
<% end %>
<%= if black_ply do %>
<.ply
ply={black_ply}
reviewing={@reviewing}
review_index={@review_index}
result={@endgame.result}
/>
<% end %>
</div>
<% end %>
<% end %>
</div>
</div> </div>
<div class="flex flex-wrap gap-2"> <div class="flex flex-wrap gap-2">
<.button
:if={(@reviewing and @review_tablebase) && PlayCore.best_move_text(@review_tablebase)}
phx-click="play_best_line"
disabled={@awaiting_best_line}
>
Play best line
</.button>
<.button :if={@reviewing and @line != @plies} phx-click="back_to_game">
Back to game
</.button>
<.button <.button
:if={@status in [:solved, :failed] and not @reviewing} :if={@status in [:solved, :failed] and not @reviewing}
phx-click="review" phx-click="review"
@@ -164,24 +103,193 @@ defmodule ChesstrainerWeb.PlayComponents do
Next puzzle Next puzzle
</.button> </.button>
</div> </div>
</div>
<div :if={@reviewing} id="review-controls" class="flex flex-wrap gap-2"> <div class="relative w-48">
<.button phx-click="review_prev" disabled={@review_index <= 0}>←</.button> <div class="absolute inset-0 flex flex-col gap-3">
<.button phx-click="review_next" disabled={@review_index >= length(@line)}>→</.button> <%= if @reviewing do %>
<.button <div
:if={@review_tablebase && PlayCore.best_move_text(@review_tablebase)} id="best-move-panel"
phx-click="play_best_line" class="flex-1 min-h-0 overflow-y-auto rounded-lg bg-canvas-raised p-3 text-sm"
disabled={@awaiting_best_line} >
> <%= cond do %>
Play best line <% @review_blocked -> %>
</.button> <p class="text-muted">Best move unavailable here</p>
<.button :if={@line != @plies} phx-click="back_to_game">Back to game</.button> <p class="text-muted">{@review_blocked}</p>
<% @review_tablebase -> %>
<p class="text-muted font-semibold mb-1">Best move:</p>
<p class="text-success-text">{PlayCore.best_move_text(@review_tablebase) || "—"}</p>
<%= if played_ply = played_ply_at(@line, @review_index) do %>
<p class={["mt-1", grade_class(played_ply.grade)]}>Played: {played_ply.san}</p>
<% end %>
<.tablebase_options tablebase={@review_tablebase} />
<% true -> %>
<p class="text-muted">No best move.</p>
<% end %>
</div>
<% else %>
<div class="rounded-lg bg-canvas-raised p-3 text-sm">
<p class="flex items-center justify-between gap-2 font-semibold">
<span>{turn_label(@status, @awaiting_reply)}</span>
<span class="text-xs font-normal text-muted">
You play {colour_name(@endgame.color)}
</span>
</p>
</div>
<div class="rounded-lg bg-canvas-raised p-3 text-sm">
<%= cond do %>
<% @status == :loading -> %>
<p class="text-muted">Loading tablebase…</p>
<% @status == :blocked -> %>
<p class="font-semibold text-error">Tablebase unavailable</p>
<p class="text-error">{@blocked_reason}</p>
<% @status == :solved -> %>
<p class="font-semibold text-success-text">
{if @endgame.result == :draw, do: "Draw held!", else: "Solved!"}
</p>
<% @status == :failed -> %>
<p class="font-semibold text-error">Failed</p>
<p class="text-error">
{if @endgame.result == :draw,
do: "That move loses the draw.",
else: "That move throws away the win."}
</p>
<%= if @best_move && @plies != [] do %>
<p class="text-muted">
You played {List.last(@plies).san}; best was: {@best_move}
</p>
<% end %>
<% @awaiting_reply -> %>
<p class="text-muted">Opponent is replying…</p>
<% @last_grade == :optimal -> %>
<p class="font-semibold text-success-text">Optimal move</p>
<% @last_grade == :winning -> %>
<p class="font-semibold text-warning">
{if @endgame.result == :draw,
do: "Keeps the draw — but not the sharpest",
else: "Winning — but not the sharpest"}
</p>
<% @last_grade == :losing -> %>
<p class="font-semibold text-error">
{if @endgame.result == :draw,
do: "Losing move — this loses the draw",
else: "Losing move — this throws away the win"}
</p>
<% @last_grade == :unknown -> %>
<p class="font-semibold text-muted">Could not grade that move</p>
<% true -> %>
<p class="text-muted">Make a move to have it graded.</p>
<% end %>
<p :if={@status in [:solved, :failed]} class="mt-1 text-xs text-muted">
Puzzle rating: {round(@endgame.rating)}
</p>
</div>
<div
id="move-list"
class="flex-1 min-h-0 flex flex-col bg-canvas-raised rounded-lg p-3"
>
<% plies = display_plies(@reviewing, @line, @plies) %>
<p class="text-sm text-muted font-semibold mb-2">Moves:</p>
<div class="flex-1 overflow-y-auto">
<%= if plies == [] do %>
<p class="text-sm text-muted">No Moves</p>
<% else %>
<%= for {[white_ply, black_ply], move_no} <- move_rows(plies, @endgame.color) do %>
<div class="font-mono text-sm leading-6">
<span class="text-muted mr-2">{move_no}.</span>
<%= if white_ply do %>
<.ply
ply={white_ply}
reviewing={@reviewing}
review_index={@review_index}
result={@endgame.result}
/>
<% else %>
<span class="text-body">...</span>
<% end %>
<%= if black_ply do %>
<.ply
ply={black_ply}
reviewing={@reviewing}
review_index={@review_index}
result={@endgame.result}
/>
<% end %>
</div>
<% end %>
<% end %>
</div>
</div>
<% end %>
</div> </div>
</div> </div>
</div> </div>
""" """
end end
attr :tablebase, :any, required: true
# The reviewed position's moves grouped like lichess's tablebase explorer:
# each heading is the outcome for the side to move, one table per outcome.
defp tablebase_options(assigns) do
assigns = assign(assigns, :groups, tablebase_groups(assigns.tablebase))
~H"""
<div :if={@groups != []} class="mt-3 border-t border-base-200 pt-2">
<p class="text-muted font-semibold mb-1">Tablebase</p>
<div :for={{label, class, moves} <- @groups} class="mt-2 first:mt-0">
<p class={["text-xs font-semibold", class]}>{label}</p>
<table class="w-full text-left text-xs font-mono">
<tbody>
<tr
:for={move <- moves}
phx-click="review_move"
phx-value-uci={move.uci}
class="cursor-pointer hover:bg-base-200"
title={"Play #{move.san}"}
>
<td class={["py-0.5 pr-2", class]}>{move.san}</td>
<td class="py-0.5 text-right text-muted" title="Distance to zeroing (DTZ)">
{dtz_text(move)}
</td>
</tr>
</tbody>
</table>
</div>
</div>
"""
end
defp tablebase_groups(%{moves: moves}) when is_list(moves) do
[
{"Winning", "text-success-text", :win},
{"Drawn", "text-muted", :draw},
{"Losing", "text-error", :loss},
{"Unknown", "text-muted", :unknown}
]
|> Enum.flat_map(fn {label, class, outcome} ->
case Enum.filter(moves, &(mover_outcome(&1.category) == outcome)) do
[] -> []
moves -> [{label, class, moves}]
end
end)
end
defp tablebase_groups(_tablebase), do: []
# A move's category is the outcome for the side to move *after* the move, so
# the mover's outcome is its flip.
defp mover_outcome(:loss), do: :win
defp mover_outcome(:win), do: :loss
defp mover_outcome(:draw), do: :draw
defp mover_outcome(_), do: :unknown
defp dtz_text(%{dtz: nil}), do: ""
defp dtz_text(%{dtz: dtz}), do: "DTZ #{abs(dtz)}"
attr :ply, :map, required: true attr :ply, :map, required: true
attr :reviewing, :boolean, required: true attr :reviewing, :boolean, required: true
attr :review_index, :integer, required: true attr :review_index, :integer, required: true
@@ -242,15 +350,17 @@ defmodule ChesstrainerWeb.PlayComponents do
defp played_ply_at(line, review_index) do defp played_ply_at(line, review_index) do
case Enum.at(line, review_index) do case Enum.at(line, review_index) do
%{best_line: true} -> nil %{analysis: true} -> nil
ply -> ply ply -> ply
end end
end end
defp ply_class(%{best_line: true}), do: "text-info italic" defp ply_class(%{best_line: true}), do: "text-info italic"
defp ply_class(%{analysis: true}), do: "text-info"
defp ply_class(ply), do: grade_class(ply.grade) defp ply_class(ply), do: grade_class(ply.grade)
defp ply_title(%{best_line: true}, _result), do: "Best line" defp ply_title(%{best_line: true}, _result), do: "Best line"
defp ply_title(%{analysis: true}, _result), do: "Tablebase move"
defp ply_title(ply, result), do: grade_label(ply.grade, result) defp ply_title(ply, result), do: grade_label(ply.grade, result)
defp grade_class(:optimal), do: "text-success-text" defp grade_class(:optimal), do: "text-success-text"
@@ -167,6 +167,12 @@ defmodule ChesstrainerWeb.EndgameLive.GuestTrain do
def handle_event("review_step", %{"index" => index}, socket), def handle_event("review_step", %{"index" => index}, socket),
do: PlayCore.review_step(socket, index) do: PlayCore.review_step(socket, index)
def handle_event("review_start", _params, socket), do: PlayCore.review_start(socket)
def handle_event("review_end", _params, socket), do: PlayCore.review_end(socket)
def handle_event("review_move", params, socket), do: PlayCore.review_move(socket, params)
def handle_event("play_best_line", _params, socket), do: PlayCore.play_best_line(socket) def handle_event("play_best_line", _params, socket), do: PlayCore.play_best_line(socket)
def handle_event("best_line_move_applied", params, socket), def handle_event("best_line_move_applied", params, socket),
@@ -85,6 +85,12 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
def handle_event("review_step", %{"index" => index}, socket), def handle_event("review_step", %{"index" => index}, socket),
do: PlayCore.review_step(socket, index) do: PlayCore.review_step(socket, index)
def handle_event("review_start", _params, socket), do: PlayCore.review_start(socket)
def handle_event("review_end", _params, socket), do: PlayCore.review_end(socket)
def handle_event("review_move", params, socket), do: PlayCore.review_move(socket, params)
def handle_event("play_best_line", _params, socket), do: PlayCore.play_best_line(socket) def handle_event("play_best_line", _params, socket), do: PlayCore.play_best_line(socket)
def handle_event("best_line_move_applied", params, socket), def handle_event("best_line_move_applied", params, socket),
@@ -46,7 +46,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
|> assign(:review_tablebase, nil) |> assign(:review_tablebase, nil)
|> assign(:review_blocked, nil) |> assign(:review_blocked, nil)
|> assign(:awaiting_best_line, false) |> assign(:awaiting_best_line, false)
|> assign(:pending_best_move, nil) |> assign(:pending_move, nil)
|> assign(:last_san, "None yet") |> assign(:last_san, "None yet")
|> assign(:last_from_to, "None yet") |> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil) |> assign(:last_grade, nil)
@@ -135,7 +135,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
|> assign(:review_tablebase, nil) |> assign(:review_tablebase, nil)
|> assign(:review_blocked, nil) |> assign(:review_blocked, nil)
|> assign(:awaiting_best_line, false) |> assign(:awaiting_best_line, false)
|> assign(:pending_best_move, nil) |> assign(:pending_move, nil)
|> assign(:last_san, "None yet") |> assign(:last_san, "None yet")
|> assign(:last_from_to, "None yet") |> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil) |> assign(:last_grade, nil)
@@ -162,6 +162,10 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
def review_next(socket), do: step_review(socket, 1) def review_next(socket), do: step_review(socket, 1)
def review_start(socket), do: review_step(socket, 0)
def review_end(socket), do: review_step(socket, length(socket.assigns.line))
def review_step(socket, index) do def review_step(socket, index) do
if socket.assigns.reviewing do if socket.assigns.reviewing do
last = length(socket.assigns.line) last = length(socket.assigns.line)
@@ -177,21 +181,41 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
with true <- socket.assigns.reviewing, with true <- socket.assigns.reviewing,
%Tablebase{} = tablebase <- socket.assigns.review_tablebase, %Tablebase{} = tablebase <- socket.assigns.review_tablebase,
%Tablebase.Move{} = move <- pick_best_move(tablebase) do %Tablebase.Move{} = move <- pick_best_move(tablebase) do
# Branch the review line at the current position, then play one best move. play_review_move(socket, move, true)
{:noreply,
socket
|> assign(:line, Enum.take(socket.assigns.line, socket.assigns.review_index))
|> assign(:awaiting_best_line, true)
|> assign(:pending_best_move, move)
|> push_event("best_line_move", reply_payload(move))}
else else
_ -> {:noreply, socket} _ -> {:noreply, socket}
end end
end end
@doc """
Plays one tablebase move from the reviewed position, branching the line.
The move comes from a `phx-value-uci` on the tablebase table.
"""
def review_move(socket, %{"uci" => uci}) do
with true <- socket.assigns.reviewing,
%Tablebase{} = tablebase <- socket.assigns.review_tablebase,
%Tablebase.Move{} = move <- find_move_by_uci(tablebase, uci) do
play_review_move(socket, move, false)
else
_ -> {:noreply, socket}
end
end
# Branch the review line at the current position, then ask the board to play
# the move; `best_line_move_applied/2` appends it once chess.js confirms it.
defp play_review_move(socket, move, best_line?) do
{:noreply,
socket
|> assign(:line, Enum.take(socket.assigns.line, socket.assigns.review_index))
|> assign(:awaiting_best_line, true)
|> assign(:pending_move, %{move: move, best_line: best_line?})
|> push_event("best_line_move", reply_payload(move))}
end
def best_line_move_applied(socket, %{"fen" => fen}) do def best_line_move_applied(socket, %{"fen" => fen}) do
if socket.assigns.awaiting_best_line do if socket.assigns.awaiting_best_line do
move = socket.assigns.pending_best_move %{move: move, best_line: best_line?} = socket.assigns.pending_move
line = line =
socket.assigns.line ++ socket.assigns.line ++
@@ -201,7 +225,8 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
san: move.san, san: move.san,
fen_after: fen, fen_after: fen,
grade: nil, grade: nil,
best_line: true analysis: true,
best_line: best_line?
} }
] ]
@@ -209,7 +234,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
socket socket
|> assign(:line, line) |> assign(:line, line)
|> assign(:awaiting_best_line, false) |> assign(:awaiting_best_line, false)
|> assign(:pending_best_move, nil) |> assign(:pending_move, nil)
|> set_review_index(length(line)) |> set_review_index(length(line))
{:noreply, push_review_position(socket)} {:noreply, push_review_position(socket)}
@@ -489,6 +514,12 @@ defmodule ChesstrainerWeb.EndgameLive.PlayCore do
defp find_move(_tablebase, _from, _to, _promotion), do: nil defp find_move(_tablebase, _from, _to, _promotion), do: nil
defp find_move_by_uci(%Tablebase{moves: moves}, uci) when is_list(moves) do
Enum.find(moves, &(&1.uci == uci))
end
defp find_move_by_uci(_tablebase, _uci), do: nil
# Compare only the board and side to move: chess.js may normalise the rest # Compare only the board and side to move: chess.js may normalise the rest
# (castling/en-passant/halfmove/fullmove) differently from the stored FEN. # (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 same_position?(fen_a, fen_b), do: position_key(fen_a) == position_key(fen_b)
@@ -269,6 +269,12 @@ defmodule ChesstrainerWeb.EndgameLive.Train do
def handle_event("review_step", %{"index" => index}, socket), def handle_event("review_step", %{"index" => index}, socket),
do: PlayCore.review_step(socket, index) do: PlayCore.review_step(socket, index)
def handle_event("review_start", _params, socket), do: PlayCore.review_start(socket)
def handle_event("review_end", _params, socket), do: PlayCore.review_end(socket)
def handle_event("review_move", params, socket), do: PlayCore.review_move(socket, params)
def handle_event("play_best_line", _params, socket), do: PlayCore.play_best_line(socket) def handle_event("play_best_line", _params, socket), do: PlayCore.play_best_line(socket)
def handle_event("best_line_move_applied", params, socket), def handle_event("best_line_move_applied", params, socket),
@@ -80,7 +80,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
# Plays one optimal move, applies the opponent's reply, then a losing move, # Plays one optimal move, applies the opponent's reply, then a losing move,
# leaving a three-ply failed attempt to review. # leaving a three-ply failed attempt to review.
defp seeded_attempt(conn) do defp seeded_attempt(conn, start_moves \\ grading_moves()) do
endgame = endgame_fixture() endgame = endgame_fixture()
# The tablebase cache is keyed by position (clocks ignored), so these must # The tablebase cache is keyed by position (clocks ignored), so these must
@@ -91,7 +91,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :loss, dtz: -3} reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :loss, dtz: -3}
losing_reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :draw, dtz: 0} losing_reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :draw, dtz: 0}
seed_tablebase(endgame.fen, moves: grading_moves()) seed_tablebase(endgame.fen, moves: start_moves)
seed_tablebase(after_first, category: :loss, moves: [reply]) seed_tablebase(after_first, category: :loss, moves: [reply])
seed_tablebase(after_reply, category: :win, moves: grading_moves()) seed_tablebase(after_reply, category: :win, moves: grading_moves())
seed_tablebase(after_losing, category: :draw, moves: [losing_reply]) seed_tablebase(after_losing, category: :draw, moves: [losing_reply])
@@ -791,20 +791,35 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert back == fens.after_first assert back == fens.after_first
end end
test "clicking a ply jumps to its position", %{conn: conn} do test "hides the result panels and move list while reviewing", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
assert has_element?(view, "#best-move-panel")
refute has_element?(view, "#move-list")
refute render(view) =~ "Failed"
refute render(view) =~ "Solved!"
end
test "jumps to the start and end of the reviewed line", %{conn: conn} do
{view, fens} = seeded_attempt(conn) {view, fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click() view |> element("button", "Review") |> render_click()
%{proxy: {ref, _topic, _}} = view %{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "review_position", %{fen: after_losing}}}, 100
assert after_losing == fens.after_losing
# Consume the position pushed on entering review. view |> element("#review-start") |> render_click()
assert_receive {^ref, {:push_event, "review_position", _payload}}, 100
view |> element("button", "Ke7") |> render_click() assert_receive {^ref, {:push_event, "review_position", %{fen: start}}}, 100
assert start == fens.start
assert_receive {^ref, {:push_event, "review_position", %{fen: fen}}}, 100 view |> element("#review-end") |> render_click()
assert fen == fens.after_reply
assert_receive {^ref, {:push_event, "review_position", %{fen: at_end}}}, 100
assert at_end == fens.after_losing
end end
test "try again exits review and starts a fresh attempt", %{conn: conn} do test "try again exits review and starts a fresh attempt", %{conn: conn} do
@@ -857,6 +872,56 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert panel =~ "Played: Qd4" assert panel =~ "Played: Qd4"
end end
test "groups tablebase moves by outcome during review", %{conn: conn} do
start_moves = [
%Tablebase.Move{uci: "d1d7", san: "Qd7+", category: :loss, dtz: -1},
%Tablebase.Move{uci: "d1d4", san: "Qd4", category: :draw, dtz: 0},
%Tablebase.Move{uci: "d1d8", san: "Qd8", category: :win, dtz: 5}
]
{view, _fens} = seeded_attempt(conn, start_moves)
view |> element("button", "Review") |> render_click()
render_hook(view, "review_step", %{"index" => "0"})
panel = view |> element("#best-move-panel") |> render()
assert panel =~ ~r/Winning.*Qd7\+.*Drawn.*Qd4.*Losing.*Qd8/s
assert panel =~ "DTZ 1"
assert panel =~ "DTZ 5"
end
test "clicking a tablebase move plays it from the reviewed position", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
render_hook(view, "review_step", %{"index" => "2"})
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "review_position", _}}, 100
assert_receive {^ref, {:push_event, "review_position", _}}, 100
view |> element("#best-move-panel tr[phx-value-uci='d1d5']") |> render_click()
assert_receive {^ref, {:push_event, "best_line_move", %{from: "d1", to: "d5"}}}, 100
best_after = "8/8/8/8/8/8/8/6K1 b - - 1 1"
seed_tablebase(best_after,
category: :draw,
moves: [%Tablebase.Move{uci: "g1g2", san: "Kg2", category: :draw, dtz: 0}]
)
render_hook(view, "best_line_move_applied", %{"fen" => best_after})
assert_receive {^ref, {:push_event, "review_position", %{fen: ^best_after}}}, 100
panel = view |> element("#best-move-panel") |> render()
assert panel =~ "Kg2"
assert has_element?(view, "button", "Back to game")
refute has_element?(view, "#move-list")
end
test "summarises the failing move and the best alternative", %{conn: conn} do test "summarises the failing move and the best alternative", %{conn: conn} do
{view, _fens} = seeded_attempt(conn) {view, _fens} = seeded_attempt(conn)
@@ -864,7 +929,7 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
end end
test "play best line branches and steps the optimal continuation", %{conn: conn} do test "play best line branches and steps the optimal continuation", %{conn: conn} do
{view, _fens} = seeded_attempt(conn) {view, fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click() view |> element("button", "Review") |> render_click()
render_hook(view, "review_prev", %{}) render_hook(view, "review_prev", %{})
@@ -878,20 +943,25 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert_receive {^ref, {:push_event, "best_line_move", %{from: "d1", to: "d7"}}}, 100 assert_receive {^ref, {:push_event, "best_line_move", %{from: "d1", to: "d7"}}}, 100
best_after = "8/8/8/8/8/8/8/8 w - - 2 1" best_after = "8/8/8/8/8/8/8/8 w - - 2 1"
seed_tablebase(best_after, category: :draw, moves: [])
seed_tablebase(best_after,
category: :draw,
moves: [%Tablebase.Move{uci: "d8d7", san: "Qd7", category: :draw, dtz: 0}]
)
render_hook(view, "best_line_move_applied", %{"fen" => best_after}) render_hook(view, "best_line_move_applied", %{"fen" => best_after})
assert_receive {^ref, {:push_event, "review_position", %{fen: ^best_after}}}, 100 assert_receive {^ref, {:push_event, "review_position", %{fen: ^best_after}}}, 100
moves = view |> element("#move-list") |> render() panel = view |> element("#best-move-panel") |> render()
refute moves =~ "Qd4" assert panel =~ "Qd7"
assert moves =~ "Qd7+" assert has_element?(view, "button", "Back to game")
assert moves =~ ~s(title="Best line")
view |> element("button", "Back to game") |> render_click() view |> element("button", "Back to game") |> render_click()
moves = view |> element("#move-list") |> render() assert_receive {^ref, {:push_event, "review_position", %{fen: fen}}}, 100
assert moves =~ "Qd4" assert fen == fens.after_losing
refute has_element?(view, "button", "Back to game")
end end
test "degrades gracefully and reuses played-position snapshots", %{conn: conn} do test "degrades gracefully and reuses played-position snapshots", %{conn: conn} do