mirror of
https://github.com/TheRealOwenRees/chess-endgame-trainer.git
synced 2026-11-18 11:42:07 +00:00
* remove daisyui and rebuild styles * very basic setup of new design - missing components etc * basic navbar with reusable landing components * basic puzzle of the day * update todos * update todos * add curated landing puzzle cards with selectable board (#55) * update with footer * add button to solve today's puzzle * Make landing page a dead view Render the home page from PageController with a static board preview, link puzzle cards and CTAs to public-code play routes, count puzzles from the DB, and add a global footer. * Serve a marketing-only JS bundle on the landing page Build a small marketing entry point with phoenix_html and the plain-DOM navbar, select it on controller-rendered pages, and keep the full LiveView bundle for LiveView pages. * Add landing page SEO metadata Replace the Phoenix default title with a descriptive Lucid Chess title, and add description, canonical, Open Graph, and Twitter card tags to the landing page. * Complete the hero copy block Add the spark icon primitive and the Endgames, made clear eyebrow. The primary CTA keeps linking to the active puzzle rather than scrolling to the board. * Add a persisted global daily puzzle Assign one endgame per UTC day in a daily_puzzles table with a unique date, preferring endgames unused in the last 30 days and falling back to any. Concurrent first requests insert with on-conflict-ignore and read the winning row. The landing board now shows the daily puzzle. * remove unused CSS, nav links, time pill * allow devices to connect to dev server by changing IP address to 0.0.0.0 * Restore the colour-mode switch and add a dark palette * Use brand colour tokens on the play page * self host fonts - closes issue #62 * begin splitting CSS into modules * remove hover on hero chessboard, split more css modules * remove interactivity from hero chessboard * update todo
818 lines
25 KiB
Elixir
818 lines
25 KiB
Elixir
defmodule ChesstrainerWeb.EndgameLive.Play do
|
|
use ChesstrainerWeb, :live_view
|
|
|
|
alias Chesstrainer.Attempts
|
|
alias Chesstrainer.Endgames
|
|
alias Chesstrainer.Endgames.Tablebase
|
|
alias Chesstrainer.Ratings
|
|
|
|
@impl true
|
|
def render(assigns) do
|
|
~H"""
|
|
<Layouts.app flash={@flash}>
|
|
<.header>
|
|
Play endgame {@endgame.key}
|
|
<:subtitle>
|
|
{@endgame.color |> Atom.to_string() |> String.capitalize()} to move · Rating: {round(
|
|
@endgame.rating
|
|
)} · Attempts: {@endgame.times_attempted ||
|
|
0} · Solved: {@endgame.times_solved || 0}<span :if={@user_rating}> · Your rating: {round(
|
|
@user_rating
|
|
)}</span>
|
|
<p class="text-xs text-muted flex items-center mt-1">
|
|
<span>FEN: {@endgame.fen}</span>
|
|
<button
|
|
id="copy-fen-btn"
|
|
phx-hook="CopyFen"
|
|
data-fen={@endgame.fen}
|
|
class="inline-flex items-center cursor-pointer"
|
|
title="Copy FEN to clipboard"
|
|
>
|
|
<.icon name="hero-document-duplicate" class="w-3.5 h-3.5" />
|
|
</button>
|
|
</p>
|
|
</:subtitle>
|
|
<:actions>
|
|
<.button navigate={~p"/endgames"}>
|
|
<.icon name="hero-arrow-left" /> Back to endgames
|
|
</.button>
|
|
</:actions>
|
|
</.header>
|
|
|
|
<div class="flex gap-2 bg-base-200 p-4 rounded-xl shadow-inner">
|
|
<div
|
|
id="endgame-board"
|
|
phx-hook="ChessBoard"
|
|
phx-update="ignore"
|
|
data-endgame-id={@endgame.id}
|
|
class="w-100 h-100"
|
|
>
|
|
</div>
|
|
|
|
<div class="w-48 h-100 flex flex-col gap-3">
|
|
<div class="rounded-lg bg-canvas-raised p-3 text-sm">
|
|
<%= cond do %>
|
|
<% @status == :loading -> %>
|
|
<p class="text-muted">Loading tablebase…</p>
|
|
<% @status == :blocked -> %>
|
|
<p class="font-semibold text-error">Tablebase unavailable</p>
|
|
<p class="text-error">{@blocked_reason}</p>
|
|
<% @status == :solved -> %>
|
|
<p class="font-semibold text-success-text">
|
|
{if @endgame.result == :draw, do: "Draw held!", else: "Solved!"}
|
|
</p>
|
|
<% @status == :failed -> %>
|
|
<p class="font-semibold text-error">Failed</p>
|
|
<p class="text-error">
|
|
{if @endgame.result == :draw,
|
|
do: "That move loses the draw.",
|
|
else: "That move throws away the win."}
|
|
</p>
|
|
<%= if @best_move && @plies != [] do %>
|
|
<p class="text-muted">
|
|
You played {List.last(@plies).san}; best was: {@best_move}
|
|
</p>
|
|
<% end %>
|
|
<% @awaiting_reply -> %>
|
|
<p class="text-muted">Opponent is replying…</p>
|
|
<% @last_grade == :optimal -> %>
|
|
<p class="font-semibold text-success-text">Optimal move</p>
|
|
<% @last_grade == :winning -> %>
|
|
<p class="font-semibold text-warning">
|
|
{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-error">
|
|
{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-muted">Could not grade that move</p>
|
|
<% true -> %>
|
|
<p class="text-muted">Make a move to have it graded.</p>
|
|
<% end %>
|
|
</div>
|
|
|
|
<div :if={@reviewing} id="best-move-panel" class="rounded-lg bg-canvas-raised p-3 text-sm">
|
|
<%= cond do %>
|
|
<% @review_blocked -> %>
|
|
<p class="text-muted">Best move unavailable here</p>
|
|
<p class="text-muted">{@review_blocked}</p>
|
|
<% @review_tablebase -> %>
|
|
<p class="text-muted font-semibold mb-1">Best move:</p>
|
|
<p class="text-success-text">{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-muted">No best move.</p>
|
|
<% end %>
|
|
</div>
|
|
|
|
<div id="move-list" class="flex-1 min-h-0 flex flex-col bg-canvas-raised rounded-lg p-3">
|
|
<% plies = display_plies(@reviewing, @line, @plies) %>
|
|
<p class="text-sm text-muted font-semibold mb-2">Moves:</p>
|
|
<div class="flex-1 overflow-y-auto">
|
|
<%= if plies == [] do %>
|
|
<p class="text-sm text-muted">No Moves</p>
|
|
<% else %>
|
|
<%= for {[white_ply, black_ply], move_no} <- move_rows(plies, @endgame.color) do %>
|
|
<div class="font-mono text-sm leading-6">
|
|
<span class="text-muted 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-body">...</span>
|
|
<% end %>
|
|
<%= if black_ply do %>
|
|
<.ply
|
|
ply={black_ply}
|
|
reviewing={@reviewing}
|
|
review_index={@review_index}
|
|
result={@endgame.result}
|
|
/>
|
|
<% end %>
|
|
</div>
|
|
<% end %>
|
|
<% end %>
|
|
</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>
|
|
"""
|
|
end
|
|
|
|
@impl true
|
|
def mount(%{"public_code" => public_code}, _session, socket) do
|
|
endgame = Endgames.get_endgame_by_public_code!(public_code)
|
|
|
|
socket =
|
|
socket
|
|
|> assign(:page_title, "Play endgame")
|
|
|> assign(:endgame, endgame)
|
|
|> assign(:user_rating, user_rating(socket.assigns.current_scope))
|
|
|> 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(: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)
|
|
|> 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)
|
|
|> 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
|
|
|
|
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(: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)
|
|
|
|
{:noreply, load_attempt(socket)}
|
|
end
|
|
|
|
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))
|
|
|
|
{: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-info 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-success-text"
|
|
defp grade_class(:winning), do: "text-warning"
|
|
defp grade_class(:losing), do: "text-error"
|
|
defp grade_class(_), do: "text-body"
|
|
|
|
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)
|
|
|> snapshot(fen, 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, :not_covered}) 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} ->
|
|
socket = snapshot(socket, fen_after, tablebase)
|
|
reply_to(socket, tablebase)
|
|
|
|
other ->
|
|
{:noreply,
|
|
socket
|
|
|> assign(:status, :blocked)
|
|
|> assign(:blocked_reason, blocked_reason(other))}
|
|
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)
|
|
|
|
socket =
|
|
socket
|
|
|> assign(:endgame, endgame)
|
|
|> record_attempt(:solved)
|
|
|
|
{:noreply,
|
|
socket
|
|
|> assign(:status, :solved)
|
|
|> assign(:awaiting_reply, false)
|
|
|> assign(:best_move, nil)}
|
|
end
|
|
|
|
defp fail_attempt(socket) do
|
|
socket = record_attempt(socket, :failed)
|
|
|
|
{:noreply,
|
|
socket
|
|
|> assign(:status, :failed)
|
|
|> assign(:awaiting_reply, false)
|
|
|> assign(:best_move, best_move_text(socket.assigns.tablebase))}
|
|
end
|
|
|
|
defp record_attempt(socket, outcome) do
|
|
case Attempts.record_attempt(socket.assigns.current_scope, socket.assigns.endgame, outcome) do
|
|
{:ok, attempt} ->
|
|
case Ratings.rate_attempt(attempt) do
|
|
{:ok, %{user: user, endgame: endgame}} ->
|
|
socket
|
|
|> assign(:endgame, endgame)
|
|
|> assign(:user_rating, user.rating)
|
|
|
|
{:skipped, _attempt} ->
|
|
put_flash(
|
|
socket,
|
|
:info,
|
|
"Replay recorded. Your rating is unchanged because you played this recently."
|
|
)
|
|
end
|
|
|
|
_ ->
|
|
socket
|
|
end
|
|
end
|
|
|
|
defp user_rating(%{user: %{rating: rating}}), do: rating
|
|
defp user_rating(_), do: nil
|
|
|
|
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 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)
|
|
end
|
|
end
|
|
|
|
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
|
|
%{
|
|
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
|