defmodule ChesstrainerWeb.EndgameLive.Play do use ChesstrainerWeb, :live_view alias Chesstrainer.Endgames alias Chesstrainer.Endgames.Tablebase @impl true def render(assigns) do ~H""" <.header> Play endgame {@endgame.key} <:subtitle> {@endgame.color |> Atom.to_string() |> String.capitalize()} to move · Rating: {@endgame.rating} · Attempts: {@endgame.times_attempted || 0} · Solved: {@endgame.times_solved || 0} <:actions> <.button navigate={~p"/endgames"}> <.icon name="hero-arrow-left" /> Back to endgames
<%= cond do %> <% @status == :loading -> %>

Loading tablebase…

<% @status == :blocked -> %>

Tablebase unavailable

{@blocked_reason}

<% @status == :solved -> %>

{if @endgame.result == :draw, do: "Draw held!", else: "Solved!"}

<% @status == :failed -> %>

Failed

{if @endgame.result == :draw, do: "That move loses the draw.", else: "That move throws away the win."}

<%= if @best_move do %>

Best was: {@best_move}

<% end %> <% @awaiting_reply -> %>

Opponent is replying…

<% @last_grade == :optimal -> %>

Optimal move

<% @last_grade == :winning -> %>

{if @endgame.result == :draw, do: "Keeps the draw — but not the sharpest", else: "Winning — but not the sharpest"}

<% @last_grade == :losing -> %>

{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 -> %>

Make a move to have it graded.

<% end %>

Moves:

<%= if @plies == [] do %>

No Moves

<% else %> <%= for {[white_ply, black_ply], move_no} <- move_rows(@plies, @endgame.color) do %>
{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 %> <% end %>
<.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)}>→
""" end @impl true def mount(%{"id" => id}, _session, socket) do endgame = Endgames.get_endgame!(id) socket = socket |> assign(:page_title, "Play endgame") |> assign(:endgame, endgame) |> assign(:fen, endgame.fen) |> assign(:tablebase, nil) |> assign(:status, :loading) |> assign(:blocked_reason, nil) |> assign(:best_move, nil) |> 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) |> assign(:awaiting_reply, false) {:ok, load_attempt(socket)} end @impl true def handle_event("endgame_move_played", params, socket) do %{"from" => from, "to" => to, "san" => san} = params promotion = params["promotion"] draw = params["draw"] || false prev_fen = params["prev_fen"] || socket.assigns.fen fen_after = params["fen"] || socket.assigns.fen cond do socket.assigns.status == :blocked -> {:noreply, put_flash(socket, :error, "The tablebase is unavailable, so this move cannot be graded.")} socket.assigns.status != :playing -> {:noreply, socket} not same_position?(prev_fen, socket.assigns.fen) -> {:noreply, put_flash(socket, :error, "That move is out of sequence. Press Reset to try again.")} true -> grade_and_record(socket, from, to, promotion, san, fen_after, draw) end end def handle_event("opponent_reply_applied", params, socket) do %{"fen" => fen} = params draw = params["draw"] || false cond do not socket.assigns.awaiting_reply -> {:noreply, socket} 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 {: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 def handle_event("chess_fen_invalid", %{"fen" => fen, "message" => message}, socket) do {:noreply, put_flash( socket, :error, "Endgame FEN is invalid and the board cannot be loaded: #{message} (#{fen})" )} end def handle_event("reset", _params, socket) do socket = socket |> 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) {:noreply, load_attempt(socket)} end def handle_event("review", _params, socket) do if socket.assigns.status in [:solved, :failed] do last = length(socket.assigns.plies) {: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 socket = socket |> assign(:fen, fen) |> assign(:awaiting_reply, false) |> assign(:best_move, nil) if connected?(socket) do case Tablebase.new(fen) do {:ok, tablebase} -> {:ok, endgame} = Endgames.record_attempt(socket.assigns.endgame) socket |> assign(:endgame, endgame) |> assign(:tablebase, tablebase) |> assign(:status, :playing) |> assign(:blocked_reason, nil) |> push_init_board(fen) other -> socket |> assign(:tablebase, nil) |> assign(:status, :blocked) |> assign(:blocked_reason, blocked_reason(other)) |> push_init_board(fen) end else assign(socket, :status, :loading) end end defp push_init_board(socket, fen) do push_event(socket, "init_board", %{ fen: fen, orientation: Atom.to_string(socket.assigns.endgame.color), player_color: Atom.to_string(socket.assigns.endgame.color), blocked: socket.assigns.status == :blocked }) end defp blocked_reason({:cooldown, remaining_ms}) do seconds = max(div(remaining_ms + 999, 1000), 1) "The tablebase is rate-limited. Try again in about #{seconds}s." end defp blocked_reason({:error, {:too_many_requests, _, _}}) do "The tablebase is rate-limited. Try again in a minute." end defp blocked_reason({:error, {:client_error, 404, _}}) do "This position is not covered by the tablebase." end defp blocked_reason({:error, reason}) do "The tablebase is unavailable (#{inspect(reason)})." end defp grade_and_record(socket, from, to, promotion, san, fen_after, draw) do case find_move(socket.assigns.tablebase, from, to, promotion) do nil -> {:noreply, put_flash(socket, :error, "Could not identify that move in the tablebase.")} move -> 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(:plies, socket.assigns.plies ++ [ply]) cond do grade == :losing -> fail_attempt(socket) grade not in [:optimal, :winning] -> {:noreply, socket} draw and socket.assigns.endgame.result == :draw -> # A drawn-by-rule position is the goal of a draw puzzle. solve_attempt(socket) socket.assigns.endgame.result == :win and not is_nil(promotion) -> # Conversion cutoff: a promotion that keeps the win ends a win puzzle. solve_attempt(socket) not same_position?(fen_after, socket.assigns.fen) -> start_opponent_reply(socket, fen_after) true -> {:noreply, socket} end end end 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) |> assign(:pending_reply, %{san: reply.san, uci: reply.uci}) |> push_event("opponent_move", reply_payload(reply))} {:ok, %Tablebase{}} -> # Terminal non-mate position (stalemate/insufficient): no reply to play. {:noreply, socket} other -> {:noreply, socket |> assign(:status, :blocked) |> assign(:blocked_reason, blocked_reason(other))} end end defp solve_attempt(socket) do {:ok, endgame} = Endgames.record_solve(socket.assigns.endgame) {:noreply, socket |> assign(:status, :solved) |> assign(:endgame, endgame) |> assign(:awaiting_reply, false) |> assign(:best_move, nil)} end defp fail_attempt(socket) do {:noreply, socket |> assign(:status, :failed) |> assign(:awaiting_reply, false) |> 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) if is_nil(best_rank) do nil else san = moves |> Enum.filter(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 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), to: String.slice(uci, 2, 2), promotion: String.at(uci, 4), san: san } end defp find_move(%Tablebase{moves: moves}, from, to, promotion) when is_list(moves) do uci = "#{from}#{to}#{promotion || ""}" Enum.find(moves, &(&1.uci == uci)) end defp find_move(_tablebase, _from, _to, _promotion), do: nil # Compare only the board and side to move: chess.js may normalise the rest # (castling/en-passant/halfmove/fullmove) differently from the stored FEN. defp same_position?(fen_a, fen_b), do: position_key(fen_a) == position_key(fen_b) defp position_key(fen) do case String.split(fen, " ") do [board, active | _] -> {board, active} _ -> fen end end defp grade_move(%Tablebase{moves: []}, _move), do: :unknown defp grade_move(%Tablebase{category: position_category, moves: [best | _]}, move) do best_rank = outcome_rank(position_category) move_rank = outcome_rank(mover_outcome(move.category)) cond do is_nil(best_rank) or is_nil(move_rank) -> :unknown move_rank < best_rank -> :losing move.dtz == best.dtz -> :optimal true -> :winning end end # The mover's outcome is the flip of `category`, which is reported from the # perspective of the side to move *after* the move. defp mover_outcome(:loss), do: :win defp mover_outcome(:win), do: :loss defp mover_outcome(:draw), do: :draw defp mover_outcome(_), do: :unknown defp outcome_rank(:win), do: 2 defp outcome_rank(:draw), do: 1 defp outcome_rank(:loss), do: 0 defp outcome_rank(_), do: nil end