chess_tui 0.41.4

data/lib/chess/game/game.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Game class
+  class Game
+    include Display
+    include Mouse
+    include Save
+    include ValidMoves
+    include WinAndDraw
+
+    def initialize(player = Chess::Player)
+      @white_player = player.new
+      @black_player = player.new
+    end
+
+    # select different actions based on what was clicked
+    # @param board [Chess::Board]
+    # @param clicked [String]
+    # @param board_pos [Array]
+    # @param mouse_coord [Array]
+    # @return [nil,Integer] nil or Exit Code 0
+    def select_click_action(board, clicked, board_pos, mouse_coord)
+      return if clicked == 'outside'
+
+      if clicked == 'board'
+        board_action(board, board_pos)
+      else
+        button_action(board, mouse_coord)
+      end
+    end
+
+    # actions for clicks on board
+    # @param board [Chess:Board]
+    # @param board_pos [Array]
+    # @return [nil,Integer] nil or Exit Code 0
+    def board_action(board, board_pos)
+      player = if board.current_player == 'w'
+                 @white_player
+               else
+                 @black_player
+               end
+      update_castling_rights(board)
+      valid_moves = player_turn(player, board, board_pos)
+      update_king_status(board)
+      redraw_display(board.data, valid_moves)
+      detect_win_or_draws(board)
+    end
+
+    # actions for clicks on buttons
+    # @param board [Chess::Board]
+    # @param mouse_coord [Array]
+    # @return [nil,Integer] nil or Exit Code 0
+    def button_action(board, mouse_coord)
+      type = button_type(mouse_coord)
+      if type == 'save&exit'
+        save_and_exit(board)
+      else
+        game_exit
+      end
+    end
+
+    # player turn to select move
+    # @param player [Chess::Player]
+    # @param board [Chess::Board]
+    # @param board_pos [Array]
+    # @return [void]
+    def player_turn(player, board, board_pos)
+      piece = board.piece_at(*board_pos)
+      if player.selected_piece == '' || same_color?(board.current_player, piece)
+        select_piece(piece, player, board)
+      else
+        select_move(player, board, board_pos)
+        []
+      end
+    end
+
+    # player turn to select move
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param player [Chess::Player]
+    # @param board [Chess::Board]
+    # @return [void]
+    def select_piece(piece, player, board)
+      player.selected_piece = piece if same_color?(board.current_player, piece)
+      if player.selected_piece == ''
+        []
+      else
+        player.selected_piece.valid_moves = valid_moves(piece, board)
+      end
+    end
+
+    # selects move to play
+    #
+    # @param player [Chess::Player]
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @return [void]
+    def select_move(player, board, move_pos)
+      player.select_move(board, move_pos)
+      player.selected_piece.valid_moves = []
+      player.selected_piece = ''
+    end
+
+    # checks if current_player and piece have same color
+    #
+    # @param current_player [String] from {Chess::Board#current_player}
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    def same_color?(current_player, piece)
+      piece.color.chr == current_player unless piece == ''
+    end
+
+    # updates king's @in_check attribute
+    #
+    # @param board [Chess::Board]
+    # @return [void]
+    def update_king_status(board)
+      current_player = board.current_player
+      board.current_player = 'b'
+      board.white_king.in_check?(board, board.black_pieces)
+      board.current_player = 'w'
+      board.black_king.in_check?(board, board.white_pieces)
+      board.current_player = current_player
+    end
+
+    # updates castling_rights for board
+    #
+    # @param board [Chess::Board]
+    # @return [void]
+    def update_castling_rights(board)
+      return if board.castling_rights == ''
+
+      location_piece_color_and_rights = {
+        h0: [Chess::Pieces::Rook, 'w', 'K'],
+        a0: [Chess::Pieces::Rook, 'w', 'Q'],
+        e0: [Chess::Pieces::King, 'w', 'KQ'],
+        h7: [Chess::Pieces::Rook, 'b', 'k'],
+        a7: [Chess::Pieces::Rook, 'b', 'q'],
+        e7: [Chess::Pieces::King, 'b', 'kq']
+      }
+      update_castling_rights_for_each_pos(board, location_piece_color_and_rights)
+    end
+
+    # helper method for {#update_castling_rights}
+    #
+    # @param board [Chess::Board]
+    # @param  location_piece_color_and_rights [Hash]
+    # @return [void]
+    def update_castling_rights_for_each_pos(board, location_piece_color_and_rights) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      location_piece_color_and_rights.each_key do |pos|
+        type = location_piece_color_and_rights[pos].first
+        color = location_piece_color_and_rights[pos][1]
+        rights = location_piece_color_and_rights[pos].last
+        position = pos.to_s.chars
+        file = position.first
+        rank = position.last.to_i
+        piece = board.piece_at(file, rank)
+        rights = rights.chars
+        rights.each do |right|
+          board.castling_rights.sub!(right, '') unless piece.is_a?(type) && same_color?(color, piece)
+        end
+      end
+    end
+  end
+end

