chess_cli 0.9.2

data/lib/console/wait_utils.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "whirly"
+
+module ConsoleGame
+  # Wait Utils class uses the whirly gem to enhance user experience when interacting with the terminal.
+  # @author Ancient Nimbus
+  class WaitUtils
+    def self.wait_msg(...) = new(...).wait_msg
+
+    attr_reader :msg, :time
+
+    def initialize(msg, time: 0)
+      @msg = msg
+      @time = time
+    end
+
+    # Wait event via whirly
+    def wait_msg
+      Whirly.start spinner: "random_dots", status: msg, color: false, stop: "⣿" do
+        sleep time
+      end
+    end
+  end
+end

data/lib/console_game/base_game.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../console/console"
+require_relative "../nimbus_file_utils/nimbus_file_utils"
+
+module ConsoleGame
+  # Base Game class
+  class BaseGame
+    include Console
+    include ::NimbusFileUtils
+
+    attr_reader :game_manager, :controller, :title, :user, :ver
+    attr_accessor :state, :game_result
+
+    # @param game_manager [GameManager]
+    # @param title [String]
+    # @param input [Input]
+    # @param ver [String] game version
+    def initialize(game_manager = nil, title = "Base Game", input = nil, ver:)
+      @ver = ver
+      @game_manager = game_manager
+      @controller = input
+      @title = title
+      @user = game_config[:users][0]
+      @state = :created
+    end
+
+    # Game config
+    def game_config
+      return nil if game_manager.nil?
+
+      { users: [game_manager.user] }
+    end
+
+    # State machine
+
+    # Start the game
+    def start
+      self.state = :playing
+      boot
+      setup_game
+    end
+
+    # Change game state to paused
+    def pause = self.state = :paused
+
+    # Change game state to playing
+    def resume = self.state = :playing
+
+    # Change game state to ended
+    def end_game(result)
+      self.state = :ended
+      @game_result = result
+      show_end_screen
+      restart
+    end
+
+    # Check if current game session is active
+    def active? = state == :playing
+
+    private
+
+    # Print the boot screen
+    def boot; end
+
+    def setup_game; end
+
+    def show_end_screen
+      puts "Game Over! Result: #{@game_result}"
+    end
+
+    def restart; end
+  end
+end

