chess_tui 0.41.4

data/lib/chess/play_moves/play_moves_by_type.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Play all types of moves
+  module PlayMovesByType
+    include PlayPawnMoves
+    include PlayKingMoves
+
+    # play different move based on type of the piece
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @param inside_valid_moves_flag [Boolean]
+    # @return [void]
+    def play_move_by_type(piece, board, move_pos, inside_valid_moves_flag: false) # rubocop:disable Metrics/MethodLength
+      update_player_board_data(piece, board, inside_valid_moves_flag)
+      if piece.is_a?(Pieces::Pawn)
+        play_pawn_move(piece, board, move_pos, inside_valid_moves_flag)
+        board.reset_half_move unless inside_valid_moves_flag
+      elsif piece.is_a?(Pieces::King)
+        play_king_move(piece, board, move_pos)
+      else
+        play_normal_move(piece, board, move_pos)
+      end
+      change_player_turn(board)
+      remove_en_passant_from_board(board) if @remove_en_passant
+    end
+
+    # play normal move
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @return [void]
+    def play_normal_move(piece, board, move_pos)
+      board.remove_piece_at(piece.pos)
+      board.reset_half_move if board.piece_at(*move_pos).is_a?(Pieces::Piece)
+      board.remove_piece_at(move_pos)
+      board.insert_piece_at(piece, move_pos)
+    end
+
+    # update some player and board data
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @param inside_valid_moves_flag [Boolean]
+    # @return [void]
+    def update_player_board_data(piece, board, inside_valid_moves_flag)
+      board.half_move += 1 unless inside_valid_moves_flag
+      @remove_en_passant = true
+      board.full_move += 1 if !inside_valid_moves_flag && piece.black?
+    end
+  end
+end

data/lib/chess/play_moves/play_pawn_moves.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # PawnMoves
+  module PlayPawnMoves
+    include Display
+
+    # play appropriate type of pawn move
+    #
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @param inside_valid_moves_flag [Boolean]
+    # @return [void]
+    def play_pawn_move(piece, board, move_pos, inside_valid_moves_flag)
+      if pawn_is_promoting?(piece)
+        play_pawn_promotion(piece, board, move_pos, inside_valid_moves_flag)
+      elsif attacking_en_passant?(piece, board, move_pos)
+        play_normal_move(piece, board, move_pos)
+        remove_enemy_en_passant_pawn(piece, board, move_pos)
+      elsif pawn_two_step_move?(piece, board, move_pos)
+        move_two_step(piece, board, move_pos)
+      else
+        play_normal_move(piece, board, move_pos)
+      end
+    end
+
+    # play two step move
+    #
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @return [void]
+    def move_two_step(piece, board, move_pos)
+      play_normal_move(piece, board, move_pos)
+      set_board_possible_en_passant(piece, board)
+      @remove_en_passant = false
+    end
+
+    # check if move is attacking a enemy pawn at {Chess::Board#possible_en_passant_target}
+    # @param (see #move_two_step)
+    def attacking_en_passant?(piece, board, move_pos)
+      file = piece.pos.first
+      rank = piece.pos.last
+      moves = piece.attack_en_passant(board, file, rank)
+      moves.include?(move_pos)
+    end
+
+    # check if pawn is promoting
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    def pawn_is_promoting?(piece)
+      rank = piece.pos.last
+      return true if rank == 1 && piece.black?
+
+      true if rank == 6 && piece.white?
+    end
+
+    # check if moving two step
+    #
+    # @param (see #move_two_step)
+    def pawn_two_step_move?(piece, board, move_pos)
+      file = piece.pos.first
+      rank = piece.pos.last
+      moves = piece.two_step_forward(board, file, rank)
+      moves.include?(move_pos)
+    end
+
+    # remove enemy pawn in attacking en passant
+    # @param (see #move_two_step)
+    # @return [void]
+    def remove_enemy_en_passant_pawn(piece, board, move_pos)
+      file = move_pos.first
+      rank = if piece.white?
+               move_pos.last - 1
+             else
+               move_pos.last + 1
+             end
+      board.remove_piece_at([file, rank])
+    end
+
+    # set board possible_en_passant_target
+    # @param piece any subclass of {Chess::Pieces::Piece}
+    # @param board [Chess::Board]
+    # @return [void]
+    def set_board_possible_en_passant(piece, board)
+      file = piece.pos.first
+      rank = if piece.white?
+               piece.pos.last - 1
+             else
+               piece.pos.last + 1
+             end
+      board.possible_en_passant_target = file + rank.to_s
+    end
+
+    # remove possible_en_passant_target pos from board
+    # @param board [Chess::Board]
+    # @return [void]
+    def remove_en_passant_from_board(board)
+      board.possible_en_passant_target = ''
+    end
+
+    # play pawn promotion move
+    # @param (see #play_pawn_move)
+    # @return [void]
+    def play_pawn_promotion(piece, board, move_pos, inside_valid_moves_flag)
+      board.remove_piece_at(piece.pos)
+      new_piece_letter = 'q'
+      new_piece_letter = prompt_pawn_promotion_choices unless inside_valid_moves_flag
+      new_piece_letter = new_piece_letter.upcase if piece.white?
+      piece = board.create_piece(new_piece_letter)
+      board.insert_piece_at(piece, move_pos)
+    end
+  end
+end