data/lib/chess/game/valid_moves.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # ValidMoves
+  module ValidMoves
+    # find valid_moves for given piece on the given board
+    #
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @return [Array] valid_moves_arr
+    def valid_moves(piece, board)
+      possible_moves = piece.possible_moves(board)
+      new_player = Player.new
+      fen_code = generate_fen_code(board)
+
+      if piece.is_a?(Pieces::King)
+        valid_moves_for_king(board, piece, possible_moves, fen_code, new_player)
+      else
+        valid_moves_from_possible_moves(piece, possible_moves, fen_code, new_player)
+      end
+    end
+
+    # find valid_moves from possible_moves
+    #
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param possible_moves [Array]
+    # @param fen_code [String]
+    # @param new_player [Chess::Player]
+    # @return [Array] valid_moves_arr
+    def valid_moves_from_possible_moves(piece, possible_moves, fen_code, new_player)
+      valid_moves_arr = []
+      possible_moves.each do |move|
+        invalid = invalid_normal_move?(move, piece, fen_code, new_player)
+        valid_moves_arr << move unless invalid
+      end
+      valid_moves_arr
+    end
+
+    # check if given move is invalid
+    #
+    # @param move [Array]
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param fen_code [String]
+    # @param new_player [Chess::Player]
+    def invalid_normal_move?(move, piece, fen_code, new_player)
+      new_board = Chess::Board.new(fen_code)
+      new_player.selected_piece = new_board.piece_at(*piece.pos)
+      new_player.play_move_by_type(new_player.selected_piece, new_board, move, inside_valid_moves_flag: true)
+      king_comes_in_check?(piece, new_board)
+    end
+
+    # find valid_moves for given king on the given board
+    #
+    # @param board [Chess::Board]
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param possible_moves [Array]
+    # @param fen_code [String]
+    # @param new_player [Chess::Player]
+    # @return [Array] valid_moves_arr
+    def valid_moves_for_king(board, piece, possible_moves, fen_code, new_player) # rubocop:disable Metrics/MethodLength
+      valid_moves_arr = []
+      castling_moves = piece.castling_moves(board)
+      invalid = false
+      possible_moves.each do |move|
+        invalid = if castling_moves.include?(move)
+                    invalid_castling_move?(move, piece, fen_code, new_player)
+                  else
+                    invalid_normal_move?(move, piece, fen_code, new_player)
+                  end
+        valid_moves_arr << move unless invalid
+      end
+      valid_moves_arr
+    end
+
+    # Check if given castling move is invalid
+    #
+    # @param move [Array]
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param fen_code [String]
+    # @param new_player [Chess::Player]
+    def invalid_castling_move?(move, piece, fen_code, new_player)
+      return true if piece.in_check
+
+      file = move.first
+      if file.downcase == 'c'
+        invalid_queen_side_castle?(move, piece, fen_code, new_player)
+      elsif file.downcase == 'g'
+        invalid_king_side_castle?(move, piece, fen_code, new_player)
+      end
+    end
+
+    # helper method for {#invalid_castling_move?}
+    # @param (see #invalid_castling_move?)
+    def invalid_queen_side_castle?(move, piece, fen_code, new_player)
+      comes_in_check = castling_king_passes_check?(move, piece, fen_code, new_player)
+      move = ['d', move.last]
+      passes_check = castling_king_passes_check?(move, piece, fen_code, new_player)
+      passes_check || comes_in_check
+    end
+
+    # helper method for {#invalid_castling_move?}
+    # @param (see #invalid_castling_move?)
+    def invalid_king_side_castle?(move, piece, fen_code, new_player)
+      comes_in_check = castling_king_passes_check?(move, piece, fen_code, new_player)
+      move = ['f', move.last]
+      passes_check = castling_king_passes_check?(move, piece, fen_code, new_player)
+      passes_check || comes_in_check
+    end
+
+    # helper method for {#invalid_castling_move?}
+    # @param (see #invalid_castling_move?)
+    def castling_king_passes_check?(move, piece, fen_code, new_player)
+      new_board = Chess::Board.new(fen_code)
+      new_player.selected_piece = new_board.piece_at(*piece.pos)
+      new_player.play_move_by_type(new_player.selected_piece, new_board, move, inside_valid_moves_flag: true)
+      king_comes_in_check?(piece, new_board)
+    end
+
+    # Checks if king comes in check
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param new_board new board obj of [Chess::Board]
+    def king_comes_in_check?(piece, new_board)
+      if piece.white?
+        new_board.white_king.in_check?(new_board, new_board.black_pieces)
+      else
+        new_board.black_king.in_check?(new_board, new_board.white_pieces)
+      end
+    end
+  end
+end