data/lib/console_game/chess/board.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../../console/wait_utils"
+require_relative "logics/display"
+
+module ConsoleGame
+  module Chess
+    # The Board class handles the rendering of the chessboard
+    # @author Ancient Nimbus
+    class Board
+      include Console
+      include Display
+
+      attr_accessor :board_size, :board_side, :board_padding, :flip_board, :highlight
+      attr_reader :level, :type_hl, :alg_pos_hl
+
+      # @param level [Level] chess Level object
+      def initialize(level)
+        @level = level
+        display_configs
+      end
+
+      # Print before the chessboard
+      # @param keypath [String] TF keypath
+      # @param subs [Hash] `{ demo: ["some text", :red] }`
+      # def print_before_cb(keypath, sub)
+      #   board.print_msg(board.s(keypath, sub))
+      # end
+
+      # Loading message
+      # @see WaitUtils #wait_msg
+      def loading_msg(...) = WaitUtils.wait_msg(...)
+
+      # Print after the chessboard
+      # @param keypath [String] TF keypath
+      # @param sub [Hash] `{ demo: ["some text", :red] }`
+      def print_after_cb(keypath, sub = {}) = print_msg(s(keypath, sub), pre: "⠗ ")
+
+      # Print turn
+      # @param event_msgs [Array<String>]
+      def print_turn(event_msgs = [""])
+        system("clear")
+        # print "\e[2J\e[H"
+
+        print_msg(*event_msgs, pre: "\n⠗ ") unless event_msgs.empty?
+        print_chessboard
+        level.event_msgs.clear
+      end
+
+      # Print the chessboard
+      def print_chessboard
+        puts "\n"
+        print_msg(*build_chessboard, pre: "".ljust(board_padding), clear: false)
+        puts "\n"
+      end
+
+      # Enable & disable board flipping
+      def flip_setting
+        self.flip_board = !flip_board
+        print_chessboard
+        keypath = flip_board ? "cmd.board.flip_on" : "cmd.board.flip_off"
+        print_msg(s(keypath), pre: D_MSG[:gear_icon])
+      end
+
+      # Make board bigger or smaller
+      def adjust_board_size
+        self.board_size, self.board_padding = board_size == 1 ? BOARD[:b_size_l] : BOARD[:b_size_s]
+        print_chessboard
+        keypath = board_size == 1 ? "cmd.board.size1" : "cmd.board.size2"
+        print_msg(s(keypath), pre: D_MSG[:gear_icon])
+      end
+
+      private
+
+      # Display configs
+      def display_configs
+        @board_size, @board_padding = BOARD[:b_size_s]
+        @flip_board = true
+        @board_side = :white
+        @highlight = THEME[:classic].slice(:icon, :highlight)
+        @type_hl, @alg_pos_hl = MSG_HIGHLIGHT[:std].values_at(:type, :alg_pos)
+      end
+
+      # Pre-process turn data before sending it to display module
+      # @return [Array] 2D array respect to bound limit
+      def rendering_data
+        display_data = highlight_moves(level.turn_data.dup, level.active_piece)
+        to_matrix(display_data)
+      end
+
+      # Temporary display move indicator highlight on the board
+      # @param display_data [Array<ChessPiece, String>] 1D copied of turn_data
+      # @param active_piece [King, Queen, Bishop, Knight, Rook, Pawn] chess piece
+      # @return [Array]
+      def highlight_moves(display_data, active_piece)
+        return display_data if active_piece.nil?
+
+        active_piece.possible_moves.each { |move| display_data[move] = highlight if display_data[move].is_a?(String) }
+        display_data
+      end
+
+      # Build the chessboard
+      # @return [Array<String>]
+      def build_chessboard
+        board_direction = flip_board ? level.player.side : board_side
+        build_board(rendering_data, side: board_direction, size: board_size)
+      end
+    end
+  end
+end

