Show the full game and review it after an attempt

Closes #18
This commit is contained in:
2026-11-02 21:26:20 +01:00
parent 6d0d750ca7
commit 1e62b13d94
3 changed files with 472 additions and 34 deletions
+44
View File
@@ -6,11 +6,32 @@ export const ChessBoard = {
this.chess = new Chess(); this.chess = new Chess();
this.ground = null; this.ground = null;
this.playerColor = "white"; this.playerColor = "white";
this.reviewing = false;
this.handleEvent("init_board", (payload) => { this.handleEvent("init_board", (payload) => {
this.reviewing = false;
this.initBoard(payload); 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 }) => { this.handleEvent("set_fen", ({ fen }) => {
try { try {
this.chess.load(fen); 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 }) { initBoard({ fen, orientation, player_color, blocked }) {
try { try {
this.chess.load(fen); this.chess.load(fen);
+196 -18
View File
@@ -58,9 +58,17 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
<% @last_grade == :optimal -> %> <% @last_grade == :optimal -> %>
<p class="font-semibold text-emerald-600">Optimal move</p> <p class="font-semibold text-emerald-600">Optimal move</p>
<% @last_grade == :winning -> %> <% @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 -> %> <% @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 -> %> <% @last_grade == :unknown -> %>
<p class="font-semibold text-gray-600">Could not grade that move</p> <p class="font-semibold text-gray-600">Could not grade that move</p>
<% true -> %> <% true -> %>
@@ -71,15 +79,29 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
<div class="flex-1 min-h-0 flex flex-col bg-white rounded-lg p-3"> <div class="flex-1 min-h-0 flex flex-col bg-white rounded-lg p-3">
<p class="text-sm text-gray-600 font-semibold mb-2">Moves:</p> <p class="text-sm text-gray-600 font-semibold mb-2">Moves:</p>
<div class="flex-1 overflow-y-auto"> <div class="flex-1 overflow-y-auto">
<%= if @move_list == [] do %> <%= if @plies == [] do %>
<p class="text-sm text-gray-500">No Moves</p> <p class="text-sm text-gray-500">No Moves</p>
<% else %> <% 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"> <div class="font-mono text-sm leading-6">
<span class="text-gray-500 mr-2">{i}.</span> <span class="text-gray-500 mr-2">{move_no}.</span>
<span class="text-gray-900">{white_move || "..."}</span> <%= if white_ply do %>
<%= if black_move do %> <.ply
<span class="text-gray-900 ml-2">{black_move}</span> 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 %> <% end %>
</div> </div>
<% end %> <% end %>
@@ -87,12 +109,23 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
</div> </div>
</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"> <.button phx-click="reset" variant="primary">
<.icon name="hero-arrow-path" /> <.icon name="hero-arrow-path" />
{if @status in [:solved, :failed], do: "Try again", else: "Reset"} {if @status in [:solved, :failed], do: "Try again", else: "Reset"}
</.button> </.button>
</div> </div>
<div :if={@reviewing} id="review-controls" class="flex gap-2">
<.button phx-click="review_prev" disabled={@review_index <= 0}>←</.button>
<.button phx-click="review_next" disabled={@review_index >= length(@plies)}>→</.button>
</div>
</div> </div>
</div> </div>
</Layouts.app> </Layouts.app>
@@ -112,7 +145,10 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
|> assign(:status, :loading) |> assign(:status, :loading)
|> assign(:blocked_reason, nil) |> assign(:blocked_reason, nil)
|> assign(:best_move, 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_san, "None yet")
|> assign(:last_from_to, "None yet") |> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil) |> assign(:last_grade, nil)
@@ -154,10 +190,12 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
not socket.assigns.awaiting_reply -> not socket.assigns.awaiting_reply ->
{:noreply, socket} {:noreply, socket}
draw and socket.assigns.endgame.result == :draw ->
solve_attempt(socket)
true -> true ->
socket = record_opponent_ply(socket, fen, params["san"])
if draw and socket.assigns.endgame.result == :draw do
solve_attempt(socket)
else
case Tablebase.new(fen) do case Tablebase.new(fen) do
{:ok, tablebase} -> {:ok, tablebase} ->
{:noreply, {:noreply,
@@ -178,6 +216,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
end end
end end
end end
end
def handle_event("chess_fen_invalid", %{"fen" => fen, "message" => message}, socket) do def handle_event("chess_fen_invalid", %{"fen" => fen, "message" => message}, socket) do
{:noreply, {:noreply,
@@ -191,7 +230,10 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
def handle_event("reset", _params, socket) do def handle_event("reset", _params, socket) do
socket = socket =
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_san, "None yet")
|> assign(:last_from_to, "None yet") |> assign(:last_from_to, "None yet")
|> assign(:last_grade, nil) |> assign(:last_grade, nil)
@@ -199,14 +241,123 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
{:noreply, load_attempt(socket)} {:noreply, load_attempt(socket)}
end end
def format_move_pairs(move_list, color) do def handle_event("review", _params, socket) do
moves = if color in [:black, "black"], do: [nil | move_list], else: move_list 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 %>
<button
type="button"
phx-click="review_step"
phx-value-index={@ply.index + 1}
class={[
"ml-2",
grade_class(@ply.grade),
current_ply?(@ply, @review_index) && "underline"
]}
title={grade_label(@ply.grade, @result)}
data-grade={@ply.grade}
>
{@ply.san}
</button>
<% else %>
<span
class={["ml-2", grade_class(@ply.grade)]}
title={grade_label(@ply.grade, @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.chunk_every(2, 2, [nil])
|> Enum.with_index(1) |> Enum.with_index(1)
end 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 defp load_attempt(socket) do
fen = socket.assigns.endgame.fen fen = socket.assigns.endgame.fen
@@ -274,12 +425,19 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
move -> move ->
grade = grade_move(socket.assigns.tablebase, move) grade = grade_move(socket.assigns.tablebase, move)
ply = %{
index: length(socket.assigns.plies),
san: san,
fen_after: fen_after,
grade: grade
}
socket = socket =
socket socket
|> assign(:last_from_to, "#{from} ➔ #{to}") |> assign(:last_from_to, "#{from} ➔ #{to}")
|> assign(:last_san, san) |> assign(:last_san, san)
|> assign(:last_grade, grade) |> assign(:last_grade, grade)
|> assign(:move_list, socket.assigns.move_list ++ [san]) |> assign(:plies, socket.assigns.plies ++ [ply])
cond do cond do
grade == :losing -> grade == :losing ->
@@ -314,6 +472,7 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
{:noreply, {:noreply,
socket socket
|> assign(:awaiting_reply, true) |> assign(:awaiting_reply, true)
|> assign(:pending_reply, %{san: reply.san, uci: reply.uci})
|> push_event("opponent_move", reply_payload(reply))} |> push_event("opponent_move", reply_payload(reply))}
{:ok, %Tablebase{}} -> {:ok, %Tablebase{}} ->
@@ -369,6 +528,25 @@ defmodule ChesstrainerWeb.EndgameLive.Play do
defp best_move_text(_tablebase), do: nil 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 defp reply_payload(%Tablebase.Move{uci: uci, san: san}) do
%{ %{
from: String.slice(uci, 0, 2), from: String.slice(uci, 0, 2),
@@ -57,6 +57,57 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
}) })
end 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 describe "mount" do
test "renders the chessboard hook div and pushes init_board", %{conn: conn} do test "renders the chessboard hook div and pushes init_board", %{conn: conn} do
endgame = endgame_fixture(color: :white) endgame = endgame_fixture(color: :white)
@@ -434,4 +485,169 @@ defmodule ChesstrainerWeb.EndgameLive.PlayTest do
assert Endgames.get_endgame!(endgame.id).times_attempted == 2 assert Endgames.get_endgame!(endgame.id).times_attempted == 2
end end
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 end