data/lib/chess/game/win_and_draw.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # WinAndDraw
+  module WinAndDraw
+    # detects wins or draws and exits the game
+    #
+    # @param board [Chess::Board]
+    # @return [nil,Integer] nil or Exit Code 0
+    def detect_win_or_draws(board) # rubocop:disable Metrics/MethodLength
+      if checkmate?(board)
+        puts 'Checkmate!'
+        return game_exit
+      end
+
+      if stalemate?(board)
+        puts 'Stalemate!'
+        return game_exit
+      end
+
+      return unless fifty_move_draw?(board)
+
+      puts 'draw'
+      game_exit
+    end
+
+    # check if player is in checkmate
+    #
+    # @param board [Chess::Board]
+    def checkmate?(board)
+      in_check = if board.current_player == 'w'
+                   board.white_king.in_check
+                 else
+                   board.black_king.in_check
+                 end
+      return false unless in_check
+
+      return false if any_legal_move?(board)
+
+      true
+    end
+
+    # check if player is in stalemate
+    #
+    # @param board [Chess::Board]
+    def stalemate?(board)
+      in_check = if board.current_player == 'w'
+                   board.white_king.in_check
+                 else
+                   board.black_king.in_check
+                 end
+      return false if in_check
+
+      return false if any_legal_move?(board)
+
+      true
+    end
+
+    # check if any legal move available
+    #
+    # @param board [Chess::Board]
+    def any_legal_move?(board)
+      pieces = if board.current_player == 'w'
+                 board.white_pieces
+               else
+                 board.black_pieces
+               end
+      total_moves = []
+      pieces.each do |piece|
+        total_moves += valid_moves(piece, board)
+      end
+      total_moves != []
+    end
+
+    # check if there's a fifty_move draw (100 half moves)
+    #
+    # @param board [Chess::Board]
+    def fifty_move_draw?(board)
+      board.half_move >= 100
+    end
+
+    # save the game
+    #
+    # @param board [Chess::Board]
+    def save_game(board)
+      save_name = prompt_save_name
+      fen = generate_fen_code(board)
+      save(save_name, fen)
+    end
+
+    # exits the game
+    # @return [Integer] Exit Code 0
+    def game_exit
+      pp 'exiting...'
+      0
+    end
+
+    # save and exit the game
+    # @return [Integer] Exit Code 0
+    def save_and_exit(board)
+      save_game(board)
+      game_exit
+    end
+  end
+end

data/lib/chess/mouse/mouse_input.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Mouse
+  module Mouse
+    # starts listening mouse input in console
+    # @param board [Chess::Board]
+    def start_mouse_input(board)
+      warn_tmux_users if ENV['TMUX']
+      system('stty -icanon -echo') # Disable canonical mode and echo in terminal
+      enable_mouse_tracking
+      begin
+        puts 'Waiting for mouse click... Press Ctrl+C to quit.'
+        input_loop(board)
+      ensure # run these even if Ctrl+C was pressed
+        disable_mouse_tracking
+        system('stty icanon echo') # Restore terminal to sane mode
+      end
+    end
+
+    # warns tmux users that mouse may not work
+    def warn_tmux_users
+      warn 'Mouse input may not work as expected in tmux'
+    end
+
+    # enable the mouse tracking using xterm control sequences -
+    # https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
+    def enable_mouse_tracking
+      print "\e[?9h" # Enable X10 mouse tracking
+    end
+
+    # disable the mouse tracking using xterm control sequences -
+    # https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-Mouse-Tracking
+    def disable_mouse_tracking
+      print "\e[?9l" # Disable X10 mouse tracking
+    end
+
+    # runs loop for mouse input
+    # @param board [Chess::Board]
+    def input_loop(board) # rubocop:disable Metrics/MethodLength
+      file_coords = generate_file_coords
+      rank_coords = generate_rank_coords
+      loop do
+        char = $stdin.getc
+        next unless char == "\e"
+
+        coord = read_input(char)
+        board_pos = clicked_element(coord, file_coords, rank_coords)
+        clicked = read_clicked(board_pos, coord)
+        return_value = select_click_action(board, clicked, board_pos, coord)
+        break if game_exit?(return_value)
+      end
+    end
+
+    # reads whole input sequence and returns the coords X and Y
+    # @param char [Char]
+    # @return [Array(x,y)]
+    def read_input(char)
+      shift = 32
+      sequence = char + $stdin.read(5) # Read the full ESC [ M SPACE Cx Cy stored in buffer
+      sequence.bytes[4..].map { |e| e - shift } # shift and return the Cx Cy only
+    end
+
+    # read what was clicked
+    # @example file and rank are decomposed from array
+    #   read_clicked([file,rank],coord)
+    #
+    # @param coord [Array]
+    # @return [String]
+    def read_clicked((file, rank), coord)
+      if !(file.nil? || rank.nil?)
+        'board'
+      elsif buttons_touched?(coord)
+        'button'
+      else
+        'outside'
+      end
+    end
+
+    # checks if exit code 0 is returned
+    # @param value [Integer,nil]
+    def game_exit?(value)
+      value == 0 # rubocop:disable Style/NumericPredicate
+    end
+  end
+end