data/lib/console_game/chess/game.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative "version"
+require_relative "../base_game"
+require_relative "player/chess_player"
+require_relative "player/chess_computer"
+require_relative "level"
+require_relative "input/chess_input"
+require_relative "logics/display"
+require_relative "utilities/chess_utils"
+require_relative "utilities/player_builder"
+require_relative "utilities/session_builder"
+require_relative "utilities/load_manager"
+require_relative "utilities/fen_import"
+
+module ConsoleGame
+  # The Chess module features all the working parts for the game Chess.
+  # @author Ancient Nimbus
+  # @version 0.9.0
+  module Chess
+    # Main game flow for the game Chess, a subclass of ConsoleGame::BaseGame
+    class Game < BaseGame
+      include ChessUtils
+      include Display
+
+      attr_reader :mode, :p1, :p2, :sides, :sessions, :level
+      attr_accessor :fen
+
+      # @param game_manager [GameManager]
+      # @param title [String]
+      def initialize(game_manager = nil, title = "Chess")
+        super(game_manager, title, ChessInput.new(game_manager, self), ver: VER)
+        user.profile[:appdata][:chess] ||= {}
+        @sessions = user.profile[:appdata][:chess]
+      end
+
+      # Setup sequence
+      # new game or load game
+      def setup_game
+        reset_state
+        opt = game_selection
+        id = opt == 2 ? load_game : new_game(import: (opt == 3))
+        @fen ||= sessions.dig(id, :fens, -1)
+        @level = Level.new(controller, sides, sessions[id], fen).open_level
+        end_game
+      end
+
+      # Handle new game sequence
+      # @param err [Boolean] is use when there is a load err
+      # @param import [Boolean] true if opt is 3
+      def new_game(err: false, import: false)
+        print_msg(s("new.err")) if err
+        print_msg(s("new.f1"))
+        @mode = controller.ask(s("new.f1a"), err_msg: s("new.f1a_err"), reg: [1, 2], input_type: :range).to_i
+        @p1, @p2 = setup_players
+        start_order
+        import_game if import
+        create_session
+      end
+
+      private
+
+      # Import game mode
+      def import_game
+        print_msg(s("new.f3"), pre: "⠗ ")
+        @fen = controller.ask("FEN: ", input_type: :any)
+      end
+
+      # == Flow ==
+
+      # Game intro
+      def boot
+        tf_fetcher("", *%w[boot how_to help]).each do |msg|
+          print_msg(msg.sub("0.0.0", ver))
+          controller.ask(s("blanks.enter"), empty: true)
+        end
+      end
+
+      # Prompt player for new game or load game
+      def game_selection
+        print_msg(s("load.f1"))
+        controller.ask(s("load.f1a"), err_msg: s("load.f1a_err"), reg: [1, 3], input_type: :range).to_i
+      end
+
+      # Handle load game sequence
+      def load_game
+        user_opt, session = select_session
+        @mode = session[:mode]
+        begin
+          @p1, @p2 = build_players(session)
+        rescue KeyError
+          print_msg(s("load.err"))
+          new_game(err: true)
+        end
+        assign_sides
+        user_opt
+      end
+
+      # Endgame handling
+      def end_game
+        self.state = :ended
+        opt = controller.ask(s("session.restart"), reg: COMMON_REG[:yesno], input_type: :custom)
+        setup_game if opt.downcase.include?("y")
+      end
+
+      # == Utilities ==
+
+      # Reset state
+      def reset_state
+        Player.player_count(0)
+        reset_config = { player_builder: nil, sides: {}, p1: setup_p1, p2: nil, fen: nil }
+        reset_config.each { |var, v| instance_variable_set("@#{var}", v) }
+      end
+
+      # Create new session data
+      # @return [Integer] session id
+      def create_session
+        id, session_data = SessionBuilder.build_session(self)
+        sessions[id] = p1.register_session(id, **session_data)
+        id
+      end
+
+      # Select game session from list of sessions
+      # @see LoadManager #select_session
+      def select_session = LoadManager.select_session(self)
+
+      # Setup players
+      def setup_players = [p1, p2].map { |player| player_profile(player) }
+
+      # Set up player profile
+      # @param player [ConsoleGame::ChessPlayer, nil]
+      # @return [ChessPlayer, ChessComputer]
+      def player_profile(player)
+        player ||= mode == 1 ? create_player("") : create_player("Computer", type: :ai)
+        return player if player.is_a?(ChessComputer)
+
+        # flow 2: name players
+        f2 = s("new.f2", { count: [Player.total_player], name: [player.name] })
+        player.edit_name(controller.ask(f2, reg: COMMON_REG[:filename], empty: true, input_type: :custom))
+        print_msg(s("new.f2a", { name: player.name }))
+
+        player
+      end
+
+      # Set start order
+      def start_order
+        f1, f1a, f1a_err = tf_fetcher("order", *%w[.f1 .f1a .f1a_err])
+        print_msg(f1)
+        opt = controller.ask(f1a, err_msg: f1a_err, reg: [1, 3], input_type: :range).to_i
+        opt = rand(1..2) if opt == 3
+        assign_sides(opt:)
+      end
+
+      # Assign players to a sides hash
+      # @param opt [Integer] expects 1 or 2, where 1 will set p1 as white and p2 as black, and 2 in reverse
+      # @return [Hash<ChessPlayer, ChessComputer>]
+      def assign_sides(opt: 1)
+        validated_opt = p1.side ? determine_opt : opt
+        sides[w_sym], sides[b_sym] = validated_opt == 1 ? [p1, p2] : [p2, p1]
+      end
+
+      # Helper: determine side assignment option, usable only when p1.side is not nil
+      # @return [Integer]
+      def determine_opt = p1.side == w_sym ? 1 : 2
+
+      # == Player object creation ==
+
+      # Setup player 1
+      def setup_p1 = create_player(user.profile[:username])
+
+      # Create new player builder service
+      # @return [PlayerBuilder]
+      def player_builder = @player_builder ||= PlayerBuilder.new(self)
+
+      # Create players based on load mode
+      # @see PlayerBuilder #build_player
+      def build_players(...) = player_builder.build_players(...)
+
+      # Create a player
+      # @see PlayerBuilder #create_player
+      def create_player(...) = player_builder.create_player(...)
+    end
+  end
+end

