chess_cli 0.9.2

data/lib/console_game/chess/utilities/player_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "chess_utils"
+require_relative "../player/chess_player"
+require_relative "../player/chess_computer"
+
+module ConsoleGame
+  module Chess
+    # The Player Builder class helps create new chess players for each session
+    # @author Ancient Nimbus
+    class PlayerBuilder
+      include ChessUtils
+
+      attr_reader :game, :session, :controller, :human_class, :ai_class
+
+      # @param game [Game] expects chess game manager object
+      def initialize(game)
+        @game = game
+        @controller = game.controller
+        @human_class = ChessPlayer
+        @ai_class = ChessComputer
+      end
+
+      # Create players based on load mode
+      # @param session [Hash] game session to load
+      # @return [Array<ChessPlayer, ChessComputer>]
+      def build_players(session)
+        @session = session
+        case session[:mode]
+        when 1 then pvp_mode
+        when 2 then pve_mode
+        else raise KeyError
+        end
+      end
+
+      # Create a player
+      # @param name [String] expects a name
+      # @param side [Symbol, nil] expects :black or :white
+      # @param type [Symbol] expects :human or :ai
+      # @param m_history [Array<String>]
+      # @return [ChessPlayer, ChessComputer]
+      def create_player(name = "", side = nil, type: :human, m_history: [])
+        new_player = type == :human ? human_class : ai_class
+        new_player.new(name, controller, side, m_history:)
+      end
+
+      private
+
+      # When it is player vs player
+      # @return [Array<ChessPlayer>]
+      def pvp_mode
+        SIDES_SYM.map { |side| create_player(session[side], side, m_history: m_history_data(side)) }
+      end
+
+      # When it is player vs computer
+      # @return [Array<ChessPlayer, ChessComputer>]
+      def pve_mode
+        computer_side = session.key("Computer")
+        raise KeyError if computer_side.nil?
+
+        player_side = opposite_of(computer_side)
+        [create_player(session[player_side], player_side, m_history: m_history_data(player_side)),
+         create_player(session[computer_side], computer_side, type: :ai, m_history: m_history_data(computer_side))]
+      end
+
+      # Helper to return moves history depending on side
+      # @return [Array<String>]
+      def m_history_data(side)
+        data = session["#{side}_moves".to_sym]
+        data.nil? ? [] : data
+      end
+    end
+  end
+end

data/lib/console_game/chess/utilities/session_builder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "chess_utils"
+
+module ConsoleGame
+  module Chess
+    # The Session Builder class helps create new session data hash
+    # @author Ancient Nimbus
+    class SessionBuilder
+      include ChessUtils
+
+      # Create session data
+      # @return [Array<Integer, Hash>] session data
+      def self.build_session(...) = new(...).build_session
+
+      attr_reader :sessions, :mode, :sides, :site_txt, :ongoing_txt
+
+      # @param game [Game] expects chess game manager object
+      def initialize(game)
+        @sessions = game.sessions
+        @mode = game.mode
+        @sides = game.sides
+        @site_txt = game.s("misc.site")
+        @ongoing_txt = game.s("status.ongoing")
+      end
+
+      # Build session data
+      # @return [Array<Integer, Hash>] session data
+      def build_session
+        id = sessions.size + 1
+        set_player_side
+        wp_name, bp_name = sides.values_at(w_sym, b_sym).map(&:name)
+        session = { mode: mode,
+                    white: wp_name,
+                    black: bp_name,
+                    event: "#{wp_name} vs #{bp_name} Status #{ongoing_txt}",
+                    site: site_txt,
+                    date: Time.new.ceil.strftime(STR_TIME) }
+        [id, session]
+      end
+
+      private
+
+      # Set internal side value for new player object
+      def set_player_side = sides.map { |side, player| player.side = side }
+    end
+  end
+end

data/lib/console_game/chess/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ConsoleGame
+  module Chess
+    # Chess game version
+    VER = "0.9.2"
+  end
+end

