Compare commits

..
4 Commits
Author SHA1 Message Date
owenrees fa71783e55 Show best moves and the optimal line in review
Closes #19
2026-11-02 21:45:06 +01:00
owenrees 36548ece8d Add the replay plan 2026-11-02 21:26:20 +01:00
owenrees 1e62b13d94 Show the full game and review it after an attempt
Closes #18
2026-11-02 21:26:20 +01:00
owenrees 6d0d750ca7 Default new endgames to rating 1500
Closes #17
2026-11-02 21:26:19 +01:00
7 changed files with 900 additions and 65 deletions
+72
View File
@@ -6,11 +6,36 @@ export const ChessBoard = {
this.chess = new Chess();
this.ground = null;
this.playerColor = "white";
this.reviewing = false;
this.handleEvent("init_board", (payload) => {
this.reviewing = false;
this.initBoard(payload);
});
this.handleEvent("review_position", ({ fen }) => {
this.reviewing = true;
this.showReviewPosition(fen);
});
this.handleEvent("best_line_move", ({ from, to, promotion, san }) => {
this.applyBestLineMove({ from, to, promotion, san });
});
this.handleKeyDown = (event) => {
if (!this.reviewing) return;
if (event.key === "ArrowLeft") {
event.preventDefault();
this.pushEvent("review_prev", {});
} else if (event.key === "ArrowRight") {
event.preventDefault();
this.pushEvent("review_next", {});
}
};
window.addEventListener("keydown", this.handleKeyDown);
this.handleEvent("set_fen", ({ fen }) => {
try {
this.chess.load(fen);
@@ -53,6 +78,53 @@ export const ChessBoard = {
});
},
destroyed() {
window.removeEventListener("keydown", this.handleKeyDown);
},
showReviewPosition(fen) {
if (!this.ground) return;
try {
this.chess.load(fen);
} catch (error) {
console.error("Invalid review FEN from server:", fen, error);
return;
}
const turnColor = this.chess.turn() === "w" ? "white" : "black";
this.ground.set({
fen: this.chess.fen(),
turnColor,
movable: { color: null, dests: new Map() },
});
},
applyBestLineMove({ from, to, promotion, san }) {
const move = promotion
? this.chess.move({ from, to, promotion })
: this.chess.move({ from, to });
if (!move) {
console.error("Best-line move rejected by chess.js", { from, to, promotion, san });
return;
}
const turnColor = this.chess.turn() === "w" ? "white" : "black";
this.ground.set({
fen: this.chess.fen(),
turnColor,
movable: { color: null, dests: new Map() },
});
this.pushEvent("best_line_move_applied", {
fen: this.chess.fen(),
san: move.san,
});
},
initBoard({ fen, orientation, player_color, blocked }) {
try {
this.chess.load(fen);
+89
View File
@@ -0,0 +1,89 @@
# Replay: post-attempt review of a played puzzle
Goal: after a puzzle ends (solved or failed), let the user step through the game
they just played, see the best move at each position, and — where they went
wrong — follow the optimal line to see how it should have gone.
## Definition of done
- On `:solved`/`:failed`, an explicit **Review** button appears alongside
"Try again". Clicking it enters read-only review mode.
- The move list shows the **full game** — the user's moves *and* the opponent's
replies — with the user's plies color-coded by grade (optimal / winning /
losing), result-aware for draw puzzles.
- Clicking any ply (or using prev/next) repositions the board to that position.
- At every reviewed position, the best move(s) for the side to move are shown.
- On a failed attempt, the losing move is highlighted with the best alternative,
and **"Play best line"** steps through the tablebase's optimal continuation.
- Review is **ephemeral**: it lives in socket `assigns` and is lost on refresh.
- Review is **read-only**: no resuming play from a replayed position.
## Decisions (see GLOSSARY.md, docs/adr/)
- Review is entered via an explicit button, not auto-entered on finish.
- **LiveView owns the move history**; the board is a pure FEN display driven by
the existing `set_fen` hook (our own solution now; see "Future" below).
- The played line is recorded with a per-ply tablebase snapshot, so best moves
on the played line need no re-query. Off-line "Play best line" positions fetch
on demand and degrade gracefully under rate-limit/cooldown.
- Review is ephemeral and read-only; "Try again" starts a fresh attempt.
## Work breakdown
### 0. Rating default (independent)
- Add `default: 1500` to `field :rating` in `lib/chesstrainer/endgames/endgame.ex`
(matches the DB migration default). The new-endgame form then auto-fills 1500.
### 1. Record the full game during play (`EndgameLive.Play`)
- Replace `move_list` (SAN strings) with a ply list; each ply records
`{san, uci, fen_after, side, grade, tablebase_snapshot}`.
- Append the opponent's reply (currently discarded in `opponent_reply_applied` /
`start_opponent_reply`) to the same list.
- Snapshot the `%Tablebase{}` used at each position (the one already fetched for
grading / reply selection) onto its ply.
### 2. Review state + navigation
- Add `:review` status and a current-ply index; a "Review" button transitions
`:solved`/`:failed` → review mode.
- Move list: render full game, each ply `phx-click`-able; prev/next controls and
arrow-key navigation.
- On ply selection, push that ply's FEN to the board via the existing `set_fen`
handler.
### 3. Best-move panel
- At the reviewed position: show the best move(s) from the ply's snapshot
(reuse `best_move_text/1` logic, extended to a list).
- On the failing ply: highlight it red, show "You played X; best was Y".
### 4. "Play best line" (optimal continuation)
- From any reviewed position, offer "Play best line": step forward through the
tablebase's best moves, fetching `Tablebase.new/1` on demand for positions off
the played line.
- On `{:cooldown, _}` / `{:error, _}`, show a graceful "tablebase unavailable
here" note and stop the line, without breaking the rest of review.
### 5. Move-list rendering
- Full game with grade colors; draw-puzzle-aware labels ("keeps the draw" /
"throws away the draw" rather than "winning"/"losing").
## Future: chessground-native move list (Approach 2)
Our current solution keeps the move history in LiveView and treats the board as
a FEN display. A later migration to the lichess-style approach would:
- Feed chess.js the full move history and run chessground in `viewOnly` mode.
- On ply click, read `chess.history({verbose:true})[i]` and `ground.set({fen})`
client-side, removing the per-ply server round-trip.
The move-list component itself is not part of chessground (it lives in lichess's
`ui`). **Licensing**: chessground is GPL-3.0-or-later (already a dependency, so
reusing more of it adds no new obligation). lichess's `ui` is AGPL-3.0-or-later
(network copyleft — obligations trigger merely by serving the app). So the
migration stays license-clean only if we build the move list ourselves and do
not vendor lichess `ui`. This reading is not legal advice.
## Out of scope (deferred)
- Persisting reviews / attempt history to the DB.
- Resuming play from a replayed position.
- Auth and per-user Glicko ratings (unchanged from MVP).
+1 -1
View File
@@ -17,7 +17,7 @@ defmodule Chesstrainer.Endgames.Endgame do
field :message, :string
field :notes, :string
field :result, Ecto.Enum, values: [:win, :loss, :draw]
field :rating, :integer
field :rating, :integer, default: 1500
field :rating_deviation, :integer
field :times_attempted, :integer
field :times_solved, :integer
+403 -64
View File
@@ -50,17 +50,27 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
do: "That move loses the draw.",
else: "That move throws away the win."}
</p>
<%= if @best_move do %>
<p class="text-gray-600">Best was: {@best_move}</p>
<%= if @best_move && @plies != [] do %>
<p class="text-gray-600">
You played {List.last(@plies).san}; best was: {@best_move}
</p>
<% end %>
<% @awaiting_reply -> %>
<p class="text-gray-500">Opponent is replying…</p>
<% @last_grade == :optimal -> %>
<p class="font-semibold text-emerald-600">Optimal move</p>
<% @last_grade == :winning -> %>
<p class="font-semibold text-amber-600">Winning — but not the sharpest</p>
<p class="font-semibold text-amber-600">
{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-red-600">Losing move — this throws away the win</p>
<p class="font-semibold text-red-600">
{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-gray-600">Could not grade that move</p>
<% true -> %>
@@ -68,18 +78,49 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
<% end %>
</div>
<div class="flex-1 min-h-0 flex flex-col bg-white rounded-lg p-3">
<div :if={@reviewing} id="best-move-panel" class="rounded-lg bg-white p-3 text-sm">
<%= cond do %>
<% @review_blocked -> %>
<p class="text-gray-500">Best move unavailable here</p>
<p class="text-gray-400">{@review_blocked}</p>
<% @review_tablebase -> %>
<p class="text-gray-600 font-semibold mb-1">Best move:</p>
<p class="text-emerald-600">{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-gray-500">No best move.</p>
<% end %>
</div>
<div id="move-list" class="flex-1 min-h-0 flex flex-col bg-white rounded-lg p-3">
<% plies = display_plies(@reviewing, @line, @plies) %>
<p class="text-sm text-gray-600 font-semibold mb-2">Moves:</p>
<div class="flex-1 overflow-y-auto">
<%= if @move_list == [] do %>
<%= if plies == [] do %>
<p class="text-sm text-gray-500">No Moves</p>
<% else %>
<%= for {[white_move, black_move], i} <- format_move_pairs(@move_list, @endgame.color) do %>
<%= for {[white_ply, black_ply], move_no} <- move_rows(plies, @endgame.color) do %>
<div class="font-mono text-sm leading-6">
<span class="text-gray-500 mr-2">{i}.</span>
<span class="text-gray-900">{white_move || "..."}</span>
<%= if black_move do %>
<span class="text-gray-900 ml-2">{black_move}</span>
<span class="text-gray-500 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-gray-900">...</span>
<% end %>
<%= if black_ply do %>
<.ply
ply={black_ply}
reviewing={@reviewing}
review_index={@review_index}
result={@endgame.result}
/>
<% end %>
</div>
<% end %>
@@ -87,12 +128,31 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
</div>
</div>
<div>
<div class="flex gap-2">
<.button
:if={@status in [:solved, :failed] and not @reviewing}
phx-click="review"
>
<.icon name="hero-eye" /> Review
</.button>
<.button phx-click="reset" variant="primary">
<.icon name="hero-arrow-path" />
{if @status in [:solved, :failed], do: "Try again", else: "Reset"}
</.button>
</div>
<div :if={@reviewing} id="review-controls" class="flex flex-wrap gap-2">
<.button phx-click="review_prev" disabled={@review_index <= 0}>←</.button>
<.button phx-click="review_next" disabled={@review_index >= length(@line)}>→</.button>
<.button
:if={@review_tablebase && best_move_text(@review_tablebase)}
phx-click="play_best_line"
disabled={@awaiting_best_line}
>
Play best line
</.button>
<.button :if={@line != @plies} phx-click="back_to_game">Back to game</.button>
</div>
</div>
</div>
</Layouts.app>
@@ -112,7 +172,16 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|> assign(:status, :loading)
|> assign(:blocked_reason, nil)
|> assign(:best_move, nil)
|> assign(:move_list, [])
|> assign(:plies, [])
|> assign(:reviewing, false)
|> assign(:review_index, 0)
|> assign(:pending_reply, nil)
|> assign(:snapshots, %{})
|> assign(:line, [])
|> assign(:review_tablebase, nil)
|> assign(:review_blocked, nil)
|> assign(:awaiting_best_line, false)
|> assign(:pending_best_move, nil)
|> assign(:last_san, "None yet")
|> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil)
@@ -154,27 +223,31 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
not socket.assigns.awaiting_reply ->
{:noreply, socket}
draw and socket.assigns.endgame.result == :draw ->
solve_attempt(socket)
true ->
case Tablebase.new(fen) do
{:ok, tablebase} ->
{:noreply,
socket
|> assign(:fen, fen)
|> assign(:tablebase, tablebase)
|> assign(:awaiting_reply, false)
|> assign(:status, :playing)
|> assign(:blocked_reason, nil)
|> push_event("resume_board", %{})}
socket = record_opponent_ply(socket, fen, params["san"])
other ->
{:noreply,
socket
|> assign(:awaiting_reply, false)
|> assign(:status, :blocked)
|> assign(:blocked_reason, blocked_reason(other))}
if draw and socket.assigns.endgame.result == :draw do
solve_attempt(socket)
else
case Tablebase.new(fen) do
{:ok, tablebase} ->
{:noreply,
socket
|> assign(:fen, fen)
|> assign(:tablebase, tablebase)
|> snapshot(fen, tablebase)
|> assign(:awaiting_reply, false)
|> assign(:status, :playing)
|> assign(:blocked_reason, nil)
|> push_event("resume_board", %{})}
other ->
{:noreply,
socket
|> assign(:awaiting_reply, false)
|> assign(:status, :blocked)
|> assign(:blocked_reason, blocked_reason(other))}
end
end
end
end
@@ -191,7 +264,16 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
def handle_event("reset", _params, socket) do
socket =
socket
|> assign(:move_list, [])
|> assign(:plies, [])
|> assign(:reviewing, false)
|> assign(:review_index, 0)
|> assign(:pending_reply, nil)
|> assign(:snapshots, %{})
|> assign(:line, [])
|> assign(:review_tablebase, nil)
|> assign(:review_blocked, nil)
|> assign(:awaiting_best_line, false)
|> assign(:pending_best_move, nil)
|> assign(:last_san, "None yet")
|> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil)
@@ -199,14 +281,229 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
{:noreply, load_attempt(socket)}
end
def format_move_pairs(move_list, color) do
moves = if color in [:black, "black"], do: [nil | move_list], else: move_list
def handle_event("review", _params, socket) do
if socket.assigns.status in [:solved, :failed] do
socket =
socket
|> assign(:reviewing, true)
|> assign(:line, socket.assigns.plies)
|> set_review_index(length(socket.assigns.plies))
moves
{:noreply, push_review_position(socket)}
else
{:noreply, socket}
end
end
def handle_event("review_prev", _params, socket), do: step_review(socket, -1)
def handle_event("review_next", _params, socket), do: step_review(socket, 1)
def handle_event("review_step", %{"index" => index}, socket) do
if socket.assigns.reviewing do
last = length(socket.assigns.line)
index = parse_index(index) |> max(0) |> min(last)
{:noreply, push_review_position(set_review_index(socket, index))}
else
{:noreply, socket}
end
end
def handle_event("play_best_line", _params, socket) do
with true <- socket.assigns.reviewing,
%Tablebase{} = tablebase <- socket.assigns.review_tablebase,
%Tablebase.Move{} = move <- pick_best_move(tablebase) do
# Branch the review line at the current position, then play one best move.
{: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
_ -> {:noreply, socket}
end
end
def handle_event("best_line_move_applied", %{"fen" => fen}, socket) do
if socket.assigns.awaiting_best_line do
move = socket.assigns.pending_best_move
line =
socket.assigns.line ++
[
%{
index: length(socket.assigns.line),
san: move.san,
fen_after: fen,
grade: nil,
best_line: true
}
]
socket =
socket
|> assign(:line, line)
|> assign(:awaiting_best_line, false)
|> assign(:pending_best_move, nil)
|> set_review_index(length(line))
{:noreply, push_review_position(socket)}
else
{:noreply, socket}
end
end
def handle_event("back_to_game", _params, socket) do
if socket.assigns.reviewing do
socket =
socket
|> assign(:line, socket.assigns.plies)
|> set_review_index(length(socket.assigns.plies))
{:noreply, push_review_position(socket)}
else
{:noreply, socket}
end
end
attr :ply, :map, required: true
attr :reviewing, :boolean, required: true
attr :review_index, :integer, required: true
attr :result, :atom, required: true
defp ply(assigns) do
~H"""
<%= if @reviewing do %>
<button
type="button"
phx-click="review_step"
phx-value-index={@ply.index + 1}
class={[
"ml-2",
ply_class(@ply),
current_ply?(@ply, @review_index) && "underline"
]}
title={ply_title(@ply, @result)}
data-grade={@ply.grade}
>
{@ply.san}
</button>
<% else %>
<span
class={["ml-2", ply_class(@ply)]}
title={ply_title(@ply, @result)}
data-grade={@ply.grade}
>
{@ply.san}
</span>
<% end %>
"""
end
defp move_rows(plies, color) do
padded = if color in [:black, "black"], do: [nil | plies], else: plies
padded
|> Enum.chunk_every(2, 2, [nil])
|> Enum.with_index(1)
end
defp positions(start_fen, plies), do: [start_fen | Enum.map(plies, & &1.fen_after)]
defp display_plies(true, line, _plies), do: line
defp display_plies(false, _line, plies), do: plies
defp push_review_position(socket) do
fen =
socket.assigns.endgame.fen
|> positions(socket.assigns.line)
|> Enum.at(socket.assigns.review_index)
push_event(socket, "review_position", %{fen: fen})
end
defp set_review_index(socket, index) do
socket
|> assign(:review_index, index)
|> update_review_tablebase()
end
defp update_review_tablebase(socket) do
fen =
socket.assigns.endgame.fen
|> positions(socket.assigns.line)
|> Enum.at(socket.assigns.review_index)
case snapshot_or_fetch(socket, fen) do
{:ok, tablebase, socket} ->
assign(socket, review_tablebase: tablebase, review_blocked: nil)
{:unavailable, reason, socket} ->
assign(socket, review_tablebase: nil, review_blocked: reason)
end
end
defp snapshot_or_fetch(socket, fen) do
case Map.fetch(socket.assigns.snapshots, fen) do
{:ok, tablebase} ->
{:ok, tablebase, socket}
:error ->
case Tablebase.new(fen) do
{:ok, tablebase} -> {:ok, tablebase, snapshot(socket, fen, tablebase)}
other -> {:unavailable, blocked_reason(other), socket}
end
end
end
defp snapshot(socket, fen, tablebase) do
assign(socket, :snapshots, Map.put(socket.assigns.snapshots, fen, tablebase))
end
defp step_review(socket, delta) do
if socket.assigns.reviewing do
last = length(socket.assigns.line)
index = (socket.assigns.review_index + delta) |> max(0) |> min(last)
{:noreply, socket |> set_review_index(index) |> push_review_position()}
else
{:noreply, socket}
end
end
defp parse_index(index) when is_integer(index), do: index
defp parse_index(index) when is_binary(index), do: String.to_integer(index)
defp current_ply?(%{index: index}, review_index), do: index + 1 == review_index
defp played_ply_at(line, review_index) do
case Enum.at(line, review_index) do
%{best_line: true} -> nil
ply -> ply
end
end
defp ply_class(%{best_line: true}), do: "text-sky-600 italic"
defp ply_class(ply), do: grade_class(ply.grade)
defp ply_title(%{best_line: true}, _result), do: "Best line"
defp ply_title(ply, result), do: grade_label(ply.grade, result)
defp grade_class(:optimal), do: "text-emerald-600"
defp grade_class(:winning), do: "text-amber-600"
defp grade_class(:losing), do: "text-red-600"
defp grade_class(_), do: "text-gray-900"
defp grade_label(nil, _result), do: nil
defp grade_label(:optimal, _result), do: "Optimal move"
defp grade_label(:winning, :draw), do: "Keeps the draw — but not the sharpest"
defp grade_label(:winning, _result), do: "Winning — but not the sharpest"
defp grade_label(:losing, :draw), do: "Loses the draw"
defp grade_label(:losing, _result), do: "Throws away the win"
defp grade_label(:unknown, _result), do: "Not graded"
defp load_attempt(socket) do
fen = socket.assigns.endgame.fen
@@ -224,6 +521,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
socket
|> assign(:endgame, endgame)
|> assign(:tablebase, tablebase)
|> snapshot(fen, tablebase)
|> assign(:status, :playing)
|> assign(:blocked_reason, nil)
|> push_init_board(fen)
@@ -274,12 +572,19 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
move ->
grade = grade_move(socket.assigns.tablebase, move)
ply = %{
index: length(socket.assigns.plies),
san: san,
fen_after: fen_after,
grade: grade
}
socket =
socket
|> assign(:last_from_to, "#{from} ➔ #{to}")
|> assign(:last_san, san)
|> assign(:last_grade, grade)
|> assign(:move_list, socket.assigns.move_list ++ [san])
|> assign(:plies, socket.assigns.plies ++ [ply])
cond do
grade == :losing ->
@@ -307,18 +612,9 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
defp start_opponent_reply(socket, fen_after) do
case Tablebase.new(fen_after) do
{:ok, %Tablebase{checkmate: true}} ->
solve_attempt(socket)
{:ok, %Tablebase{moves: [reply | _]}} ->
{:noreply,
socket
|> assign(:awaiting_reply, true)
|> push_event("opponent_move", reply_payload(reply))}
{:ok, %Tablebase{}} ->
# Terminal non-mate position (stalemate/insufficient): no reply to play.
{:noreply, socket}
{:ok, tablebase} ->
socket = snapshot(socket, fen_after, tablebase)
reply_to(socket, tablebase)
other ->
{:noreply,
@@ -328,6 +624,21 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
end
end
defp reply_to(socket, %Tablebase{checkmate: true}), do: solve_attempt(socket)
defp reply_to(socket, %Tablebase{moves: [reply | _]}) do
{:noreply,
socket
|> assign(:awaiting_reply, true)
|> assign(:pending_reply, %{san: reply.san, uci: reply.uci})
|> push_event("opponent_move", reply_payload(reply))}
end
defp reply_to(socket, %Tablebase{}) do
# Terminal non-mate position (stalemate/insufficient): no reply to play.
{:noreply, socket}
end
defp solve_attempt(socket) do
{:ok, endgame} = Endgames.record_solve(socket.assigns.endgame)
@@ -347,27 +658,55 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|> assign(:best_move, best_move_text(socket.assigns.tablebase))}
end
defp best_move_text(%Tablebase{category: category, moves: [best | _] = moves}) do
best_rank = outcome_rank(category)
defp best_move_text(tablebase) do
san =
tablebase
|> best_moves()
|> Enum.map(& &1.san)
|> Enum.reject(&is_nil/1)
|> Enum.take(3)
|> Enum.join(", ")
if is_nil(best_rank) do
nil
else
san =
moves
|> Enum.filter(fn move ->
if san == "", do: nil, else: san
end
defp pick_best_move(tablebase), do: tablebase |> best_moves() |> List.first()
defp best_moves(%Tablebase{moves: moves} = tablebase) when is_list(moves) do
case {outcome_rank(tablebase.category), moves} do
{nil, _} ->
[]
{_best_rank, []} ->
[]
{best_rank, [best | _]} ->
Enum.filter(moves, fn move ->
outcome_rank(mover_outcome(move.category)) == best_rank and move.dtz == best.dtz
end)
|> Enum.map(& &1.san)
|> Enum.reject(&is_nil/1)
|> Enum.take(3)
|> Enum.join(", ")
if san == "", do: nil, else: san
end
end
defp best_move_text(_tablebase), do: nil
defp best_moves(_tablebase), do: []
defp record_opponent_ply(socket, fen, client_san) do
san =
case socket.assigns.pending_reply do
%{san: san} when is_binary(san) -> san
_ -> client_san || "…"
end
ply = %{
index: length(socket.assigns.plies),
san: san,
fen_after: fen,
grade: nil
}
socket
|> assign(:plies, socket.assigns.plies ++ [ply])
|> assign(:pending_reply, nil)
end
defp reply_payload(%Tablebase.Move{uci: uci, san: san}) do
%{
+8
View File
@@ -150,6 +150,14 @@ defmodule Chesstrainer.EndgamesTest do
end
end
describe "rating default" do
test "a new endgame changeset defaults rating to 1500" do
changeset = Endgames.change_endgame(%Endgame{})
assert Ecto.Changeset.get_field(changeset, :rating) == 1500
end
end
describe "listing and filtering" do
test "list_keys/0 returns the distinct keys sorted" do
create_endgame!(@kr)
@@ -10,6 +10,40 @@ defmodule ChesstrainerWeb.EndgameLive.FormTest do
@fen "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
describe "rating default" do
test "new endgame form pre-fills rating with 1500", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
html = view |> element("#endgame-form input[name='endgame[rating]']") |> render()
assert html =~ ~s(value="1500")
end
test "creates an endgame rated 1500 when rating is left unchanged", %{conn: conn} do
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
view
|> form("#endgame-form", endgame: %{fen: @fen, result: "win"})
|> render_submit()
assert_redirect(view, ~p"/admin/endgames")
endgame = Endgames.list_endgames() |> Enum.find(&(&1.fen == @fen))
assert endgame.rating == 1500
end
test "editing an endgame keeps its stored rating", %{conn: conn} do
attrs = %{fen: @fen, color: :white, result: :win, rating: 1625}
{:ok, endgame} = Endgames.create_endgame(attrs)
{:ok, view, _html} = live(conn, ~p"/admin/endgames/#{endgame}/edit")
html = view |> element("#endgame-form input[name='endgame[rating]']") |> render()
assert html =~ ~s(value="1625")
end
end
test "creates an endgame with staged themes", %{conn: conn} do
theme = theme_fixture(%{name: "Lucena"})
@@ -57,6 +57,59 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
})
end
# Plays one optimal move, applies the opponent's reply, then a losing move,
# leaving a three-ply failed attempt to review.
defp seeded_attempt(conn) do
endgame = endgame_fixture()
after_first = "8/8/8/8/8/8/8/8 b - - 0 1"
after_reply = "8/8/8/8/8/8/8/8 w - - 0 1"
after_losing = "8/8/8/8/8/8/8/8 b - - 1 1"
reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :loss, dtz: -3}
losing_reply = %Tablebase.Move{uci: "e8e7", san: "Ke7", category: :draw, dtz: 0}
seed_tablebase(endgame.fen, moves: grading_moves())
seed_tablebase(after_first, category: :loss, moves: [reply])
seed_tablebase(after_reply, category: :win, moves: grading_moves())
seed_tablebase(after_losing, category: :draw, moves: [losing_reply])
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "init_board", _payload}}, 100
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d7",
"san" => "Qd7+",
"prev_fen" => endgame.fen,
"fen" => after_first,
"endgame_id" => endgame.id
})
render_hook(view, "opponent_reply_applied", %{"fen" => after_reply})
assert_receive {^ref, {:push_event, "opponent_move", _payload}}, 100
assert_receive {^ref, {:push_event, "resume_board", _payload}}, 100
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d4",
"san" => "Qd4",
"prev_fen" => after_reply,
"fen" => after_losing,
"endgame_id" => endgame.id
})
{view,
%{
start: endgame.fen,
after_first: after_first,
after_reply: after_reply,
after_losing: after_losing
}}
end
describe "mount" do
test "renders the chessboard hook div and pushes init_board", %{conn: conn} do
endgame = endgame_fixture(color: :white)
@@ -434,4 +487,244 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert Endgames.get_endgame!(endgame.id).times_attempted == 2
end
end
describe "full move list" do
test "shows the opponent's reply alongside the user's moves", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
html = render(view)
assert html =~ "Qd7+"
assert html =~ "Ke7"
assert html =~ "Qd4"
end
test "colours the user's plies by grade", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
html = render(view)
assert html =~ ~s(data-grade="optimal")
assert html =~ ~s(data-grade="losing")
end
test "uses draw-aware wording for draw attempts", %{conn: conn} do
endgame = endgame_fixture(result: :draw)
moves = [
%Tablebase.Move{uci: "d1d7", san: "Qd7", category: :draw, dtz: 0},
%Tablebase.Move{uci: "d1d5", san: "Qd5", category: :draw, dtz: -5}
]
seed_tablebase(endgame.fen, category: :draw, moves: moves)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "d1",
"to" => "d5",
"san" => "Qd5",
"prev_fen" => endgame.fen,
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
html = render(view)
assert html =~ "Keeps the draw"
refute html =~ "Winning — but not the sharpest"
end
end
describe "review" do
test "enters review after a failed attempt at the final position", %{conn: conn} do
{view, fens} = seeded_attempt(conn)
assert has_element?(view, "button", "Review")
view |> element("button", "Review") |> render_click()
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "review_position", %{fen: fen}}}, 100
assert fen == fens.after_losing
assert has_element?(view, "#review-controls")
end
test "offers review after a solved attempt", %{conn: conn} do
endgame = endgame_fixture()
moves = [%Tablebase.Move{uci: "a7a8q", san: "a8=Q", category: :loss, dtz: -1}]
seed_tablebase(endgame.fen, moves: moves)
{:ok, view, _html} = live(conn, ~p"/endgames/#{endgame}/play")
render_hook(view, "endgame_move_played", %{
"from" => "a7",
"to" => "a8",
"san" => "a8=Q",
"promotion" => "q",
"prev_fen" => endgame.fen,
"fen" => endgame.fen,
"endgame_id" => endgame.id
})
assert has_element?(view, "button", "Review")
end
test "steps through positions with prev/next and clamps at the ends", %{conn: conn} do
{view, fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "review_position", %{fen: after_losing}}}, 100
assert after_losing == fens.after_losing
render_hook(view, "review_prev", %{})
assert_receive {^ref, {:push_event, "review_position", %{fen: after_reply}}}, 100
assert after_reply == fens.after_reply
render_hook(view, "review_prev", %{})
assert_receive {^ref, {:push_event, "review_position", %{fen: after_first}}}, 100
assert after_first == fens.after_first
render_hook(view, "review_prev", %{})
assert_receive {^ref, {:push_event, "review_position", %{fen: start}}}, 100
assert start == fens.start
# Bounded at the start of the game.
render_hook(view, "review_prev", %{})
assert_receive {^ref, {:push_event, "review_position", %{fen: still_start}}}, 100
assert still_start == fens.start
render_hook(view, "review_next", %{})
assert_receive {^ref, {:push_event, "review_position", %{fen: back}}}, 100
assert back == fens.after_first
end
test "clicking a ply jumps to its position", %{conn: conn} do
{view, fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
%{proxy: {ref, _topic, _}} = view
# Consume the position pushed on entering review.
assert_receive {^ref, {:push_event, "review_position", _payload}}, 100
view |> element("button", "Ke7") |> render_click()
assert_receive {^ref, {:push_event, "review_position", %{fen: fen}}}, 100
assert fen == fens.after_reply
end
test "try again exits review and starts a fresh attempt", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
assert has_element?(view, "#review-controls")
view |> element("button", "Try again") |> render_click()
refute has_element?(view, "#review-controls")
assert render(view) =~ "No Moves"
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "init_board", _payload}}, 100
end
test "ignores moves while reviewing", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
render_hook(view, "endgame_move_played", %{
"from" => "a1",
"to" => "a2",
"san" => "Ka2",
"prev_fen" => "8/8/8/8/8/8/8/8 b - - 1 1",
"fen" => "8/8/8/8/8/8/8/8 w - - 1 2",
"endgame_id" => "ignored"
})
refute render(view) =~ "Ka2"
end
end
describe "best moves" do
test "shows the best move and the played move at each reviewed position", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
panel = view |> element("#best-move-panel") |> render()
assert panel =~ "Best move:"
assert panel =~ "Ke7"
render_hook(view, "review_prev", %{})
panel = view |> element("#best-move-panel") |> render()
assert panel =~ "Qd7+"
assert panel =~ "Played: Qd4"
end
test "summarises the failing move and the best alternative", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
assert render(view) =~ "You played Qd4; best was: Qd7+"
end
test "play best line branches and steps the optimal continuation", %{conn: conn} do
{view, _fens} = seeded_attempt(conn)
view |> element("button", "Review") |> render_click()
render_hook(view, "review_prev", %{})
%{proxy: {ref, _topic, _}} = view
assert_receive {^ref, {:push_event, "review_position", _}}, 100
assert_receive {^ref, {:push_event, "review_position", _}}, 100
view |> element("button", "Play best line") |> render_click()
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"
seed_tablebase(best_after, category: :draw, moves: [])
render_hook(view, "best_line_move_applied", %{"fen" => best_after})
assert_receive {^ref, {:push_event, "review_position", %{fen: ^best_after}}}, 100
moves = view |> element("#move-list") |> render()
refute moves =~ "Qd4"
assert moves =~ "Qd7+"
assert moves =~ ~s(title="Best line")
view |> element("button", "Back to game") |> render_click()
moves = view |> element("#move-list") |> render()
assert moves =~ "Qd4"
end
test "degrades gracefully and reuses played-position snapshots", %{conn: conn} do
{view, fens} = seeded_attempt(conn)
TablebaseCache.delete(fens.after_losing)
Ratelimiters.lichess_add_cooldown()
on_exit(fn -> Ratelimiters.lichess_reset_cooldown() end)
view |> element("button", "Review") |> render_click()
panel = view |> element("#best-move-panel") |> render()
assert panel =~ "Best move unavailable here"
refute has_element?(view, "button", "Play best line")
render_hook(view, "review_prev", %{})
panel = view |> element("#best-move-panel") |> render()
refute panel =~ "Best move unavailable here"
assert panel =~ "Qd7+"
end
end
end