data/lib/console_game/chess/input/algebraic_notation.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ConsoleGame
+  module Chess
+    # Module to parse Algebraic notation
+    module AlgebraicNotation
+      # Algebraic Input Regexp pattern
+      #  keys:
+      #  :pieces - Piece notations.
+      #  :disambiguation - Useful when two (or more) identical pieces can move to the same square.
+      #  :capture - Indicate the move is a capture.
+      #  :destination - Indicate destination square.
+      #  :promote - Pawn specific pattern, usable when Pawn reaches the other end of the board.
+      #  :check - Optional check and checkmate indicator.
+      #  :castling - King specific pattern usable when Castling move is possible.
+      # @return [Hash<Symbol, String>] patterns required to construct algebraic notation input.
+      ALG_PATTERN = {
+        pieces: "(?<piece>[KQRBN])?",
+        disambiguation: "(?<file_rank>[a-h][1-8]|[a-h])?",
+        capture: "(?<capture>x)?",
+        destination: "(?<target>[a-h][1-8])",
+        promote: "(?:=(?<promote>[QRBN]))?",
+        check: "(?<check>[+#])?",
+        castling: "(?<castle>O-O(?:-O)?)"
+      }.freeze
+
+      private
+
+      # == Algebraic notation ==
+
+      # Input validation when input scheme is set to Algebraic notation
+      # @param input [String] input value from prompt
+      # @param side [Symbol] player side :white or :black
+      # @param reg [String] regexp pattern
+      # @return [Hash] a command pattern hash
+      def validate_algebraic(input, side, reg)
+        captures = alg_output_capture_gps(input, reg)
+        return { type: :invalid_input, args: [input] } unless captures
+
+        if captures[:castle]
+          parse_castling(side, captures[:castle])
+        elsif captures[:promote]
+          parse_promote(side, captures)
+        else
+          parse_move(side, captures)
+        end
+      end
+
+      # Helper: Process regexp and returns a named capture groups
+      # @param input [String] input value from prompt
+      # @param reg [String] regexp pattern
+      # @return [Hash]
+      def alg_output_capture_gps(input, reg) = input.match(reg)&.named_captures(symbolize_names: true)&.compact
+
+      # Helper: parse castling input
+      # @param side [Symbol] player side :white or :black
+      # @param castle [String]
+      # @return [Hash] a command pattern hash
+      def parse_castling(side, castle)
+        rank = side == :white ? "1" : "8"
+        new_file = castle == "O-O" ? "g" : "c"
+        { type: :direct_move, args: ["e#{rank}", "#{new_file}#{rank}"] }
+      end
+
+      # Helper: parse pawn promote & capture
+      # @param side [Symbol] player side :white or :black
+      # @param captures [hash]
+      # @return [Hash] a command pattern hash
+      def parse_promote(side, captures)
+        target, promote = captures.slice(:target, :promote).values
+        rank = side == :white ? "7" : "2"
+        file = captures[:file_rank] || captures[:target][0]
+
+        { type: :direct_promote, args: ["#{file}#{rank}", target, notation_to_sym(promote)] }
+      end
+
+      # Helper: parse pawn movement
+      # @param side [Symbol] player side :white or :black
+      # @param captures [hash]
+      # @return [Hash] a command pattern hash
+      def parse_move(side, captures)
+        piece_type = notation_to_sym(captures[:piece] || :p)
+
+        { type: :fetch_and_move, args: [side, piece_type, captures[:target], captures[:file_rank]].compact }
+      end
+
+      # == Utilities ==
+
+      # Algebraic Regexp pattern builder
+      # @return [String]
+      def regexp_algebraic
+        castling_gp = ALG_PATTERN.select { |k, _| k == :castling }.values.join
+        regular_gp = ALG_PATTERN.reject { |k, _| k == :castling }.values.join
+        "(#{[castling_gp, regular_gp].join('|')})"
+      end
+
+      # Helper: Convert algebraic notation to internal symbol
+      # @param notation [String]
+      # @return [Symbol]
+      def notation_to_sym(notation) = notation.is_a?(Symbol) ? notation : notation.downcase.to_sym
+    end
+  end
+end