data/lib/console_game/console_menu.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "input"
+
+module ConsoleGame
+  # Input controller for console menu
+  class ConsoleMenu < Input
+    # == Console Commands ==
+
+    # Exit sequences | command patterns: `exit`, `ttfn`
+    def quit(_args = [])
+      print_msg(s("cli.lobby.exit"))
+      super
+    end
+
+    # Display help string | command pattern: `help`
+    def help(_args = []) = print_msg(s("cli.help"))
+
+    # Display system info | command pattern: `info`
+    def info(_args = []) = print_msg(s("cli.menu"))
+
+    # Save user profile to disk | command pattern: `save`
+    def save(_args = []) = game_manager.save_user_profile
+
+    # Load user profile from disk | command pattern: `load`
+    def load(_args = []) = game_manager.switch_user_profile
+
+    # Launch a game | command pattern: `play <launch code>`
+    # @param args [Array<String>] optional arguments
+    def play(args = [])
+      return print_msg(s("cli.play.gm_err")) unless game_manager
+
+      app = args[0]
+      game_manager.apps.key?(app) ? game_manager.launch(app) : print_msg(s("cli.play.run_err"), pre: "! ")
+    end
+
+    # Display user info | command pattern: `self`
+    def self(_args = [])
+      profile = game_manager.user.profile
+      user_color = :yellow
+      # p "Debug: #{profile}"
+      print_msg(s("cli.self.msg",
+                  { uuid: [profile[:uuid], user_color],
+                    date: [profile[:saved_date].strftime("%m/%d/%Y %I:%M %p"), user_color],
+                    name: [profile[:username], user_color],
+                    visit: [profile[:stats][:launch_count], user_color] }))
+    end
+
+    private
+
+    # Easter egg | command pattern: `lol`
+    def lol(_args = [])
+      Whirly.start spinner: "random_dots", status: s("cli.lol.title").sample do
+        sleep 3
+        Whirly.status = s("cli.lol.sub").sample
+        sleep 1.5
+        msgs = s("cli.lol.msgs")
+        print_msg(msgs[command_usage[:lol] % msgs.size], pre: "⠗ ")
+      end
+    end
+
+    # == Unities ==
+
+    # Setup input commands
+    def setup_commands = super.merge({ "save" => method(:save), "load" => method(:load), "play" => method(:play),
+                                       "self" => method(:self), "lol" => method(:lol) })
+  end
+end