data/lib/chess/player/player.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Player
+  class Player
+    include PlayMovesByType
+
+    attr_accessor :selected_piece
+
+    def initialize
+      @selected_piece = ''
+    end
+
+    # select a move
+    # @param board [Chess::Board]
+    # @param move_pos [Array]
+    # @return [void]
+    def select_move(board, move_pos)
+      if @selected_piece.valid_moves.include?(move_pos)
+        play_move_by_type(@selected_piece, board, move_pos)
+      else
+        pp 'invalid move'
+      end
+    end
+
+    # change player turn
+    # @param board [Chess::Board]
+    # @return [void]
+    def change_player_turn(board)
+      current_player_color = board.current_player
+      board.current_player = if current_player_color == 'w'
+                               'b'
+                             else
+                               'w'
+                             end
+    end
+  end
+end

data/lib/chess/save/fen_from_board.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # create fen_code from board
+  module Save
+    # Fen code from Board
+    module FenCodeFromBoard
+      # generate FEN code from given board
+      # @param board [Chess::Board]
+      def generate_fen_code(board)
+        piece_placement = fen_piece_placement(board.data)
+        current_player = board.current_player
+        castling_rights = board.castling_rights
+        en_passant = board.possible_en_passant_target
+        half_move = board.half_move
+        full_move = board.full_move
+
+        "#{piece_placement} #{current_player} #{castling_rights} #{en_passant} #{half_move} #{full_move}"
+      end
+
+      # create fen piece placement for given board_data
+      # @param board_data [Hash]
+      # @return [String] piece_placement
+      def fen_piece_placement(board_data)
+        string = ''
+        (0..7).reverse_each do |rank|
+          string += fen_piece_placement_by_rank(board_data, rank)
+          string += '/' unless rank.zero?
+        end
+        string
+      end
+
+      # helper method for {#fen_piece_placement}
+      # @param board_data [Hash]
+      # @param rank [Integer]
+      # @return [String] piece_placement_part
+      def fen_piece_placement_by_rank(board_data, rank) # rubocop:disable Metrics/MethodLength
+        string = ''
+        empty_space = 0
+        ('a'..'h').each do |file|
+          piece = board_data[file][rank]
+          if piece == ''
+            empty_space += 1
+            string += empty_space.to_s if file == 'h'
+          else
+            string += empty_space.to_s unless empty_space.zero?
+            string += letter_of(piece)
+            empty_space = 0
+          end
+        end
+        string
+      end
+
+      # return letter of piece
+      #
+      # @param piece any subclass of {Chess::Pieces::Piece}
+      # @return [String] piece_letter
+      def letter_of(piece) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        letter = case piece
+                 when Pieces::King
+                   'k'
+                 when Pieces::Bishop
+                   'b'
+                 when Pieces::Rook
+                   'r'
+                 when Pieces::Pawn
+                   'p'
+                 when Pieces::Queen
+                   'q'
+                 when Pieces::Knight
+                   'n'
+                 end
+        if piece.white?
+          letter.upcase
+        else
+          letter
+        end
+      end
+    end
+  end
+end

data/lib/chess/save/save.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Save file commands
+  module Save
+    include Serializer
+    include FenCodeFromBoard
+
+    # writes a save to the save file
+    #
+    # @param name [String]
+    # @param data [String]
+    # @return [void]
+    def save(name, data)
+      file_data = read
+      file_data[name] = data
+      new_data_serialized = serialize(file_data)
+      File.write(SAVE_PATH, new_data_serialized)
+    end
+
+    # reads and returns saves from the save file.
+    # {Serializer#unserialize} is used to unserialize the data.
+    #
+    # @return [Hash]
+    def read
+      contents = File.read(SAVE_PATH)
+      unserialize(contents)
+    end
+  end
+end

data/lib/chess/save/serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Chess
+module Chess
+  # Save file commands
+  module Save
+    # Serializer for saving to file and reading from file.
+    module Serializer
+      # Serializing format used for save and load
+      SERIALIZER = JSON
+
+      # serializes the save data with save_name as keys and FEN as values
+      #
+      # @param data [Hash]
+      # @return [String]
+      def serialize(data)
+        SERIALIZER.dump data
+      end
+
+      # unserializes the given string and returns the Hash
+      # with save's name as keys and FEN code as values.
+      #
+      # @return [Hash]
+      def unserialize(string)
+        SERIALIZER.parse string
+      end
+    end
+  end
+end