data/lib/console_game/chess/input/chess_input.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../../input"
+require_relative "../logics/display"
+require_relative "../utilities/chess_utils"
+require_relative "../utilities/pgn_export"
+require_relative "smith_notation"
+require_relative "algebraic_notation"
+
+module ConsoleGame
+  module Chess
+    # Input controller for the game Chess
+    class ChessInput < Input
+      include ChessUtils
+      include Display
+      include SmithNotation
+      include AlgebraicNotation
+
+      attr_accessor :input_scheme
+      attr_reader :alg_reg, :smith_reg, :level, :active_side, :chess_manager
+
+      # @param game_manager [GameManager]
+      # @param chess_manager [Game]
+      def initialize(game_manager = nil, chess_manager = nil)
+        super(game_manager)
+        @chess_manager = chess_manager
+        notation_patterns_builder
+        @input_scheme = smith_reg
+      end
+
+      # Store active level object
+      # @param level [Chess::Level] expects a chess Level class object
+      def link_level(level) = @level = level
+
+      # == Core methods ==
+
+      # Get user input and process them accordingly
+      # @param player [ChessPlayer]
+      def turn_action(player)
+        input = ask(s("level.action1"), reg: input_scheme, input_type: :custom, empty: true)
+        ops = case input_scheme
+              when smith_reg then validate_smith(input)
+              when alg_reg then validate_algebraic(input, player.side, input_scheme)
+              end
+        turn_action(player) unless player.method(ops[:type]).call(*ops[:args])
+      end
+
+      # Prompt user for the second time in the same turn if the first prompt was a preview move event
+      # @param player [ChessPlayer]
+      def make_a_move(player)
+        input = ask(s("level.action2"), reg: SMITH_PATTERN[:gp1], input_type: :custom, empty: true)
+        ops = case input.scan(SMITH_PARSER)
+              in [new_pos] then { type: :move_piece, args: [new_pos] }
+              else { type: :invalid_input, args: [input] }
+              end
+        make_a_move(player) unless player.method(ops[:type]).call(*ops[:args])
+      end
+
+      # Prompt user for Pawn promotion option when notation for promotion is not provided at the previous prompt
+      def promote_a_pawn
+        ask(s("level.promo_alert"), err_msg: s("level.err.promo2"), reg: SMITH_PATTERN[:promotion], input_type: :custom)
+      end
+
+      # Chess Override: process user input
+      # @param msg [String] first print
+      # @param cmds [Hash] expects a list of commands hash
+      # @param err_msg [String] second print
+      # @param reg [Regexp, String, Array<String>] pattern to match, use an Array when input type is :range
+      # @param empty [Boolean] allow empty input value, default to false
+      # @param input_type [Symbol] expects the following option: :any, :range, :custom
+      # @return [String]
+      def ask(msg = "", cmds: commands, err_msg: s("cmd.std_err"), reg: ".*", empty: false, input_type: :any) = super
+
+      # == Console Commands ==
+
+      # Exit sequences | command patterns: `exit`
+      def quit(_args = [])
+        print_msg(s("cmd.exit"))
+        save_moves unless level.nil?
+        super
+      end
+
+      # Display help string | command pattern: `help`
+      def help(args = [])
+        keypath = case args
+                  in ["alg"] then "alg_h"
+                  in ["smith"] then "sm_h"
+                  else "help"
+                  end
+        print_msg(s(keypath))
+      end
+
+      # Display system info | command pattern: `info`
+      def info(_args = [])
+        str = level.nil? ? s("cmd.info", { ver: chess_manager.ver }) : s("cmd.info2", build_info_data)
+        print_msg(str)
+      end
+
+      # Save session to player data | command pattern: `save`
+      # @param mute [Boolean] bypass printing when use at the background
+      def save(_args = [], mute: false)
+        return cmd_disabled if level.nil?
+
+        level.session[:date] = Time.new.ceil.strftime(STR_TIME)
+        game_manager.save_user_profile(mute:)
+      end
+
+      # Load another session from player data | command pattern: `load`
+      def load(_args = [])
+        return cmd_disabled if level.nil?
+
+        @level = nil
+        print_msg(s("cmd.load"), pre: "⠗ ")
+        chess_manager.setup_game
+      end
+
+      # Export current game session as pgn file | command pattern: `export`
+      def export(_args = [])
+        return cmd_disabled if level.nil?
+
+        save_moves
+        dir, filename, pgn_out = PgnExport.export_session(level.session).values_at(:path, :filename, :export_data)
+        print_msg(s("cmd.export", {
+                      filename: [filename, "gold"], dir: [dir, "gold"], sep: ["PGN".center(80, "=")], pgn_out:
+                    }))
+      end
+
+      # Change input mode to detect Smith Notation | command pattern: `smith`
+      def smith(_args = []) = switch_notation(:smith)
+
+      # Change input mode to detect Algebraic Notation | command pattern: `alg`
+      def alg(_args = []) = switch_notation(:alg)
+
+      # Update board settings | command pattern: `board`
+      # @example usage example
+      #  `--board size`
+      #  `--board flip`
+      def board(args = [])
+        return cmd_disabled if level.nil?
+
+        case args
+        in ["size"] then level.board.adjust_board_size
+        in ["flip"] then level.board.flip_setting
+        else print_msg(s("cmd.err"), pre: D_MSG[:warn_prefix])
+        end
+      end
+
+      private
+
+      # == Utilities ==
+
+      # Switch notation depending on user input
+      # @param mode [Symbol] expects :smith or :alg
+      def switch_notation(mode)
+        return cmd_disabled if level.nil?
+
+        self.input_scheme = case mode
+                            when :smith then smith_reg
+                            when :alg then alg_reg
+                            end
+        print_msg(s("cmd.input.#{mode}"), pre: "⠗ ")
+      end
+
+      # Create regexp patterns for various input modes
+      def notation_patterns_builder
+        @alg_reg = regexp_algebraic
+        @smith_reg = regexp_smith
+      end
+
+      # Setup input commands
+      def setup_commands = super.merge({ "save" => method(:save), "load" => method(:load), "export" => method(:export),
+                                         "smith" => method(:smith), "alg" => method(:alg), "board" => method(:board) })
+
+      # Print command is disabled at this stage
+      def cmd_disabled = print_msg(s("cmd.disabled"), pre: D_MSG[:warn_prefix])
+
+      # Helper to build session info data
+      # @return [Hash]
+      def build_info_data
+        date, fens, event, white, black = level.session.values_at(:date, :fens, :event, :white, :black)
+        { date:, fen: fens.last, event:, w_player: white, b_player: black, ver: chess_manager.ver }
+      end
+
+      # Helper to save session moves data
+      def save_moves
+        level.update_session_moves
+        save(mute: true)
+      end
+    end
+  end
+end