data/lib/console_game/game_manager.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "../nimbus_file_utils/nimbus_file_utils"
+require_relative "../console/console"
+require_relative "input"
+require_relative "console_menu"
+require_relative "user_profile"
+require_relative "player"
+require_relative "base_game"
+require_relative "chess/launcher"
+
+# Console Game System v2.0.0
+# @author Ancient Nimbus
+# @version 2.0.0
+module ConsoleGame
+  # Game Manager for Console game
+  class GameManager
+    include Console
+    include ::NimbusFileUtils
+    include Chess::Launcher
+
+    # Alias for NimbusFileUtils
+    F = NimbusFileUtils
+
+    attr_reader :base_input, :cli, :apps, :user, :ver
+    attr_accessor :running, :active_game
+
+    def initialize(lang: "en")
+      F.set_locale(lang)
+      @ver = "2.0.0"
+      @running = true
+      @base_input = Input.new(self)
+      @cli = ConsoleMenu.new(self)
+      @apps = load_app_list
+      @user = nil
+      @active_game = nil
+    end
+
+    # run the console game manager
+    def run
+      greet
+      assign_user_profile
+      lobby
+    end
+
+    # Run a game
+    # @param app [String]
+    def launch(app)
+      self.active_game = apps[app].call(self)
+      active_game.start
+      print_msg(s(shut_down_msg(app)))
+      self.active_game = nil
+    end
+
+    # Exit Arcade
+    def exit_arcade
+      self.running = false
+      user&.save_profile
+      exit
+    end
+
+    # Save user profile
+    # @param mute [Boolean] bypass printing when use at the background
+    def save_user_profile(mute: false)
+      return load_err(:no_profile2) if user.nil?
+
+      user.save_profile
+      print_msg(s("cli.save.msg", { dir: [user.filepath, :yellow] })) unless mute
+    end
+
+    # Load another profile when using is at the lobby
+    def switch_user_profile
+      return load_err(:no_profile2) if user.nil?
+
+      @user = load_profile
+      launch_counter
+    end
+
+    private
+
+    # Greet user
+    def greet
+      tf_fetcher("", *%w[.guideline .boot], root: "cli").each do |msg|
+        print_msg(msg.sub("0.0.0", ver))
+        base_input.ask(s("cli.std_blank"), empty: true)
+      end
+    end
+
+    # Arcade lobby
+    def lobby
+      print_msg(s("cli.menu"))
+      cli.ask(empty: true) while running
+    end
+
+    # Define the app list
+    def load_app_list = {}.merge(load_chess)
+
+    # End game message
+    # @param app [String] expects app name
+    # @return [String] textfile key
+    def shut_down_msg(app) = "app.#{app}.end.home"
+
+    # Setup user profile
+    def assign_user_profile
+      print_msg(s("cli.new.msg"))
+      mode = base_input.ask(s("cli.new.msg2"), reg: [1, 2], input_type: :range).to_i
+      @user = mode == 1 ? new_profile : load_profile
+      # Create stats data
+      launch_counter
+      # Save to disk
+      save_user_profile
+    end
+
+    # Handle new user
+    # @param username [String] username for UserProfile, skip prompt stage if it is provided
+    # @return [UserProfile] user profile
+    def new_profile(username = "")
+      # Get username
+      username = username.empty? ? grab_username : username
+      # Create user profile
+      profile = UserProfile.new(username)
+      # Welcome user
+      print_msg(s("cli.new.msg4", { name: [profile.username, :yellow] }))
+      profile
+    end
+
+    # Handle returning user
+    # @param extname [String] extension name
+    # @return [UserProfile] user profile
+    def load_profile(extname: ".json")
+      f_path = select_profile(extname: extname)
+      # Load ops
+      profile = f_path.nil? ? load_err(:no_profile) : UserProfile.load_profile(F.load_file(f_path, extname: extname))
+      profile = profile.nil? ? load_err(:bad_profile) : UserProfile.new(profile[:username], profile)
+      # Post-load ops
+      print_msg(s("cli.load.msg3", { name: [profile.username, :yellow] }))
+      profile
+    end
+
+    # Handle profile selection
+    # @param extname [String] extension name
+    # @return [String] filepath
+    def select_profile(extname: ".json")
+      print_msg(s("cli.load.msg"))
+
+      folder_path = F.filepath("", "user_data")
+      profiles = F.file_list(folder_path, extname: extname)
+      return nil if profiles.empty?
+
+      # Print the list
+      print_msg(*build_file_list(folder_path, profiles, col1: s("cli.load.li_col1"), col2: s("cli.load.li_col2")))
+      # Handle selection
+      profile = base_input.pick_from(profiles, msg: s("cli.load.msg2"), err_msg: s("cli.load.input_err"))
+      # Returns a valid filename
+      folder_path + profile
+    end
+
+    # Edge cases handling when there are issue loading a profile
+    # @param err_label [Symbol] control which error message to print
+    # @return [UserProfile]
+    def load_err(err_label = :no_profile)
+      err_msgs ||= { no_profile: "cli.load.no_profile_err", no_profile2: "cli.load.no_profile_err2",
+                     bad_profile: "cli.load.bad_file_err" }
+      keypath = err_msgs.fetch(err_label, "cli.load.unknown_err")
+      print_msg(s(keypath), pre: "! ")
+      new_profile
+    end
+
+    # Get username from prompt
+    # @return [String] username
+    def grab_username = base_input.ask(s("cli.new.msg3"), reg: COMMON_REG[:filename], input_type: :custom, empty: true)
+
+    # Simple usage stats counting
+    def launch_counter
+      return load_err(:no_profile2) if user.nil?
+
+      user.profile[:stats][:launch_count] ||= 0
+      user.profile[:stats][:launch_count] += 1
+    end
+  end
+end