data/lib/chess/mouse/mouse_position.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Mouse
+  module Mouse
+    # returns the position of board where mouse clicked on console display
+    # @example x and y are decomposed from array
+    #   clicked_element([3,2],file_coords,rank_coords)
+    #
+    # @param file_coords [Hash]
+    # @param rank_coords [Hash]
+    # @return [Array(file,rank)]
+    def clicked_element((x, y), file_coords, rank_coords)
+      [file_coords[x], rank_coords[y]]
+    end
+
+    # generate file coords for the display
+    # @return [Hash] file_coords
+    def generate_file_coords
+      file_coords = {}
+      file_ord = 97 # ord for "a"
+      board_start_x = 2
+      board_end_x = 25
+      (board_start_x..board_end_x).each_slice(3) do |arr| # a board square's string length on display is 3.
+        arr.each { |elem| file_coords[elem] = file_ord.chr }
+        file_ord += 1
+      end
+      file_coords
+    end
+
+    # generate rank coord for the display
+    # @return [Hash] rank_coords
+    def generate_rank_coords
+      rank_coords = {}
+      rank = 7 # black is on upper side of board so ranks go from 8 to 1 (7 to 0 cuz index start = 0) from top to bottom
+      board_start_y = 2
+      board_end_y = 9
+      (board_start_y..board_end_y).each do |elem|
+        rank_coords[elem] = rank
+        rank -= 1
+      end
+      rank_coords
+    end
+
+    # checks if a button was touched
+    # @example x and y are decomposed from array
+    #   buttons_touched?([x,y])
+    def buttons_touched?((coord_x, coord_y))
+      y = 11
+      return false if coord_y != y
+
+      start_x = 5
+      end_x = 15
+      save_and_exit = Array(start_x..end_x)
+      start_x = 19
+      end_x = 22
+      exit = Array(start_x..end_x)
+      (save_and_exit + exit).include?(coord_x)
+    end
+
+    # returns which button was clicked
+    # @example x and y are decomposed from array
+    #   button_type([x,y])
+    # @return [String]
+    def button_type((x, _y))
+      if x.between?(5, 15)
+        'save&exit'
+      else
+        'game_exit'
+      end
+    end
+  end
+end

data/lib/chess/pieces/bishop.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Pieces
+  module Pieces
+    # BishopMoves
+    module BishopMoves
+      def north_west_moves(board, file, rank)
+        north_west = board.north_west_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*north_west)
+          moves << north_west if board.pos_in_range?(north_west)
+          north_west = board.north_west_pos(*north_west)
+        end
+        moves << north_west if board.pos_in_range?(north_west) && board.enemy_at?(*north_west)
+        moves
+      end
+
+      def south_west_moves(board, file, rank)
+        south_west = board.south_west_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*south_west)
+          moves << south_west if board.pos_in_range?(south_west)
+          south_west = board.south_west_pos(*south_west)
+        end
+        moves << south_west if board.pos_in_range?(south_west) && board.enemy_at?(*south_west)
+        moves
+      end
+
+      def north_east_moves(board, file, rank)
+        north_east = board.north_east_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*north_east)
+          moves << north_east if board.pos_in_range?(north_east)
+          north_east = board.north_east_pos(*north_east)
+        end
+        moves << north_east if board.pos_in_range?(north_east) && board.enemy_at?(*north_east)
+        moves
+      end
+
+      def south_east_moves(board, file, rank)
+        south_east = board.south_east_pos(file, rank)
+
+        moves = []
+        while board.empty_at?(*south_east)
+          moves << south_east if board.pos_in_range?(south_east)
+          south_east = board.south_east_pos(*south_east)
+        end
+        moves << south_east if board.pos_in_range?(south_east) && board.enemy_at?(*south_east)
+        moves
+      end
+    end
+
+    # Bishop
+    class Bishop < Piece
+      include BishopMoves
+
+      # all possible_moves of Bishop
+      #
+      # @param board [Chess::Board]
+      # @return [Array] possible_moves_arr
+      def possible_moves(board)
+        file = @pos[0]
+        rank = @pos[1]
+        moves = []
+        moves += north_west_moves(board, file, rank)
+        moves += north_east_moves(board, file, rank)
+        moves += south_west_moves(board, file, rank)
+        moves += south_east_moves(board, file, rank)
+        moves
+      end
+    end
+  end
+end