Move renderer to its own module

1 files changed, 27 insertions, 212 deletions

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