data/lib/console_game/input.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "whirly"
+require "paint"
+require_relative "../nimbus_file_utils/nimbus_file_utils"
+require_relative "../console/console"
+
+module ConsoleGame
+  # Input class is a base class for various control layouts for ConsoleGame
+  class Input
+    include Console
+    include ::NimbusFileUtils
+
+    attr_reader :game_manager, :commands, :cmd_pattern, :command_usage
+
+    # @param game_manager [ConsoleGame::GameManager]
+    def initialize(game_manager = nil)
+      @game_manager = game_manager
+      @commands = setup_commands
+      @cmd_pattern = regexp_capturing_gp(commands.keys, pre: "--", suf: '(\s.*)?')
+      @command_usage = Hash.new { |h, k| h[k] = 0 }
+    end
+
+    # == Core methods ==
+
+    # 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("cli.std_err"), reg: ".*", empty: false, input_type: :any)
+      reg = case input_type
+            when :range then regexp_range(cmd_pattern, min: reg[0], max: reg[1])
+            when :custom then regexp_formatter(cmd_pattern, reg)
+            else reg
+            end
+      # p "location: #{self.class}, reg: #{reg}"
+      # p reg
+      super(msg, cmds:, err_msg:, reg:, empty:)
+    end
+
+    # Process user input where bound checks are required
+    # @param options [Array] a list of options
+    # @param msg [String] first print
+    # @param err_msg [String] second print
+    # @return [Any] a valid element within the given array
+    def pick_from(options, msg: "Pick from the following options: ", err_msg: "Not a valid option, try again.")
+      until options.fetch(opt = ask(msg, reg: COMMON_REG[:digits], input_type: :custom, err_msg: err_msg).to_i - 1, nil)
+        print_msg(err_msg, pre: Paint["! ", :red])
+      end
+      options[opt]
+    end
+
+    # == Console Commands ==
+
+    # Exit sequences | command patterns: `exit`
+    def quit(_args = []) = game_manager.nil? ? exit : game_manager.exit_arcade
+
+    # Display help string | command pattern: `help`
+    def help(_args = []) = print_msg(s("cli.std_help"))
+
+    # Display system info | command pattern: `info`
+    def info(_args = []) = print_msg(s("cli.ver", { ver: game_manager.ver }))
+
+    private
+
+    # == Unities ==
+
+    # Setup input commands
+    def setup_commands = { "exit" => method(:quit), "ttfn" => method(:quit), "help" => method(:help),
+                           "info" => method(:info) }
+
+    # Override: Handle command
+    # @param cmd [String]
+    # @param opt_arg [String]
+    # @param cmds [Array]
+    # @param is_valid [Boolean]
+    # @param cmd_err [String] custom error message
+    def handle_command(cmd, opt_arg, cmds, is_valid, cmd_err: s("cli.cmd_err"))
+      command_usage[cmd.to_sym] += 1 if cmds.key?(cmd)
+      super
+    end
+  end
+end

