chess_tui 0.41.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ffa182999d0b42056132dfbd562068e4761d5a1f90b66351a9dc04b280c5c0a
+  data.tar.gz: 719c2048abb1e1826ab7abb1b389a5373bc7751b3f6ddbb0fad22abc5ab22e62
+SHA512:
+  metadata.gz: c555796aa4b5dd6a116174465ec178be2993e747663db5a7fd339f420e64201c5b2cf2c9d2224d8f32fd910d03bc7e252dfc76ff43e846a746f46106249367b8
+  data.tar.gz: 1de74e7fb8aab8a626f228250d84c4065608f5b6a422127d54438dfc496ae11f8e79cfc1e86f8feb126f37606f8cc058dcbd2fdc4c078e8159913f56ac93ba5c

data/README.md

@@ -0,0 +1,39 @@
+# Chess
+
+<!-- uses shields.io for tags and simpleicons.org for icons -->
+[![Version](https://img.shields.io/github/v/tag/xajx179/Chess?label=version&logo=lichess)](https://github.com/XAJX179/Chess/tags)
+![last-commit](https://img.shields.io/github/last-commit/XAJX179/Chess?logo=git&label=Last%20Commit)
+[![Documentation](https://github.com/XAJX179/Chess/actions/workflows/documentation.yml/badge.svg)](https://github.com/XAJX179/Chess/actions/workflows/documentation.yml)
+[![Ruby Test](https://github.com/XAJX179/Chess/actions/workflows/tests.yml/badge.svg)](https://github.com/XAJX179/Chess/actions/workflows/tests.yml)
+[![Rubocop](https://github.com/XAJX179/Chess/actions/workflows/rubocop.yml/badge.svg)](https://github.com/XAJX179/Chess/actions/workflows/rubocop.yml)
+
+## About
+
+  Chess game with terminal ui and mouse click support,
+  load game with FEN codes or start new!
+
+## Install
+
+pre-requisite: ruby >= 3.2
+
+```bash
+gem install chess_tui
+```
+
+## uninstall
+
+```bash
+gem uninstall chess_tui
+```
+
+## Documentation
+
+[Documentation](https://xajx179.github.io/Chess/)
+
+## 🫣 Peek
+
+![screenshot](https://raw.githubusercontent.com/XAJX179/Chess/refs/heads/main/docs/images/chess_tui_screenshot.png)
+
+showcase video -
+
+<https://github.com/user-attachments/assets/180d563f-16d9-4f26-9b3a-c16bb66271a2>

data/bin/chess_tui

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/chess'
+
+Chess.start

data/lib/chess/board/board.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Board
+  class Board
+    include BoardFromFenCode
+    include BoardPos
+
+    # @!attribute data
+    #   'a’ to ‘h’ are files, rnbqkp are black pieces
+    #   and RNBQKP are white pieces along the 8 ranks.
+    #   @example generated data looks like this
+    #    {
+    #    "a"=>["R", "P", "", "", "", "", "p", "r"],
+    #    "b"=>["N", "P", "", "", "", "", "p", "n"],
+    #    "c"=>["B", "P", "", "", "", "", "p", "b"],
+    #    "d"=>["Q", "P", "", "", "", "", "p", "q"],
+    #    "e"=>["K", "P", "", "", "", "", "p", "k"],
+    #    "f"=>["B", "P", "", "", "", "", "p", "b"],
+    #    "g"=>["N", "P", "", "", "", "", "p", "n"],
+    #    "h"=>["R", "P", "", "", "", "", "p", "r"]
+    #    }
+    #   @return [Hash] board data
+
+    attr_accessor :data, :current_player, :castling_rights, :possible_en_passant_target,
+                  :half_move, :full_move, :white_pieces, :black_pieces, :white_king, :black_king
+
+    # Returns a new instance of Board.
+    # @param fen_code [String]
+    def initialize(fen_code)
+      @white_pieces = []
+      @black_pieces = []
+      @data = generate_data(fen_code)
+    end
+
+    # returns piece at the given position
+    # @param file [String]
+    # @param rank [Integer]
+    # @return any subclass of {Chess::Pieces::Piece}
+    def piece_at(file, rank)
+      return if @data[file].nil?
+
+      @data[file][rank]
+    end
+
+    # checks if a pos is empty
+    # @param file [String]
+    # @param rank [Integer]
+    def empty_at?(file, rank)
+      piece_at(file, rank) == ''
+    end
+
+    # removes the piece from board and also from {#black_pieces} or {#white_pieces}
+    # @example file and rank are decomposed from array
+    #   remove_piece_at(['d',0])
+    # @return [void]
+    def remove_piece_at((file, rank))
+      @data[file][rank] = ''
+      @black_pieces.reject! { |piece| piece.pos == [file, rank] }
+      @white_pieces.reject! { |piece| piece.pos == [file, rank] }
+    end
+
+    # inserts given piece at given pos
+    # @param piece [Chess::Pieces::Piece]
+    # @example file and rank are decomposed from array
+    #   insert_piece_at(['d',0])
+    # @return [void]
+    def insert_piece_at(piece, (file, rank))
+      @data[file][rank] = piece
+      piece.pos = [file, rank]
+      if @current_player == 'w'
+        @white_pieces << piece unless @white_pieces.include?(piece)
+      else
+        @black_pieces << piece unless @white_pieces.include?(piece)
+      end
+    end
+
+    # check if enemy at pos
+    # @param file [String]
+    # @param rank [Integer]
+    def enemy_at?(file, rank)
+      piece = piece_at(file, rank)
+      @current_player != piece.color.chr
+    end
+
+    # resets half move to 0
+    def reset_half_move
+      @half_move = 0
+    end
+  end
+end

data/lib/chess/board/board_from_fen.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # create board from fen_code
+  module BoardFromFenCode
+    # generate game’s data from FEN code.
+    # @param fen_code [String]
+    # @return [Hash] generated_board_data
+    def generate_data(fen_code)
+      fen_parts_array = fen_code.split
+      board_data = fen_parts_array[0]
+      @current_player = fen_parts_array[1]
+      @castling_rights = fen_parts_array[2]
+      @possible_en_passant_target = fen_parts_array[3]
+      @half_move = fen_parts_array[4].to_i
+      @full_move = fen_parts_array[5].to_i
+
+      create_board(board_data)
+    end
+
+    # creates board data
+    # @param board_data [String] board_data part of FEN code
+    # @return [Hash] board data
+    def create_board(board_data)
+      ranks = board_data.split('/')
+      files = ('a'..'h') # value for 'a' to 'h'
+      board = files.to_h { |file| [file, Array.new(8) { '' }] } # empty board
+
+      board = fill_board(ranks, board)
+      @data = board
+    end
+
+    # fills board with rank wise data.
+    # @param ranks [Array]
+    # @param board [Hash]
+    # @return [Hash] filled board.
+    def fill_board(ranks, board)
+      ranks.reverse!
+      ranks.each_index do |ranks_array_index|
+        rank = ranks[ranks_array_index].chars
+        fill_rank(board, rank, ranks_array_index)
+      end
+      board
+    end
+
+    # fills a rank
+    # @param board [Hash]
+    # @param rank [Array]
+    # @param ranks_array_index [Integer]
+    # @return [void]
+    def fill_rank(board, rank, ranks_array_index)
+      index = 0
+      rank.each do |letter|
+        if letter.to_i.zero?
+          index += 1
+          insert_piece(board, index, ranks_array_index, letter)
+        else
+          index += letter.to_i
+        end
+      end
+    end
+
+    # insert a piece on given board
+    # @param board [Hash]
+    # @param index [Integer]
+    # @param ranks_array_index [Integer]
+    # @param letter [String]
+    # @return [void]
+    def insert_piece(board, index, ranks_array_index, letter)
+      shift_ord = 96
+      file = (shift_ord + index).chr
+      rank = ranks_array_index
+
+      board[file][rank] = create_piece(letter)
+      piece_pos = [file, rank]
+      board[file][rank].pos = piece_pos
+    end
+
+    # create piece from the letter
+    # @param letter [String]
+    # @return any subclass of {Chess::Pieces::Piece}
+    def create_piece(letter)
+      if letter == letter.upcase
+        piece = white_piece(letter)
+        @white_pieces << piece
+      else
+        piece = black_piece(letter)
+        @black_pieces << piece
+      end
+      piece
+    end
+
+    # create white color piece from the letter
+    # @param letter [String]
+    # @return any subclass of {Chess::Pieces::Piece} with color white
+    def white_piece(letter) # rubocop:disable Metrics/MethodLength
+      color = 'white'
+      case letter
+      when 'R'
+        Chess::Pieces::Rook.new(color)
+      when 'N'
+        Chess::Pieces::Knight.new(color)
+      when 'B'
+        Chess::Pieces::Bishop.new(color)
+      when 'Q'
+        Chess::Pieces::Queen.new(color)
+      when 'K'
+        @white_king = Chess::Pieces::King.new(color)
+      when 'P'
+        Chess::Pieces::Pawn.new(color)
+      end
+    end
+
+    # create black color piece from the letter
+    # @param letter [String]
+    # @return any subclass of {Chess::Pieces::Piece} with color black
+    def black_piece(letter) # rubocop:disable Metrics/MethodLength
+      color = 'black'
+      case letter
+      when 'r'
+        Chess::Pieces::Rook.new(color)
+      when 'n'
+        Chess::Pieces::Knight.new(color)
+      when 'b'
+        Chess::Pieces::Bishop.new(color)
+      when 'q'
+        Chess::Pieces::Queen.new(color)
+      when 'k'
+        @black_king = Chess::Pieces::King.new(color)
+      when 'p'
+        Chess::Pieces::Pawn.new(color)
+      end
+    end
+  end
+end

data/lib/chess/board/board_pos.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Board
+  module BoardPos
+    # the north pos from the given pos
+    def north_pos(file, rank)
+      [file, rank + 1]
+    end
+
+    # the south pos from the given pos
+    def south_pos(file, rank)
+      [file, rank - 1]
+    end
+
+    # the east pos from the given pos
+    def east_pos(file, rank)
+      [(file.ord - 1).chr, rank]
+    end
+
+    # the west pos from the given pos
+    def west_pos(file, rank)
+      [(file.ord + 1).chr, rank]
+    end
+
+    # the north_east_pos pos from the given pos
+    def north_east_pos(file, rank)
+      [(file.ord - 1).chr, rank + 1]
+    end
+
+    # the north_west_pos pos from the given pos
+    def north_west_pos(file, rank)
+      [(file.ord + 1).chr, rank + 1]
+    end
+
+    # the south_east_pos pos from the given pos
+    def south_east_pos(file, rank)
+      [(file.ord - 1).chr, rank - 1]
+    end
+
+    # the south_west_pos pos from the given pos
+    def south_west_pos(file, rank)
+      [(file.ord + 1).chr, rank - 1]
+    end
+
+    # checks if a pos is nil value
+    # @example file and rank are decomposed from array
+    #   pos_nil?(['d',0])
+    def pos_nil?((file, rank))
+      piece_at(file, rank).nil?
+    end
+
+    # checks if a pos is in range
+    # @example file and rank are decomposed from array
+    #   pos_in_range?(['d',0])
+    def pos_in_range?((file, rank))
+      first_rank = 0
+      last_rank = 7
+      first_file_ord = 'a'.ord
+      last_file_ord = 'h'.ord
+      rank.between?(first_rank, last_rank) && file.ord.between?(first_file_ord, last_file_ord)
+    end
+  end
+end

data/lib/chess/display/board.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Console Display
+  module Display
+    # displays board with ASCII characters
+    # @param board_data [Hash]
+    # @param valid_moves [Array]
+    # @return [void]
+    def display_board(board_data, valid_moves = [])
+      print_files(board_data)
+      print_board_data(board_data, valid_moves)
+      print_files(board_data)
+    end
+
+    # prints the board data
+    #
+    # @param board_data [Hash]
+    # @param valid_moves [Array]
+    # @return [void]
+    def print_board_data(board_data, valid_moves)
+      shift_rank = 1
+      (0..7).reverse_each do |rank|
+        print rank + shift_rank
+        ('a'..'h').each do |file|
+          bg_color_name = square_bg_color_name(file, rank)
+          print_square(board_data, file, rank, bg_color_name, valid_moves)
+        end
+        print rank + shift_rank
+        puts
+      end
+    end
+
+    # prints files above the board 'a' to 'h'
+    #
+    # @param board_data [Hash]
+    # @return [void]
+    def print_files(board_data)
+      print ' '
+      board_data.each_key { |key| print " #{key} " }
+      puts
+    end
+
+    # prints a single square
+    #
+    # @param board_data [Hash]
+    # @param file [String]
+    # @param rank [Integer]
+    # @param bg_color_name [Symbol]
+    # @param valid_moves [Array]
+    # @return [void]
+    def print_square(board_data, file, rank, bg_color_name, valid_moves)
+      piece = board_data[file][rank]
+      square_pos = [file, rank]
+      if piece == ''
+        print square_string(piece, ' ', bg_color_name, square_pos, valid_moves)
+      else
+        print_piece_square(piece, bg_color_name, square_pos, valid_moves)
+      end
+    end
+
+    # helper method for {#print_square}
+    #
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param bg_color_name [Symbol]
+    # @param square_pos [Array]
+    # @param valid_moves [Array]
+    # @return [void]
+    def print_piece_square(piece, bg_color_name, square_pos, valid_moves) # rubocop:disable Metrics/MethodLength
+      case piece
+      when Pieces::Rook
+        print square_string(piece, "\u{265C}", bg_color_name, square_pos, valid_moves)
+      when Pieces::Knight
+        print square_string(piece, "\u{265E}", bg_color_name, square_pos, valid_moves)
+      when Pieces::Bishop
+        print square_string(piece, "\u{265D}", bg_color_name, square_pos, valid_moves)
+      when Pieces::Queen
+        print square_string(piece, "\u{265B}", bg_color_name, square_pos, valid_moves)
+      when Pieces::King
+        print square_string(piece, "\u{265A}", bg_color_name, square_pos, valid_moves)
+      when Pieces::Pawn
+        print square_string(piece, "\u{265F}", bg_color_name, square_pos, valid_moves)
+      end
+    end
+
+    # returns background color name for the square at
+    # given file and rank.
+    #
+    # @param file [String]
+    # @param rank [Integer]
+    # @return [Symbol]
+    def square_bg_color_name(file, rank)
+      if (file.ord.odd? && rank.odd?) || (file.ord.even? && rank.even?)
+        :dull_white
+      else
+        :green
+      end
+    end
+
+    # arrange and format strings for the square
+    #
+    # @param piece [Chess::Piece]
+    # @param unicode [String]
+    # @param bg_color_name [Symbol]
+    # @param square_pos [Array]
+    # @param valid_moves [Array]
+    # @return [String]
+    def square_string(piece, unicode, bg_color_name, square_pos, valid_moves)
+      if piece == ''
+        bg_color("#{move_dots(square_pos, valid_moves)}\u{00A0}\u{00A0}", bg_color_name)
+      elsif piece.is_a?(Chess::Pieces::King)
+        piece_color = piece.color
+        bg_color("#{move_dots(square_pos, valid_moves)}#{color(unicode, piece_color.to_sym)}#{
+            king_check_dot(piece)}", bg_color_name)
+      else
+        piece_color = piece.color
+        bg_color("#{move_dots(square_pos, valid_moves)}#{color(unicode, piece_color.to_sym)} ", bg_color_name)
+      end
+    end
+
+    # gives dot for move for the pos if it's inside valid_moves
+    #
+    # @param square_pos [Array]
+    # @param valid_moves [Array]
+    # @return [String] string (with dot or empty)
+    def move_dots(square_pos, valid_moves)
+      if valid_moves.include?(square_pos)
+        color("\u{2022}", :black)
+      else
+        "\u00A0"
+      end
+    end
+
+    # gives dot for king in check if given king is in check
+    #
+    # @param king [Chess::Pieces::King]
+    # @return [String] string (with red dot or empty)
+    def king_check_dot(king)
+      if king.in_check
+        color("\u{29BE}", :red)
+      else
+        "\u00A0"
+      end
+    end
+
+    # display Save & Exit and Exit buttons
+    # return [void]
+    def display_buttons
+      print '    '
+      print bg_color(color('Save & Exit', :green), :black)
+      print '   '
+      print bg_color(color('Exit', :green), :black)
+      puts
+    end
+
+    # clears the display and redraws the board with given board_data
+    #
+    # @param board_data [Hash]
+    # @param valid_moves [Array]
+    # @return [void]
+    def redraw_display(board_data, valid_moves = [])
+      system 'clear'
+      display_board(board_data, valid_moves)
+      display_buttons
+    end
+  end
+end

data/lib/chess/display/color.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Console Display
+  module Display
+    # Colors values for use in escape code.
+    COLORS = {
+      green: '119;149;86',
+      dull_white: '235;236;208',
+      white: '255;187;143',
+      black: '1;1;1',
+      red: '249;23;32'
+    }.freeze
+
+    # background color the string
+    #
+    # @param string [String]
+    # @param name [Symbol]
+    # @return [String]
+    def bg_color(string, name)
+      value = COLORS[name]
+      "\e[48;2;#{value}m#{string}\e[0m"
+    end
+
+    # color the string
+    #
+    # @param string [String]
+    # @param name [Symbol]
+    # @return [String]
+    #
+    # @note will not reset the color like #bg_color
+    def color(string, name)
+      value = COLORS[name]
+      "\e[38;2;#{value}m#{string}"
+    end
+  end
+end

data/lib/chess/display/prompt.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Console Display
+  module Display
+    # Prompts user to select between New Game
+    # /Load Save/Load Code(FEN) and returns the choice.
+    #
+    # @return [Integer] 0 for New Game. 1 for Load Save. 2 for Load Code(FEN).
+    def prompt_start_choices
+      prompt = TTY::Prompt.new
+      prompt.select('Create new game or load save/code?') do |menu|
+        menu.choice name: 'New Game', value: 1
+        if File.file?(SAVE_PATH) # if save.json exists
+          menu.choice name: 'Load Save', value: 2
+        else
+          menu.choice name: 'Load Save', disabled: '(No Save Found.)'
+        end
+        menu.choice name: 'Load using Code (FEN)', value: 3
+      end
+    end
+
+    # Promps User to select between saved data.
+    #
+    # @param save_data [Hash]
+    # @return [String] the FEN code of selected save name.
+    def prompt_select_save(save_data)
+      names = save_data.keys
+      prompt = TTY::Prompt.new
+      selected_save_key = prompt.select('Select a save.', per_page: 15, filter: true) do |menu|
+        names.each do |name|
+          menu.choice name: name, value: name
+        end
+      end
+      save_data[selected_save_key]
+    end
+
+    # Prompts User to enter a FEN code.
+    # @note method expects user is entering a valid FEN code.
+    #
+    # @return [String] the FEN code entered.
+    def prompt_enter_code
+      prompt = TTY::Prompt.new
+      prompt.ask('Enter a valid self attested FEN code : ') do |question|
+        regex = %r{\A[prnbqkPRNBQK0-9/ w\-a-h]+\z} # only checks if valid characters
+        # are used like 1-8,kqbnrKQBNR, w for white chance(b=bisop already),
+        # a-h(for en passant) and the slash(/).
+        question.required true
+        question.validate regex, 'Invalid FEN Code.            '
+      end
+    end
+
+    # Prompts User to choose piece to promote pawn
+    #
+    # @return [String] the letter of the piece
+    def prompt_pawn_promotion_choices
+      prompt = TTY::Prompt.new
+      prompt.select('Select the piece for pawn promotion!') do |menu|
+        menu.choice name: 'Queen', value: 'q'
+        menu.choice name: 'Knight', value: 'n'
+        menu.choice name: 'Bishop', value: 'b'
+        menu.choice name: 'Rook', value: 'r'
+      end
+    end
+
+    # Prompts User to enter a save name
+    #
+    # @return [String] save_name
+    def prompt_save_name
+      prompt = TTY::Prompt.new
+      prompt.ask('Enter a valid save name : ') do |question|
+        regex = /^[\w.]+$/
+        question.required true
+        question.validate regex, 'Only a-z , A-Z , 0-9 , _ allowed'
+      end
+    end
+  end
+end