data/lib/chess/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Chess
+  # VERSION following https://semver.org
+  VERSION = '0.41.4'
+end

data/lib/chess.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# the order of requiring here is important.
+# requiring any gems/modules/class called in Game before requiring
+# Game itself for example
+require 'tty/prompt'
+require 'json'
+require_relative 'chess/display/color'
+require_relative 'chess/display/prompt'
+require_relative 'chess/display/board'
+require_relative 'chess/mouse/mouse_position'
+require_relative 'chess/mouse/mouse_input'
+require_relative 'chess/save/fen_from_board'
+require_relative 'chess/save/serializer'
+require_relative 'chess/save/save'
+require_relative 'chess/pieces/piece'
+require_relative 'chess/pieces/bishop'
+require_relative 'chess/pieces/king'
+require_relative 'chess/pieces/knight'
+require_relative 'chess/pieces/pawn'
+require_relative 'chess/pieces/rook'
+require_relative 'chess/pieces/queen'
+require_relative 'chess/board/board_pos'
+require_relative 'chess/board/board_from_fen'
+require_relative 'chess/board/board'
+require_relative 'chess/play_moves/play_king_moves'
+require_relative 'chess/play_moves/play_pawn_moves'
+require_relative 'chess/play_moves/play_moves_by_type'
+require_relative 'chess/player/player'
+require_relative 'chess/game/valid_moves'
+require_relative 'chess/game/win_and_draw'
+require_relative 'chess/game/game'
+require_relative 'chess/play_game'
+
+# Chess
+module Chess
+  SAVE_PATH = File.expand_path('../save.json', __dir__)
+  # calls {start_game} the script file at chess/play_game
+  #
+  # @return [void]
+  def self.start
+    start_game
+  end
+end

data/save.json

@@ -0,0 +1,9 @@
+{
+  "default": "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+  "test_king": "r3k1nr/pppp1ppp/4p3/6Q1/8/8/PPP2PPP/R3K2R w KQkq - 0 1",
+  "test_queen": "rnb1kbnr/pppp1ppp/5q2/QQ2p3/2P3Q1/2Q5/PP1PPPPP/RNBQKBNR w KQkq - 0 1",
+  "test_rook_bishop": "r1kbB2R/8/8/P2R2pp/pB2r2P/8/4B3/R1Kb3r w - - 0 1",
+  "test_pawn": "3k4/ppp1pppp/1P2P1P1/4P3/4p3/1p2p1p1/PPP1PPPP/3K4 w - - 0 1",
+  "test_knight": "2nkN3/P4P2/7n/n1pN3N/N3nP2/8/8/1p1KNnp1 w - - 0 1",
+  "test_checkmate_stalemate": "8/P7/8/8/5Q1K/6B1/8/4R1bk w - - 2 2"
+}

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: chess_tui
+version: !ruby/object:Gem::Version
+  version: 0.41.4
+platform: ruby
+authors:
+- X_AJ_X
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+description: |-
+  Chess game with terminal UI written in ruby, check out docs: https://xajx179.github.io/Chess \
+      & source: https://github.com/XAJX179/Chess
+email:
+- xajx179@gmail.com
+executables:
+- chess_tui
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- bin/chess_tui
+- lib/chess.rb
+- lib/chess/board/board.rb
+- lib/chess/board/board_from_fen.rb
+- lib/chess/board/board_pos.rb
+- lib/chess/display/board.rb
+- lib/chess/display/color.rb
+- lib/chess/display/prompt.rb
+- lib/chess/game/game.rb
+- lib/chess/game/valid_moves.rb
+- lib/chess/game/win_and_draw.rb
+- lib/chess/mouse/mouse_input.rb
+- lib/chess/mouse/mouse_position.rb
+- lib/chess/pieces/bishop.rb
+- lib/chess/pieces/king.rb
+- lib/chess/pieces/knight.rb
+- lib/chess/pieces/pawn.rb
+- lib/chess/pieces/piece.rb
+- lib/chess/pieces/queen.rb
+- lib/chess/pieces/rook.rb
+- lib/chess/play_game.rb
+- lib/chess/play_moves/play_king_moves.rb
+- lib/chess/play_moves/play_moves_by_type.rb
+- lib/chess/play_moves/play_pawn_moves.rb
+- lib/chess/player/player.rb
+- lib/chess/save/fen_from_board.rb
+- lib/chess/save/save.rb
+- lib/chess/save/serializer.rb
+- lib/chess/version.rb
+- save.json
+homepage: https://xajx179.github.io/Chess
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://xajx179.github.io/Chess
+  source_code_uri: https://github.com/XAJX179/Chess
+  rubygems_mfa_required: 'true'
+post_install_message: Thanks for installing! by X_AJ_X
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: Chess game with terminal display and mouse input , load games with FEN code
+  or start new!
+test_files: []