data/lib/console_game/player.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "paint"
+
+module ConsoleGame
+  # Player class
+  class Player
+    @number_of_player = 0
+    # @colors = String.colors[8..15]
+    class << self
+      # attr_reader :colors
+
+      # Add Player count
+      def add_player
+        @number_of_player += 1
+      end
+
+      # Set global player count
+      def player_count(value)
+        @number_of_player = value
+      end
+
+      # Return number of active players
+      def total_player
+        @number_of_player
+      end
+
+      # Setup color array and remove unwanted color options
+      # def setup_color
+      #   %i[default gray].each { |elem| remove_color(elem) }
+      # end
+
+      # Remove color option to avoid two players share the same color tag
+      # @param color [Symbol]
+      # def remove_color(color)
+      #   @colors.delete(color)
+      # end
+    end
+
+    attr_reader :data, :name, :player_color, :controller
+
+    # @param name [String]
+    # @param controller [Input]
+    def initialize(name = "", controller = nil)
+      @name = name
+      @controller = controller
+      # Player.setup_color
+      Player.add_player
+      @player_color = Paint.random
+      edit_name(name)
+      init_data
+    end
+
+    # Initialise player save data
+    def init_data
+      @data = { name: name }
+    end
+
+    # Edit player name
+    # @param new_name [String]
+    def edit_name(new_name = "")
+      if new_name.empty?
+        new_name = name.empty? ? "Player #{Player.total_player}" : name
+      end
+      @name = Paint[new_name, player_color]
+    end
+
+    # Store player's move
+    # @param value [Integer] Positional value of the grid
+    # def store_move(value)
+    #   return nil if value.nil?
+
+    #   data.fetch(:moves) << value
+    # end
+
+    # Update player turn count
+    # def update_turn_count
+    #   data[:turn] = data.fetch(:moves).size
+    # end
+
+    # == Utilities ==
+  end
+
+  # Computer player class
+  # class Computer < Player
+  #   def initialize(game_manager = nil, name = "Computer")
+  #     super(game_manager, name)
+  #   end
+
+  #   # Returns a random integer between 1 to 7
+  #   # @param empty_slots [Array<Integer>]
+  #   # @param bound [Array<Integer>]
+  #   def random_move(empty_slots, bound)
+  #     row, = bound
+  #     value = (empty_slots.sample % row) + 1
+  #     print "#{value}\n"
+  #     value
+  #   end
+  # end
+end

data/lib/console_game/user_profile.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "../nimbus_file_utils/nimbus_file_utils"
+
+module ConsoleGame
+  # User Profile class
+  class UserProfile
+    include ::NimbusFileUtils
+
+    # Alias for NimbusFileUtils
+    F = NimbusFileUtils
+    # Expected user profile structure
+    PROFILE = { uuid: "", username: "", saved_date: Time, appdata: {}, stats: {} }.freeze
+
+    class << self
+      # load user profile
+      def load_profile(user_profile, _extname: ".json")
+        integrity_check(user_profile)
+      end
+
+      private
+
+      # Profile integrity check
+      # @param imported_profile [Hash]
+      def integrity_check(imported_profile)
+        return nil unless imported_profile.keys == PROFILE.keys
+
+        imported_profile[:saved_date] = to_time(imported_profile[:saved_date])
+        imported_profile
+      end
+
+      # convert string time field to TIme object for internal use
+      # @param str_date [String] expects a valid date format
+      def to_time(str_date)
+        return str_date if str_date.is_a?(Time)
+
+        Time.new(str_date)
+      end
+    end
+
+    attr_reader :profile, :filepath
+    attr_accessor :username
+
+    def initialize(username = "", user_profile = nil)
+      @username = username.empty? ? "Arcade Player" : username
+      @profile = user_profile.nil? ? create_profile : user_profile
+    end
+
+    # Create a user profile
+    def create_profile
+      { uuid: SecureRandom.uuid, username: username, saved_date: Time.now.ceil,
+        appdata: Hash.new { |hash, key| hash[key] = {} }, stats: {} }
+    end
+
+    # Save user profile
+    def save_profile(extname: ".json")
+      filename ||= F.formatted_filename(username, extname)
+      @filepath ||= F.filepath(filename, "user_data")
+
+      profile[:saved_date] = Time.now.ceil
+      F.write_to_disk(filepath, profile)
+    end
+  end
+end