diff --git a/assets/js/hooks/chessBoard.js b/assets/js/hooks/chessBoard.js
index 83ad857..b4de8b2 100644
--- a/assets/js/hooks/chessBoard.js
+++ b/assets/js/hooks/chessBoard.js
@@ -6,11 +6,32 @@ 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.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 +74,29 @@ 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() },
+ });
+ },
+
initBoard({ fen, orientation, player_color, blocked }) {
try {
this.chess.load(fen);
diff --git a/lib/chesstrainer_web/live/endgame_live/play.ex b/lib/chesstrainer_web/live/endgame_live/play.ex
index a55cb01..820d265 100644
--- a/lib/chesstrainer_web/live/endgame_live/play.ex
+++ b/lib/chesstrainer_web/live/endgame_live/play.ex
@@ -58,9 +58,17 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
<% @last_grade == :optimal -> %>
Optimal move
<% @last_grade == :winning -> %>
- Winning — but not the sharpest
+
+ {if @endgame.result == :draw,
+ do: "Keeps the draw — but not the sharpest",
+ else: "Winning — but not the sharpest"}
+
<% @last_grade == :losing -> %>
- Losing move — this throws away the win
+
+ {if @endgame.result == :draw,
+ do: "Losing move — this loses the draw",
+ else: "Losing move — this throws away the win"}
+
<% @last_grade == :unknown -> %>
Could not grade that move
<% true -> %>
@@ -71,15 +79,29 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
Moves:
- <%= if @move_list == [] do %>
+ <%= if @plies == [] do %>
No Moves
<% 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 %>
- {i}.
- {white_move || "..."}
- <%= if black_move do %>
- {black_move}
+ {move_no}.
+ <%= if white_ply do %>
+ <.ply
+ ply={white_ply}
+ reviewing={@reviewing}
+ review_index={@review_index}
+ result={@endgame.result}
+ />
+ <% else %>
+ ...
+ <% end %>
+ <%= if black_ply do %>
+ <.ply
+ ply={black_ply}
+ reviewing={@reviewing}
+ review_index={@review_index}
+ result={@endgame.result}
+ />
<% end %>
<% end %>
@@ -87,12 +109,23 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
-
+
+ <.button
+ :if={@status in [:solved, :failed] and not @reviewing}
+ phx-click="review"
+ >
+ <.icon name="hero-eye" /> Review
+
<.button phx-click="reset" variant="primary">
<.icon name="hero-arrow-path" />
{if @status in [:solved, :failed], do: "Try again", else: "Reset"}
+
+
+ <.button phx-click="review_prev" disabled={@review_index <= 0}>←
+ <.button phx-click="review_next" disabled={@review_index >= length(@plies)}>→
+
@@ -112,7 +145,10 @@ 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(:last_san, "None yet")
|> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil)
@@ -154,27 +190,30 @@ 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)
+ |> 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 +230,10 @@ 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(:last_san, "None yet")
|> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil)
@@ -199,14 +241,123 @@ 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
+ last = length(socket.assigns.plies)
- moves
+ {:noreply,
+ socket
+ |> assign(:reviewing, true)
+ |> assign(:review_index, last)
+ |> push_review_position()}
+ 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.plies)
+ index = parse_index(index) |> max(0) |> min(last)
+
+ {:noreply,
+ socket
+ |> assign(:review_index, index)
+ |> push_review_position()}
+ 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 %>
+
+ <% else %>
+
+ {@ply.san}
+
+ <% 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 push_review_position(socket) do
+ fen =
+ socket.assigns.endgame.fen
+ |> positions(socket.assigns.plies)
+ |> Enum.at(socket.assigns.review_index)
+
+ push_event(socket, "review_position", %{fen: fen})
+ end
+
+ defp step_review(socket, delta) do
+ if socket.assigns.reviewing do
+ last = length(socket.assigns.plies)
+ index = (socket.assigns.review_index + delta) |> max(0) |> min(last)
+
+ {:noreply,
+ socket
+ |> assign(: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 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
@@ -274,12 +425,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 ->
@@ -314,6 +472,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
{:noreply,
socket
|> assign(:awaiting_reply, true)
+ |> assign(:pending_reply, %{san: reply.san, uci: reply.uci})
|> push_event("opponent_move", reply_payload(reply))}
{:ok, %Tablebase{}} ->
@@ -369,6 +528,25 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
defp best_move_text(_tablebase), do: nil
+ 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
%{
from: String.slice(uci, 0, 2),
diff --git a/test/chesstrainer_web/live/endgame_live/play_test.exs b/test/chesstrainer_web/live/endgame_live/play_test.exs
index 1e25300..d87a51a 100644
--- a/test/chesstrainer_web/live/endgame_live/play_test.exs
+++ b/test/chesstrainer_web/live/endgame_live/play_test.exs
@@ -57,6 +57,57 @@ 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}
+
+ seed_tablebase(endgame.fen, moves: grading_moves())
+ seed_tablebase(after_first, category: :loss, moves: [reply])
+ seed_tablebase(after_reply, category: :win, moves: grading_moves())
+
+ {: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 +485,169 @@ 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
end