From 2ce03d4796ad54f332c70ff88f0a9f3a164bbc4a Mon Sep 17 00:00:00 2001 From: Simponic Date: Wed, 11 Jan 2023 09:54:05 -0700 Subject: Checkpoint\? --- lib/chessh/ssh/client/screen.ex | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 lib/chessh/ssh/client/screen.ex (limited to 'lib/chessh/ssh/client/screen.ex') diff --git a/lib/chessh/ssh/client/screen.ex b/lib/chessh/ssh/client/screen.ex new file mode 100644 index 0000000..2dd9f9c --- /dev/null +++ b/lib/chessh/ssh/client/screen.ex @@ -0,0 +1,31 @@ +defmodule Chessh.SSH.Client.Screen do + @callback handle_info( + {:render, width :: integer(), height :: integer()}, + state :: any() + ) :: + {:noreply, any()} + @callback handle_info({:input, width :: integer(), height :: integer(), action :: any()}) :: + {:noreply, any()} + + # @callback render(state :: Chessh.SSH.Client.State.t() | any()) :: any() + # @callback handle_input(action :: any(), state :: Chessh.SSH.Client.State.t()) :: + # Chessh.SSH.Client.State.t() + + defmacro __using__(_) do + quote do + @behaviour Chessh.SSH.Client.Screen + use GenServer + + @ascii_chars Application.compile_env!(:chessh, :ascii_chars_json_file) + |> File.read!() + |> Jason.decode!() + + def center_rect({rect_width, rect_height}, {parent_width, parent_height}) do + { + div(parent_height - rect_height, 2), + div(parent_width - rect_width, 2) + } + end + end + end +end -- cgit v1.2.3-70-g09d2 From 628c6d95a32ba0dea67ab046a480ddfca7432c9b Mon Sep 17 00:00:00 2001 From: Simponic Date: Wed, 11 Jan 2023 14:21:48 -0700 Subject: Done moving menu to genserver architecture --- lib/chessh/ssh/client/client.ex | 79 ++++++++++++++++++++++++++++------------- lib/chessh/ssh/client/menu.ex | 67 +++++++++++++++++----------------- lib/chessh/ssh/client/screen.ex | 25 +++++++------ lib/chessh/ssh/tui.ex | 33 ++++++++--------- 4 files changed, 119 insertions(+), 85 deletions(-) (limited to 'lib/chessh/ssh/client/screen.ex') diff --git a/lib/chessh/ssh/client/client.ex b/lib/chessh/ssh/client/client.ex index a5f7bec..216af71 100644 --- a/lib/chessh/ssh/client/client.ex +++ b/lib/chessh/ssh/client/client.ex @@ -1,22 +1,18 @@ defmodule Chessh.SSH.Client do alias IO.ANSI - alias Chessh.SSH.Client.Menu require Logger use GenServer @clear_codes [ ANSI.clear(), - ANSI.reset(), ANSI.home() ] - @max_terminal_width 255 - @max_terminal_height 127 - - @terminal_bad_dim_msg [ - @clear_codes | "The dimensions of your terminal are not within in the valid range" - ] + @min_terminal_width 64 + @min_terminal_height 31 + @max_terminal_width 200 + @max_terminal_height 100 defmodule State do defstruct tui_pid: nil, @@ -27,10 +23,10 @@ defmodule Chessh.SSH.Client do end @impl true - def init([%State{tui_pid: tui_pid} = state]) do + def init([%State{} = state]) do {:ok, screen_pid} = GenServer.start_link(Chessh.SSH.Client.Menu, [ - %Chessh.SSH.Client.Menu.State{tui_pid: tui_pid} + %Chessh.SSH.Client.Menu.State{client_pid: self()} ]) {:ok, %{state | screen_processes: [screen_pid]}} @@ -76,27 +72,36 @@ defmodule Chessh.SSH.Client do end end - # def handle( - # {:refresh, }, - # %State{screen_processes: [screen_pid | _] = screen_processes, width: width, height: height} = state - # ) do - # send(screen_pid, {:render, tui_pid, width, height}) - # {:noreply, state} - # end + def handle( + :refresh, + %State{} = state + ) do + render(state) + {:noreply, state} + end + + def handle( + {:send_to_ssh, data}, + %State{width: width, height: height, tui_pid: tui_pid} = state + ) do + case get_terminal_dim_msg(width, height) do + {true, msg} -> send(tui_pid, {:send_data, msg}) + {false, _} -> send(tui_pid, {:send_data, data}) + end + + {:noreply, state} + end def handle( {:resize, {width, height}}, %State{tui_pid: tui_pid, screen_processes: [screen_pid | _]} = state ) do - new_state = %State{state | width: width, height: height} - - if height <= @max_terminal_height && width <= @max_terminal_width do - send(screen_pid, {:render, width, height}) - else - send(tui_pid, {:send_data, @terminal_bad_dim_msg}) + case get_terminal_dim_msg(width, height) do + {true, msg} -> send(tui_pid, {:send_data, msg}) + {false, _} -> send(screen_pid, {:render, width, height}) end - {:noreply, new_state} + {:noreply, %State{state | width: width, height: height}} end def keymap(key) do @@ -113,4 +118,30 @@ defmodule Chessh.SSH.Client do x -> x end end + + defp get_terminal_dim_msg(width, height) do + case {height > @max_terminal_height, height < @min_terminal_height, + width > @max_terminal_width, width < @min_terminal_width} do + {true, _, _, _} -> {true, @clear_codes ++ ["The terminal height is too large."]} + {_, true, _, _} -> {true, @clear_codes ++ ["The terminal height is too small."]} + {_, _, true, _} -> {true, @clear_codes ++ ["The terminal width is too large"]} + {_, _, _, true} -> {true, @clear_codes ++ ["The terminal width is too small."]} + {false, false, false, false} -> {false, nil} + end + end + + defp render(%State{ + tui_pid: tui_pid, + width: width, + height: height, + screen_processes: [screen_pid | _] + }) do + {out_of_range, msg} = get_terminal_dim_msg(width, height) + + if out_of_range && msg do + send(tui_pid, {:send_data, msg}) + else + send(screen_pid, {:render, width, height}) + end + end end diff --git a/lib/chessh/ssh/client/menu.ex b/lib/chessh/ssh/client/menu.ex index a69ad88..7e2ffbc 100644 --- a/lib/chessh/ssh/client/menu.ex +++ b/lib/chessh/ssh/client/menu.ex @@ -5,18 +5,10 @@ defmodule Chessh.SSH.Client.Menu do require Logger defmodule State do - defstruct dy: 0, - dx: 0, - tui_pid: nil, + defstruct client_pid: nil, selected: 0 end - use Chessh.SSH.Client.Screen - - def init([%State{} = state | _]) do - {:ok, state} - end - @logo " Simponic's dP MP\"\"\"\"\"\"`MM MP\"\"\"\"\"\"`MM M\"\"MMMMM\"\"MM 88 M mmmmm..M M mmmmm..M M MMMMM MM @@ -25,6 +17,11 @@ defmodule Chessh.SSH.Client.Menu do 88. ... 88 88 88. ... M. .MMM' M M. .MMM' M M MMMMM MM `88888P' dP dP `88888P' Mb. .dM Mb. .dM M MMMMM MM MMMMMMMMMMM MMMMMMMMMMM MMMMMMMMMMMM" + use Chessh.SSH.Client.Screen + + def init([%State{} = state | _]) do + {:ok, state} + end # @options [ # {"Option 1", {Chessh.SSH.Client.Board, [%Chessh.SSH.Client.Board.State{}]}}, @@ -36,12 +33,7 @@ defmodule Chessh.SSH.Client.Menu do {"Option 3", {}} ] - def handle_info({:render, width, height}, %State{} = state) do - render(width, height, state) - {:noreply, state} - end - - def handle_info({:input, width, height, action}, %State{selected: selected} = state) do + def input(width, height, action, %State{client_pid: client_pid, selected: selected} = state) do new_state = case(action) do :up -> @@ -61,36 +53,43 @@ defmodule Chessh.SSH.Client.Menu do state end - render(width, height, new_state) - {:noreply, new_state} + send(client_pid, {:send_to_ssh, render_state(width, height, new_state)}) + new_state + end + + def render(width, height, %State{client_pid: client_pid} = state) do + send(client_pid, {:send_to_ssh, render_state(width, height, state)}) + state end - def render(width, height, %State{tui_pid: tui_pid, dy: dy, dx: dx, selected: selected}) do - text = String.split(@logo, "\n") + defp render_state( + width, + height, + %State{selected: selected} + ) do + logo_lines = String.split(@logo, "\n") {logo_width, logo_height} = Utils.text_dim(@logo) - {y, x} = center_rect({logo_width, logo_height + length(text)}, {width, height}) + {y, x} = center_rect({logo_width, logo_height + length(logo_lines)}, {width, height}) - rendered = + [ANSI.clear()] ++ Enum.flat_map( - Enum.zip(1..length(text), text), + Enum.zip(1..length(logo_lines), logo_lines), fn {i, line} -> [ - ANSI.cursor(y + i + dy, x + dx), + ANSI.cursor(y + i, x), line ] end ) ++ - Enum.flat_map( - Enum.zip(0..(length(@options) - 1), @options), - fn {i, {option, _}} -> - [ - ANSI.cursor(y + length(text) + i + dy, x + dx), - if(i == selected, do: ANSI.format([:light_cyan, "* #{option}"]), else: option) - ] - end - ) ++ [ANSI.home()] - - send(tui_pid, {:send_data, rendered}) + Enum.flat_map( + Enum.zip(0..(length(@options) - 1), @options), + fn {i, {option, _}} -> + [ + ANSI.cursor(y + length(logo_lines) + i + 1, x), + if(i == selected, do: ANSI.format([:bright, :light_cyan, "+ #{option}"]), else: option) + ] + end + ) ++ [ANSI.home()] end defp wrap_around(index, delta, length) do diff --git a/lib/chessh/ssh/client/screen.ex b/lib/chessh/ssh/client/screen.ex index 2dd9f9c..8eb9f21 100644 --- a/lib/chessh/ssh/client/screen.ex +++ b/lib/chessh/ssh/client/screen.ex @@ -1,21 +1,18 @@ defmodule Chessh.SSH.Client.Screen do - @callback handle_info( - {:render, width :: integer(), height :: integer()}, - state :: any() - ) :: - {:noreply, any()} - @callback handle_info({:input, width :: integer(), height :: integer(), action :: any()}) :: - {:noreply, any()} - - # @callback render(state :: Chessh.SSH.Client.State.t() | any()) :: any() - # @callback handle_input(action :: any(), state :: Chessh.SSH.Client.State.t()) :: - # Chessh.SSH.Client.State.t() + @callback render(width :: integer(), height :: integer(), state :: any()) :: any() + @callback input(width :: integer(), height :: integer(), action :: any(), state :: any()) :: + any() defmacro __using__(_) do quote do @behaviour Chessh.SSH.Client.Screen use GenServer + @clear_codes [ + IO.ANSI.clear(), + IO.ANSI.home() + ] + @ascii_chars Application.compile_env!(:chessh, :ascii_chars_json_file) |> File.read!() |> Jason.decode!() @@ -26,6 +23,12 @@ defmodule Chessh.SSH.Client.Screen do div(parent_width - rect_width, 2) } end + + def handle_info({:render, width, height}, state), + do: {:noreply, render(width, height, state)} + + def handle_info({:input, width, height, action}, state), + do: {:noreply, input(width, height, action, state)} end end end diff --git a/lib/chessh/ssh/tui.ex b/lib/chessh/ssh/tui.ex index 5d43760..c1c763b 100644 --- a/lib/chessh/ssh/tui.ex +++ b/lib/chessh/ssh/tui.ex @@ -26,7 +26,7 @@ defmodule Chessh.SSH.Tui do {:ok, init_state} end - def handle_msg({:ssh_channel_up, channel_id, connection_ref}, state) do + def handle_msg({:ssh_channel_up, channel_id, connection_ref}, %State{} = state) do Logger.debug("SSH channel up #{inspect(:ssh.connection_info(connection_ref))}") connected_player = @@ -54,7 +54,7 @@ defmodule Chessh.SSH.Tui do :syn.join(:player_sessions, {:session, session.id}, self()) {:ok, - %{ + %State{ state | channel_id: channel_id, connection_ref: connection_ref, @@ -66,7 +66,7 @@ defmodule Chessh.SSH.Tui do def handle_msg( {:EXIT, client_pid, _reason}, - %{client_pid: client_pid, channel_id: channel_id} = state + %State{client_pid: client_pid, channel_id: channel_id} = state ) do send(client_pid, :quit) {:stop, channel_id, state} @@ -74,7 +74,7 @@ defmodule Chessh.SSH.Tui do def handle_msg( {:send_data, data}, - %{connection_ref: connection_ref, channel_id: channel_id} = state + %State{connection_ref: connection_ref, channel_id: channel_id} = state ) do :ssh_connection.send(connection_ref, channel_id, data) {:ok, state} @@ -82,7 +82,7 @@ defmodule Chessh.SSH.Tui do def handle_msg( :session_closed, - %{connection_ref: connection_ref, channel_id: channel_id} = state + %State{connection_ref: connection_ref, channel_id: channel_id} = state ) do :ssh_connection.send(connection_ref, channel_id, @session_closed_message) {:stop, channel_id, state} @@ -94,7 +94,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, _connection_handler, {:data, _channel_id, _type, data}}, - state + %State{} = state ) do send(state.client_pid, {:data, data}) {:ok, state} @@ -103,7 +103,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, connection_handler, {:pty, channel_id, want_reply?, {_term, width, height, _pixwidth, _pixheight, _opts}}}, - state + %State{client_pid: client_pid} = state ) do Logger.debug("#{inspect(state.player_session)} has requested a PTY") :ssh_connection.reply_request(connection_handler, want_reply?, :success, channel_id) @@ -128,12 +128,12 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, _connection_handler, {:window_change, _channel_id, width, height, _pixwidth, _pixheight}}, - %{client_pid: client_pid} = state + %State{client_pid: client_pid} = state ) do send(client_pid, {:resize, {width, height}}) {:ok, - %{ + %State{ state | width: width, height: height @@ -157,12 +157,13 @@ defmodule Chessh.SSH.Tui do } ]) - {:ok, %{state | client_pid: client_pid}} + send(client_pid, :refresh) + {:ok, %State{state | client_pid: client_pid}} end def handle_ssh_msg( {:ssh_cm, connection_handler, {:exec, channel_id, want_reply?, cmd}}, - state + %State{} = state ) do :ssh_connection.reply_request(connection_handler, want_reply?, :success, channel_id) Logger.debug("EXEC #{cmd}") @@ -171,7 +172,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, _connection_handler, {:eof, _channel_id}}, - state + %State{} = state ) do Logger.debug("EOF") {:ok, state} @@ -179,7 +180,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, _connection_handler, {:signal, _channel_id, signal}}, - state + %State{} = state ) do Logger.debug("SIGNAL #{signal}") {:ok, state} @@ -187,7 +188,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, _connection_handler, {:exit_signal, channel_id, signal, err, lang}}, - state + %State{} = state ) do Logger.debug("EXIT SIGNAL #{signal} #{err} #{lang}") {:stop, channel_id, state} @@ -195,7 +196,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( {:ssh_cm, _connection_handler, {:exit_STATUS, channel_id, status}}, - state + %State{} = state ) do Logger.debug("EXIT STATUS #{status}") {:stop, channel_id, state} @@ -203,7 +204,7 @@ defmodule Chessh.SSH.Tui do def handle_ssh_msg( msg, - %{channel_id: channel_id} = state + %State{channel_id: channel_id} = state ) do Logger.debug("UNKOWN MESSAGE #{inspect(msg)}") {:stop, channel_id, state} -- cgit v1.2.3-70-g09d2 From 07eaad9b8ded7a719183eec84faaf5b168744f01 Mon Sep 17 00:00:00 2001 From: Logan Hunt Date: Fri, 13 Jan 2023 12:20:01 -0700 Subject: Move renderer to its own module --- lib/chessh/ssh/client/board/board.ex | 239 ++++-------------------------- lib/chessh/ssh/client/board/renderer.ex | 248 ++++++++++++++++++++++++++++++++ lib/chessh/ssh/client/client.ex | 2 +- lib/chessh/ssh/client/menu.ex | 2 +- lib/chessh/ssh/client/screen.ex | 16 --- lib/chessh/utils.ex | 19 +++ 6 files changed, 296 insertions(+), 230 deletions(-) create mode 100644 lib/chessh/ssh/client/board/renderer.ex (limited to 'lib/chessh/ssh/client/screen.ex') diff --git a/lib/chessh/ssh/client/board/board.ex b/lib/chessh/ssh/client/board/board.ex index b7f6da6..4c57e07 100644 --- a/lib/chessh/ssh/client/board/board.ex +++ b/lib/chessh/ssh/client/board/board.ex @@ -1,17 +1,7 @@ defmodule Chessh.SSH.Client.Board do - alias IO.ANSI require Logger alias Chessh.Utils - - @chess_board_height 8 - @chess_board_width 8 - @tile_width 7 - @tile_height 4 - - @dark_piece_color ANSI.magenta() - @light_piece_color ANSI.red() - @from_select_background ANSI.green_background() - @to_select_background ANSI.blue_background() + alias Chessh.SSH.Client.Board.Renderer defmodule State do defstruct cursor: %{x: 7, y: 7}, @@ -22,6 +12,8 @@ defmodule Chessh.SSH.Client.Board do binbo_pid: nil, width: 0, height: 0 + + # flipped: false end use Chessh.SSH.Client.Screen @@ -38,9 +30,14 @@ defmodule Chessh.SSH.Client.Board do end def handle_info({:new_move, move}, %State{binbo_pid: binbo_pid, client_pid: client_pid} = state) do - :binbo.move(binbo_pid, move) + case :binbo.move(binbo_pid, move) do + {:ok, :continue} -> + send(client_pid, {:send_to_ssh, render_state(state)}) + + _ -> + nil + end - send(client_pid, {:send_to_ssh, render_state(state)}) {:noreply, state} end @@ -53,14 +50,15 @@ defmodule Chessh.SSH.Client.Board do game_id: game_id, cursor: %{x: cursor_x, y: cursor_y} = cursor, client_pid: client_pid + # flipped: flipped } = state ) do new_cursor = case action do - :left -> %{y: cursor_y, x: Utils.wrap_around(cursor_x, -1, @chess_board_width)} - :right -> %{y: cursor_y, x: Utils.wrap_around(cursor_x, 1, @chess_board_width)} - :down -> %{y: Utils.wrap_around(cursor_y, 1, @chess_board_height), x: cursor_x} - :up -> %{y: Utils.wrap_around(cursor_y, -1, @chess_board_height), x: cursor_x} + :left -> %{y: cursor_y, x: Utils.wrap_around(cursor_x, -1, Renderer.chess_board_width())} + :right -> %{y: cursor_y, x: Utils.wrap_around(cursor_x, 1, Renderer.chess_board_width())} + :down -> %{y: Utils.wrap_around(cursor_y, 1, Renderer.chess_board_height()), x: cursor_x} + :up -> %{y: Utils.wrap_around(cursor_y, -1, Renderer.chess_board_height()), x: cursor_x} _ -> cursor end @@ -76,9 +74,10 @@ defmodule Chessh.SSH.Client.Board do {move_from, nil} end + # TODO: Check move here, then publish new move, subscribers get from DB instead if move_from && move_to do - attempted_move = "#{to_chess_coord(move_from)}#{to_chess_coord(move_to)}" - Logger.debug("New move #{attempted_move}") + attempted_move = "#{Renderer.to_chess_coord(move_from)}#{Renderer.to_chess_coord(move_to)}" + :syn.publish(:games, {:game, game_id}, {:new_move, attempted_move}) end @@ -87,11 +86,12 @@ defmodule Chessh.SSH.Client.Board do | cursor: new_cursor, move_from: new_move_from, highlighted: %{ - new_move_from => @from_select_background, - {new_cursor.y, new_cursor.x} => @to_select_background + {new_cursor.y, new_cursor.x} => Renderer.to_select_background(), + new_move_from => Renderer.from_select_background() }, width: width, height: height + # flipped: if(action == "f", do: !flipped, else: flipped) } send(client_pid, {:send_to_ssh, render_state(new_state)}) @@ -103,198 +103,13 @@ defmodule Chessh.SSH.Client.Board do %State{state | width: width, height: height} end - defp render_state(%State{ - width: _width, - height: _height, - binbo_pid: binbo_pid, - highlighted: highlighted - }) do - {:ok, fen} = :binbo.get_fen(binbo_pid) - - board = - draw_board( - fen, - {@tile_width, @tile_height}, - highlighted - ) - - [ANSI.home()] ++ - Enum.map( - Enum.zip(1..length(board), board), - fn {i, line} -> - [ANSI.cursor(i, 0), line] - end - ) - end - - defp make_board({tile_width, tile_height}) do - rows = - Enum.map(0..(@chess_board_height - 1), fn row -> - Enum.map(0..(@chess_board_width - 1), fn col -> - if(tileIsLight(row, col), do: ' ', else: '▊') - |> List.duplicate(tile_width) - end) - |> Enum.join("") - end) - - Enum.flat_map(rows, fn row -> Enum.map(1..tile_height, fn _ -> row end) end) - end - - defp to_chess_coord({y, x}) - when x >= 0 and x < @chess_board_width and y >= 0 and y < @chess_board_height do - "#{List.to_string([?a + x])}#{@chess_board_height - y}" - end - - defp tileIsLight(row, col) do - rem(row, 2) == rem(col, 2) - end - - defp skip_cols_or_place_piece_reduce(char, {curr_column, data}, rowI) do - case Integer.parse(char) do - {skip, ""} -> - {curr_column + skip, data} - - _ -> - case piece_type(char) do - nil -> - {curr_column, data} - - type -> - shade = if(char != String.capitalize(char), do: "light", else: "dark") - - {curr_column + 1, - Map.put( - data, - "#{rowI}, #{curr_column}", - {shade, type} - )} - end - end - end - - defp make_coordinate_to_piece_art_map(fen) do - rows = - String.split(fen, " ") - |> List.first() - |> String.split("/") - - Enum.zip(rows, 0..(length(rows) - 1)) - |> Enum.map(fn {row, rowI} -> - {@chess_board_height, pieces_per_row} = - Enum.reduce( - String.split(row, ""), - {0, %{}}, - &skip_cols_or_place_piece_reduce(&1, &2, rowI) - ) - - pieces_per_row - end) - |> Enum.reduce(%{}, fn pieces_map_for_this_row, acc -> - Map.merge(acc, pieces_map_for_this_row) - end) - end - - defp draw_board( - fen, - {tile_width, tile_height} = tile_dims, - highlights + defp render_state( + %State{ + binbo_pid: binbo_pid + } = state ) do - coordinate_to_piece = make_coordinate_to_piece_art_map(fen) - board = make_board(tile_dims) - - Enum.zip_with([board, 0..(length(board) - 1)], fn [rowStr, row] -> - curr_y = div(row, tile_height) - - %{row_chars: row_chars} = - Enum.reduce( - Enum.zip(String.graphemes(rowStr), 0..(String.length(rowStr) - 1)), - %{current_color: ANSI.black(), row_chars: []}, - fn {char, col}, %{current_color: current_color, row_chars: row_chars} = row_state -> - curr_x = div(col, tile_width) - key = "#{curr_y}, #{curr_x}" - relative_to_tile_col = col - curr_x * tile_width - - prefix = - if relative_to_tile_col == 0 do - case Map.fetch(highlights, {curr_y, curr_x}) do - {:ok, color} -> - color - - _ -> - ANSI.default_background() - end - end - - case Map.fetch(coordinate_to_piece, key) do - {:ok, {shade, type}} -> - piece = @ascii_chars["pieces"][shade][type] - piece_line = Enum.at(piece, row - curr_y * tile_height) - - piece_line_len = String.length(piece_line) - pad_left_right = div(tile_width - piece_line_len, 2) - - if relative_to_tile_col >= pad_left_right && - relative_to_tile_col < tile_width - pad_left_right do - piece_char = String.at(piece_line, relative_to_tile_col - pad_left_right) - new_char = if piece_char == " ", do: char, else: piece_char - - color = - if piece_char == " ", - do: ANSI.default_color(), - else: if(shade == "dark", do: @dark_piece_color, else: @light_piece_color) - - if color != current_color do - %{ - row_state - | current_color: color, - row_chars: row_chars ++ [prefix, color, new_char] - } - else - %{ - row_state - | current_color: current_color, - row_chars: row_chars ++ [prefix, new_char] - } - end - else - %{ - row_state - | current_color: ANSI.default_color(), - row_chars: row_chars ++ [prefix, ANSI.default_color(), char] - } - end - - _ -> - if ANSI.white() != current_color do - %{ - row_state - | current_color: ANSI.default_color(), - row_chars: row_chars ++ [prefix, ANSI.default_color(), char] - } - else - %{ - row_state - | row_chars: row_chars ++ [prefix, char] - } - end - end - end - ) - - row_chars - |> Enum.join("") - end) - end + {:ok, fen} = :binbo.get_fen(binbo_pid) - defp piece_type(char) do - case String.capitalize(char) do - "P" -> "pawn" - "N" -> "knight" - "R" -> "rook" - "B" -> "bishop" - "K" -> "king" - "Q" -> "queen" - _ -> nil - end + Renderer.render_board_state(fen, state) end end diff --git a/lib/chessh/ssh/client/board/renderer.ex b/lib/chessh/ssh/client/board/renderer.ex new file mode 100644 index 0000000..16987c7 --- /dev/null +++ b/lib/chessh/ssh/client/board/renderer.ex @@ -0,0 +1,248 @@ +defmodule Chessh.SSH.Client.Board.Renderer do + alias IO.ANSI + alias Chessh.Utils + alias Chessh.SSH.Client.Board + + @chess_board_height 8 + @chess_board_width 8 + + @tile_width 7 + @tile_height 4 + + @from_select_background ANSI.green_background() + @to_select_background ANSI.blue_background() + @dark_piece_color ANSI.red() + @light_piece_color ANSI.magenta() + + def chess_board_height(), do: @chess_board_height + def chess_board_width(), do: @chess_board_width + def to_select_background(), do: @to_select_background + def from_select_background(), do: @from_select_background + + def to_chess_coord({y, x}) + when x >= 0 and x < @chess_board_width and y >= 0 and y < @chess_board_height do + "#{List.to_string([?a + x])}#{@chess_board_height - y}" + end + + def render_board_state(fen, %Board.State{ + width: _width, + height: _height, + highlighted: highlighted + }) do + board = + draw_board( + fen, + {@tile_width, @tile_height}, + highlighted + ) + + [ANSI.home()] ++ + Enum.map( + Enum.zip(1..length(board), board), + fn {i, line} -> + [ANSI.cursor(i, 0), line] + end + ) + end + + defp tileIsLight(row, col) do + rem(row, 2) == rem(col, 2) + end + + defp piece_type(char) do + case String.capitalize(char) do + "P" -> "pawn" + "N" -> "knight" + "R" -> "rook" + "B" -> "bishop" + "K" -> "king" + "Q" -> "queen" + _ -> nil + end + end + + defp skip_cols_or_place_piece_reduce(char, {curr_column, data}, rowI) do + case Integer.parse(char) do + {skip, ""} -> + {curr_column + skip, data} + + _ -> + case piece_type(char) do + nil -> + {curr_column, data} + + type -> + shade = if(char == String.capitalize(char), do: "light", else: "dark") + + {curr_column + 1, + Map.put( + data, + "#{rowI}, #{curr_column}", + {shade, type} + )} + end + end + end + + defp make_coordinate_to_piece_art_map(fen) do + rows = + String.split(fen, " ") + |> List.first() + |> String.split("/") + + Enum.zip(rows, 0..(length(rows) - 1)) + |> Enum.map(fn {row, rowI} -> + {@chess_board_height, pieces_per_row} = + Enum.reduce( + String.split(row, ""), + {0, %{}}, + &skip_cols_or_place_piece_reduce(&1, &2, rowI) + ) + + pieces_per_row + end) + |> Enum.reduce(%{}, fn pieces_map_for_this_row, acc -> + Map.merge(acc, pieces_map_for_this_row) + end) + end + + defp draw_board( + fen, + {tile_width, tile_height} = tile_dims, + highlights + ) do + coordinate_to_piece = make_coordinate_to_piece_art_map(fen) + board = make_board(tile_dims) + + (Enum.zip_with([board, 0..(length(board) - 1)], fn [row_str, row] -> + curr_y = div(row, tile_height) + + %{row_chars: row_chars} = + Enum.reduce( + Enum.zip(String.graphemes(row_str), 0..(String.length(row_str) - 1)), + %{current_color: ANSI.black(), row_chars: []}, + fn {char, col}, %{current_color: current_color, row_chars: row_chars} = row_state -> + curr_x = div(col, tile_width) + key = "#{curr_y}, #{curr_x}" + relative_to_tile_col = col - curr_x * tile_width + + prefix = + if relative_to_tile_col == 0 do + case Map.fetch(highlights, {curr_y, curr_x}) do + {:ok, color} -> + color + + _ -> + ANSI.default_background() + end + end + + case Map.fetch(coordinate_to_piece, key) do + {:ok, {shade, type}} -> + piece = Utils.ascii_chars()["pieces"][shade][type] + piece_line = Enum.at(piece, row - curr_y * tile_height) + + piece_line_len = String.length(piece_line) + pad_left_right = div(tile_width - piece_line_len, 2) + + if relative_to_tile_col >= pad_left_right && + relative_to_tile_col < tile_width - pad_left_right do + piece_char = String.at(piece_line, relative_to_tile_col - pad_left_right) + new_char = if piece_char == " ", do: char, else: piece_char + + color = + if piece_char == " ", + do: ANSI.default_color(), + else: if(shade == "dark", do: @dark_piece_color, else: @light_piece_color) + + if color != current_color do + %{ + row_state + | current_color: color, + row_chars: row_chars ++ [prefix, color, new_char] + } + else + %{ + row_state + | current_color: current_color, + row_chars: row_chars ++ [prefix, new_char] + } + end + else + %{ + row_state + | current_color: ANSI.default_color(), + row_chars: row_chars ++ [prefix, ANSI.default_color(), char] + } + end + + _ -> + if ANSI.white() != current_color do + %{ + row_state + | current_color: ANSI.default_color(), + row_chars: row_chars ++ [prefix, ANSI.default_color(), char] + } + else + %{ + row_state + | row_chars: row_chars ++ [prefix, char] + } + end + end + end + ) + + curr_num = Utils.ascii_chars()["numbers"][Integer.to_string(curr_y)] + curr_num_line_no = rem(row, @tile_height) + + Enum.join( + [ + String.pad_trailing( + if(curr_num_line_no < length(curr_num), + do: Enum.at(curr_num, curr_num_line_no), + else: "" + ), + @tile_width + ) + ] ++ row_chars, + "" + ) + end) ++ + Enum.map(0..(@tile_height - 1), fn row -> + String.duplicate(" ", @tile_width) <> + (Enum.map(0..(@chess_board_width - 1), fn col -> + curr_letter = Utils.ascii_chars()["letters"][List.to_string([?a + col])] + curr_letter_line_no = rem(row, @tile_height) + + curr_line = + if(curr_letter_line_no < length(curr_letter), + do: Enum.at(curr_letter, curr_letter_line_no), + else: "" + ) + + center_prefix_len = div(@tile_width - String.length(curr_line), 2) + + String.pad_trailing( + String.duplicate(" ", center_prefix_len) <> curr_line, + @tile_width + ) + end) + |> Enum.join("")) + end)) + |> Enum.map(fn row_line -> "#{ANSI.default_background()}#{row_line}" end) + end + + defp make_board({tile_width, tile_height}) do + rows = + Enum.map(0..(@chess_board_height - 1), fn row -> + Enum.map(0..(@chess_board_width - 1), fn col -> + if(tileIsLight(row, col), do: '▊', else: ' ') + |> List.duplicate(tile_width) + end) + |> Enum.join("") + end) + + Enum.flat_map(rows, fn row -> Enum.map(1..tile_height, fn _ -> row end) end) + end +end diff --git a/lib/chessh/ssh/client/client.ex b/lib/chessh/ssh/client/client.ex index 0560ce0..10dd3b2 100644 --- a/lib/chessh/ssh/client/client.ex +++ b/lib/chessh/ssh/client/client.ex @@ -10,7 +10,7 @@ defmodule Chessh.SSH.Client do ] @min_terminal_width 64 - @min_terminal_height 31 + @min_terminal_height 38 @max_terminal_width 220 @max_terminal_height 100 diff --git a/lib/chessh/ssh/client/menu.ex b/lib/chessh/ssh/client/menu.ex index 6eb2bdd..c207872 100644 --- a/lib/chessh/ssh/client/menu.ex +++ b/lib/chessh/ssh/client/menu.ex @@ -65,7 +65,7 @@ defmodule Chessh.SSH.Client.Menu do ) do logo_lines = String.split(@logo, "\n") {logo_width, logo_height} = Utils.text_dim(@logo) - {y, x} = center_rect({logo_width, logo_height + length(logo_lines)}, {width, height}) + {y, x} = Utils.center_rect({logo_width, logo_height + length(logo_lines)}, {width, height}) [ANSI.clear()] ++ Enum.flat_map( diff --git a/lib/chessh/ssh/client/screen.ex b/lib/chessh/ssh/client/screen.ex index 8eb9f21..0437b23 100644 --- a/lib/chessh/ssh/client/screen.ex +++ b/lib/chessh/ssh/client/screen.ex @@ -8,22 +8,6 @@ defmodule Chessh.SSH.Client.Screen do @behaviour Chessh.SSH.Client.Screen use GenServer - @clear_codes [ - IO.ANSI.clear(), - IO.ANSI.home() - ] - - @ascii_chars Application.compile_env!(:chessh, :ascii_chars_json_file) - |> File.read!() - |> Jason.decode!() - - def center_rect({rect_width, rect_height}, {parent_width, parent_height}) do - { - div(parent_height - rect_height, 2), - div(parent_width - rect_width, 2) - } - end - def handle_info({:render, width, height}, state), do: {:noreply, render(width, height, state)} diff --git a/lib/chessh/utils.ex b/lib/chessh/utils.ex index d1acf44..20a8b96 100644 --- a/lib/chessh/utils.ex +++ b/lib/chessh/utils.ex @@ -1,4 +1,23 @@ defmodule Chessh.Utils do + @ascii_chars Application.compile_env!(:chessh, :ascii_chars_json_file) + |> File.read!() + |> Jason.decode!() + + @clear_codes [ + IO.ANSI.clear(), + IO.ANSI.home() + ] + + def ascii_chars(), do: @ascii_chars + def clear_codes(), do: @clear_codes + + def center_rect({rect_width, rect_height}, {parent_width, parent_height}) do + { + div(parent_height - rect_height, 2), + div(parent_width - rect_width, 2) + } + end + def pid_to_str(pid) do pid |> :erlang.pid_to_list() -- cgit v1.2.3-70-g09d2