Move renderer to its own module

This commit is contained in:
Logan Hunt 2023-01-13 12:20:01 -07:00
parent a93119b250
commit 07eaad9b8d
No known key found for this signature in database
GPG Key ID: 8AC6A4B840C0EC49
6 changed files with 296 additions and 230 deletions

View File

@ -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
defp render_state(
%State{
binbo_pid: binbo_pid
} = state
) 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
) 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
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

View File

@ -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

View File

@ -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

View File

@ -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(

View File

@ -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)}

View File

@ -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()