Move renderer to its own module

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
-
+  alias Chessh.SSH.Client.Board.Renderer
-  @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()
 
   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
+
     {: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)}
+        :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, @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, @chess_board_height), x: cursor_x}
+        :down -> %{y: Utils.wrap_around(cursor_y, 1, Renderer.chess_board_height()), x: cursor_x}
-        :up -> %{y: Utils.wrap_around(cursor_y, -1, @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)}"
+      attempted_move = "#{Renderer.to_chess_coord(move_from)}#{Renderer.to_chess_coord(move_to)}"
-      Logger.debug("New move #{attempted_move}")
+
       :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} => Renderer.to_select_background(),
-          {new_cursor.y, new_cursor.x} => @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{
+  defp render_state(
-         width: _width,
+         %State{
-         height: _height,
+           binbo_pid: binbo_pid
-         binbo_pid: binbo_pid,
+         } = state
-         highlighted: highlighted
+       ) do
-       }) do
     {:ok, fen} = :binbo.get_fen(binbo_pid)
 
-    board =
+    Renderer.render_board_state(fen, state)
-      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
   end
 end

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

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
 

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(

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

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