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} <: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}

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

Optimal move

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

Winning — but not the sharpest

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

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 @move_list == [] do %>

No Moves

<% else %> <%= for {[white_move, black_move], i} <- format_move_pairs(@move_list, @endgame.color) do %>
{i}. {white_move || "..."} <%= if black_move do %> {black_move} <% end %>
<% end %> <% end %>
<.button phx-click="reset" variant="primary"> <.icon name="hero-arrow-path" /> Reset
""" 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(:move_list, []) |> assign(:last_san, "None yet") |> assign(:last_from_to, "None yet") |> assign(:last_grade, nil) {: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"] prev_fen = params["prev_fen"] || socket.assigns.fen cond do socket.assigns.status != :playing -> {:noreply, put_flash(socket, :error, "The tablebase is unavailable, so this move cannot be graded.")} 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) 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(:move_list, []) |> assign(:last_san, "None yet") |> assign(:last_from_to, "None yet") |> assign(:last_grade, nil) {: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 moves |> Enum.chunk_every(2, 2, [nil]) |> Enum.with_index(1) end defp load_attempt(socket) do fen = socket.assigns.endgame.fen socket = assign(socket, :fen, fen) if connected?(socket) do case Tablebase.new(fen) do {:ok, tablebase} -> socket |> 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) 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 -> {:noreply, socket |> assign(:last_from_to, "#{from} ➔ #{to}") |> assign(:last_san, san) |> assign(:last_grade, grade_move(socket.assigns.tablebase, move)) |> assign(:move_list, socket.assigns.move_list ++ [san])} end 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