1 files changed, 203 insertions, 16 deletions

diff --git a/lib/chessh/ssh/client/board/board.ex b/lib/chessh/ssh/client/board/board.ex
index 600917f..b7f6da6 100644
--- a/lib/chessh/ssh/client/board/board.ex
+++ b/lib/chessh/ssh/client/board/board.ex
@@ -1,6 +1,7 @@
 defmodule Chessh.SSH.Client.Board do
   alias IO.ANSI
   require Logger
+  alias Chessh.Utils
 
   @chess_board_height 8
   @chess_board_width 8
@@ -13,11 +14,14 @@ defmodule Chessh.SSH.Client.Board do
   @to_select_background ANSI.blue_background()
 
   defmodule State do
-    defstruct cursor: %{x: 0, y: 0},
+    defstruct cursor: %{x: 7, y: 7},
               highlighted: %{},
               move_from: nil,
               game_id: nil,
-              client_pid: nil
+              client_pid: nil,
+              binbo_pid: nil,
+              width: 0,
+              height: 0
   end
 
   use Chessh.SSH.Client.Screen
@@ -26,11 +30,17 @@ defmodule Chessh.SSH.Client.Board do
     :syn.add_node_to_scopes([:games])
     :ok = :syn.join(:games, {:game, game_id}, self())
 
-    {:ok, state}
+    :binbo.start()
+    {:ok, binbo_pid} = :binbo.new_server()
+    :binbo.new_game(binbo_pid)
+
+    {:ok, %State{state | binbo_pid: binbo_pid}}
   end
 
-  def handle_info({:attempted_move, move}, %State{client_pid: client_pid} = state) do
-    send(client_pid, {:send_to_ssh, ["hello, world!"]})
+  def handle_info({:new_move, move}, %State{binbo_pid: binbo_pid, client_pid: client_pid} = state) do
+    :binbo.move(binbo_pid, move)
+
+    send(client_pid, {:send_to_ssh, render_state(state)})
     {:noreply, state}
   end
 
@@ -47,10 +57,10 @@ defmodule Chessh.SSH.Client.Board do
       ) do
     new_cursor =
       case action do
-        :left -> %{y: cursor_y, x: cursor_x - 1}
-        :right -> %{y: cursor_y, x: cursor_x + 1}
-        :down -> %{y: cursor_y + 1, x: cursor_x}
-        :up -> %{y: cursor_y - 1, x: cursor_x}
+        :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}
         _ -> cursor
       end
 
@@ -68,6 +78,7 @@ defmodule Chessh.SSH.Client.Board do
 
     if move_from && move_to do
       attempted_move = "#{to_chess_coord(move_from)}#{to_chess_coord(move_to)}"
+      Logger.debug("New move #{attempted_move}")
       :syn.publish(:games, {:game, game_id}, {:new_move, attempted_move})
     end
 
@@ -78,25 +89,201 @@ defmodule Chessh.SSH.Client.Board do
         highlighted: %{
           new_move_from => @from_select_background,
           {new_cursor.y, new_cursor.x} => @to_select_background
-        }
+        },
+        width: width,
+        height: height
     }
 
-    send(client_pid, {:send_to_ssh, render_state(width, height, new_state)})
+    send(client_pid, {:send_to_ssh, render_state(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
+    send(client_pid, {:send_to_ssh, render_state(state)})
+    %State{state | width: width, height: height}
   end
 
-  defp render_state(width, height, %State{} = _state) do
-    [ANSI.clear(), "#{width}#{height}"]
+  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])}#{y + 1}"
+    "#{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