gemba 0.1.1 → 0.2.0

data/lib/gemba/cli.rb

@@ -1,384 +1,72 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require_relative 'version'
 
 module Gemba
   class CLI
-    SUBCOMMANDS = %w[record decode info].freeze
+    SUBCOMMANDS = %w[play record decode replay config version patch ra].freeze
 
-    # Entry point: dispatch to subcommand or player.
+    # Entry point: dispatch to subcommand or default to play.
     # @param argv [Array<String>]
-    def self.run(argv = ARGV)
+    # @param dry_run [Boolean] parse and validate only, return execution plan
+    def self.run(argv = ARGV, dry_run: false)
       args = argv.dup
 
-      case args.first
-      when 'record'
-        args.shift
-        run_record(args)
-      when 'decode'
-        args.shift
-        run_decode(args)
-      when 'info'
-        args.shift
-        run_info(args)
-      else
-        run_player(args)
-      end
-    end
-
-    # Parse player (default) command options.
-    # @param argv [Array<String>]
-    # @return [Hash]
-    def self.parse(argv)
-      options = {}
-
-      parser = OptionParser.new do |o|
-        o.banner = "Usage: gemba [options] [ROM_FILE]"
-        o.separator ""
-        o.separator "GBA emulator powered by teek + libmgba"
-        o.separator ""
-        o.separator "Commands:"
-        o.separator "  record    Record video+audio to .grec (headless)"
-        o.separator "  decode    Encode .grec to video via ffmpeg"
-        o.separator "  info      Show .grec recording stats"
-        o.separator ""
-        o.separator "Player options:"
-
-        o.on("-s", "--scale N", Integer, "Window scale (1-4)") do |v|
-          options[:scale] = v.clamp(1, 4)
-        end
-
-        o.on("-v", "--volume N", Integer, "Volume (0-100)") do |v|
-          options[:volume] = v.clamp(0, 100)
-        end
-
-        o.on("-m", "--mute", "Start muted") do
-          options[:mute] = true
-        end
-
-        o.on("--no-sound", "Disable audio entirely") do
-          options[:sound] = false
-        end
-
-        o.on("-f", "--fullscreen", "Start in fullscreen") do
-          options[:fullscreen] = true
-        end
-
-        o.on("--show-fps", "Show FPS counter") do
-          options[:show_fps] = true
-        end
-
-        o.on("--turbo-speed N", Integer, "Fast-forward speed (0=uncapped, 2-4)") do |v|
-          options[:turbo_speed] = v.clamp(0, 4)
-        end
-
-        o.on("--locale LANG", "Language (en, ja, auto)") do |v|
-          options[:locale] = v
-        end
-
-        o.on("--headless", "Run without GUI (requires --frames and ROM)") do
-          options[:headless] = true
-        end
-
-        o.on("--frames N", Integer, "Run N frames then exit (requires ROM)") do |v|
-          options[:frames] = v
-        end
-
-        o.on("--reset-config", "Delete settings file and exit (keeps saves)") do
-          options[:reset_config] = true
-        end
-
-        o.on("-y", "--yes", "Skip confirmation prompts") do
-          options[:yes] = true
-        end
-
-        o.on("--version", "Show version") do
-          options[:version] = true
-        end
-
-        o.on("-h", "--help", "Show this help") do
-          options[:help] = true
-        end
-      end
-
-      parser.parse!(argv)
-      options[:rom] = File.expand_path(argv.first) if argv.first
-      options[:parser] = parser
-      options
-    end
-
-    # Apply parsed CLI options to the user config (session-only overrides).
-    # @param config [Gemba::Config]
-    # @param options [Hash]
-    def self.apply(config, options)
-      config.scale = options[:scale] if options[:scale]
-      config.volume = options[:volume] if options[:volume]
-      config.muted = true if options[:mute]
-      config.show_fps = true if options[:show_fps]
-      config.turbo_speed = options[:turbo_speed] if options[:turbo_speed]
-      config.locale = options[:locale] if options[:locale]
-    end
-
-    # --- Player (default command) ---
-
-    def self.run_player(argv)
-      options = parse(argv)
-
-      if options[:help]
-        puts options[:parser]
-        return
-      end
-
-      if options[:version]
-        puts "gemba #{Gemba::VERSION}"
-        return
-      end
-
-      require "gemba"
-
-      if options[:reset_config]
-        path = Config.default_path
-        unless File.exist?(path)
-          puts "No config file found at #{path}"
-          return
-        end
-        unless options[:yes]
-          print "Delete #{path}? [y/N] "
-          return unless $stdin.gets&.strip&.downcase == 'y'
-        end
-        Config.reset!(path: path)
-        puts "Deleted #{path}"
-        return
-      end
-
-      if options[:headless]
-        unless options[:frames] && options[:rom]
-          $stderr.puts "Error: --headless requires --frames N and a ROM file"
-          exit 1
-        end
-        require "gemba/headless"
-        HeadlessPlayer.open(options[:rom]) { |p| p.step(options[:frames]) }
-        return
-      end
-
-      if options[:frames] && !options[:rom]
-        $stderr.puts "Error: --frames requires a ROM file"
-        exit 1
-      end
-
-      apply(Gemba.user_config, options)
-      Gemba.load_locale if options[:locale]
-
-      sound = options.fetch(:sound, true)
-      Player.new(options[:rom], sound: sound, fullscreen: options[:fullscreen],
-                 frames: options[:frames]).run
-    end
-    private_class_method :run_player
-
-    # --- record subcommand ---
-
-    def self.parse_record(argv)
-      options = {}
-
-      parser = OptionParser.new do |o|
-        o.banner = "Usage: gemba record [options] ROM_FILE"
-        o.separator ""
-        o.separator "Record video+audio to a .grec file (headless, no GUI)"
-        o.separator ""
-
-        o.on("--frames N", Integer, "Number of frames to record (required)") do |v|
-          options[:frames] = v
-        end
-
-        o.on("-o", "--output PATH", "Output .grec path (default: ROM_ID.grec)") do |v|
-          options[:output] = v
-        end
-
-        o.on("-c", "--compression N", Integer, "Zlib level 1-9 (default: 1, 6+ has diminishing returns)") do |v|
-          options[:compression] = v.clamp(1, 9)
-        end
-
-        o.on("--progress", "Show recording progress") do
-          options[:progress] = true
-        end
-
-        o.on("-h", "--help", "Show this help") do
-          options[:help] = true
-        end
-      end
-
-      parser.parse!(argv)
-      options[:rom] = File.expand_path(argv.first) if argv.first
-      options[:parser] = parser
-      options
-    end
-
-    def self.run_record(argv)
-      options = parse_record(argv)
-
-      if options[:help]
-        puts options[:parser]
-        return
-      end
-
-      unless options[:frames] && options[:rom]
-        $stderr.puts "Error: record requires --frames N and a ROM file"
-        $stderr.puts "Run 'gemba record --help' for usage"
-        exit 1
-      end
-
-      require "gemba/headless"
-
-      total = options[:frames]
-
-      HeadlessPlayer.open(options[:rom]) do |player|
-        rec_path = options[:output] ||
-          "#{Config.rom_id(player.game_code, player.checksum)}.grec"
-
-        rec_opts = {}
-        rec_opts[:compression] = options[:compression] if options[:compression]
-        player.start_recording(rec_path, **rec_opts)
-
-        if options[:progress]
-          last_print = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          player.step(total) do |frame|
-            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            if frame == total || now - last_print >= 0.5
-              pct = frame * 100.0 / total
-              $stderr.print "\rRecording: #{frame}/#{total} (#{'%.1f' % pct}%)\e[K"
-              last_print = now
-            end
-          end
-          $stderr.print "\r\e[K"
-        else
-          player.step(total)
-        end
-
-        player.stop_recording
-
-        info = RecorderDecoder.stats(rec_path)
-        puts "Recorded #{info[:frame_count]} frames to #{rec_path}"
-        puts "  Duration:   #{'%.1f' % info[:duration]}s"
-        puts "  Avg change: #{'%.1f' % info[:avg_change_pct]}%/frame"
-        puts "  Uncompressed: #{format_size(info[:raw_video_size])} (encode input)"
-        puts "  .grec size: #{format_size(File.size(rec_path))}"
-      end
-    end
-    private_class_method :run_record
-
-    # --- decode subcommand ---
-
-    def self.parse_decode(argv)
-      options = {}
-
-      parser = OptionParser.new do |o|
-        o.banner = "Usage: gemba decode [options] TREC_FILE [-- FFMPEG_ARGS...]"
-        o.separator ""
-        o.separator "Encode a .grec recording to a playable video via ffmpeg."
-        o.separator "Args after -- replace the default codec flags (-c:v, -c:a, etc)."
-        o.separator ""
-
-        o.on("-o", "--output PATH", "Output path (default: INPUT.mp4)") do |v|
-          options[:output] = v
-        end
-
-        o.on("--video-codec CODEC", "Video codec (default: libx264)") do |v|
-          options[:video_codec] = v
-        end
-
-        o.on("--audio-codec CODEC", "Audio codec (default: aac)") do |v|
-          options[:audio_codec] = v
-        end
-
-        o.on("-s", "--scale N", Integer, "Scale factor (default: native)") do |v|
-          options[:scale] = v.clamp(1, 10)
-        end
-
-        o.on("--no-progress", "Disable progress indicator") do
-          options[:progress] = false
-        end
-
-        o.on("-h", "--help", "Show this help") do
-          options[:help] = true
-        end
+      if args.first == '--help' || args.first == '-h'
+        puts main_help unless dry_run
+        return { command: :help }
       end
 
-      parser.parse!(argv)
-      options[:trec] = argv.shift
-      options[:ffmpeg_args] = argv unless argv.empty?
-      options[:parser] = parser
-      options
-    end
-
-    def self.run_decode(argv)
-      options = parse_decode(argv)
+      cmd = SUBCOMMANDS.include?(args.first) ? args.shift : 'play'
 
-      if options[:help]
-        puts options[:parser]
-        return
-      end
-
-      unless options[:trec]
-        $stderr.puts "Error: decode requires a .grec file"
-        $stderr.puts "Run 'gemba decode --help' for usage"
-        exit 1
+      case cmd
+      when 'play'
+        require 'gemba/cli/commands/play'
+        Commands::Play.new(args, dry_run: dry_run).call
+      when 'record'
+        require 'gemba/cli/commands/record'
+        Commands::Record.new(args, dry_run: dry_run).call
+      when 'decode'
+        require 'gemba/cli/commands/decode'
+        Commands::Decode.new(args, dry_run: dry_run).call
+      when 'replay'
+        require 'gemba/cli/commands/replay'
+        Commands::Replay.new(args, dry_run: dry_run).call
+      when 'config'
+        require 'gemba/cli/commands/config_cmd'
+        Commands::ConfigCmd.new(args, dry_run: dry_run).call
+      when 'version'
+        require 'gemba/cli/commands/version'
+        Commands::Version.new(args, dry_run: dry_run).call
+      when 'patch'
+        require 'gemba/cli/commands/patch'
+        Commands::Patch.new(args, dry_run: dry_run).call
+      when 'ra'
+        require 'gemba/cli/commands/retro_achievements'
+        Commands::RetroAchievements.new(args, dry_run: dry_run).call
       end
-
-      require "gemba/headless"
-
-      trec_path = options[:trec]
-      output_path = options[:output] || trec_path.sub(/\.grec\z/, '') + '.mp4'
-      codec_opts = {}
-      codec_opts[:video_codec] = options[:video_codec] if options[:video_codec]
-      codec_opts[:audio_codec] = options[:audio_codec] if options[:audio_codec]
-      codec_opts[:scale] = options[:scale] if options[:scale]
-      codec_opts[:ffmpeg_args] = options[:ffmpeg_args] if options[:ffmpeg_args]
-      codec_opts[:progress] = options.fetch(:progress, true)
-
-      info = RecorderDecoder.decode(trec_path, output_path, **codec_opts)
-      puts "Encoded #{info[:frame_count]} frames " \
-           "(#{info[:width]}x#{info[:height]} @ #{'%.2f' % info[:fps]} fps, " \
-           "avg #{'%.1f' % info[:avg_change_pct]}% change/frame)"
-      puts "Output: #{info[:output_path]}"
     end
-    private_class_method :run_decode
-
-    # --- info subcommand ---
 
-    def self.run_info(argv)
-      if argv.include?('--help') || argv.include?('-h') || argv.empty?
-        puts "Usage: gemba info TREC_FILE"
-        puts ""
-        puts "Show recording stats (no ffmpeg needed)"
-        return
-      end
-
-      require "gemba/headless"
-
-      trec_path = argv.first
-      info = RecorderDecoder.stats(trec_path)
-
-      puts "Recording: #{trec_path}"
-      puts "  Frames:     #{info[:frame_count]}"
-      puts "  Resolution: #{info[:width]}x#{info[:height]}"
-      puts "  FPS:        #{'%.2f' % info[:fps]}"
-      puts "  Duration:   #{'%.1f' % info[:duration]}s"
-      puts "  Avg change: #{'%.1f' % info[:avg_change_pct]}%/frame"
-      puts "  Uncompressed: #{format_size(info[:raw_video_size])} (encode input)"
-      puts "  Audio:      #{info[:audio_rate]} Hz, #{info[:audio_channels]}ch"
+    # Main help text listing all subcommands.
+    def self.main_help
+      <<~HELP
+        Usage: gemba [command] [options]
+
+        GBA emulator powered by teek + libmgba
+
+        Commands:
+          play      Play a ROM (default)
+          record    Record video+audio to .grec (headless)
+          decode    Encode .grec to video via ffmpeg (--stats for info)
+          replay    Replay a .gir input recording
+          patch     Apply an IPS/BPS/UPS patch to a ROM
+          config    Show or reset configuration
+          version   Show version
+          ra        RetroAchievements — login, verify, achievements
+
+        Run 'gemba <command> --help' for command-specific options.
+      HELP
     end
-    private_class_method :run_info
 
-    def self.format_size(bytes)
-      if bytes >= 1_073_741_824
-        "#{'%.1f' % (bytes / 1_073_741_824.0)} GB"
-      elsif bytes >= 1_048_576
-        "#{'%.1f' % (bytes / 1_048_576.0)} MB"
-      else
-        "#{'%.1f' % (bytes / 1024.0)} KB"
-      end
-    end
-    private_class_method :format_size
   end
 end

data/lib/gemba/config.rb

@@ -49,6 +49,15 @@ module Gemba
       'tip_dismiss_ms'     => 4000,
       'recording_compression' => 1,
       'pause_on_focus_loss'  => true,
+      'log_level'            => 'info',
+      'bios_path'            => nil,
+      'skip_bios'            => false,
+      'ra_enabled'           => false,
+      'ra_username'          => '',
+      'ra_token'             => '',
+      'ra_hardcore'          => false,
+      'ra_unofficial'        => false,
+      'ra_rich_presence'     => false,
     }.freeze
 
     # Settings that can be overridden per ROM. Maps config key → locale key.
@@ -64,6 +73,7 @@ module Gemba
       'turbo_speed'       => 'settings.turbo_speed',
       'quick_save_slot'   => 'settings.quick_save_slot',
       'save_state_backup' => 'settings.keep_backup',
+      'ra_rich_presence'  => 'settings.ra_rich_presence',
     }.freeze
 
     PER_GAME_KEYS = PER_GAME_SETTINGS.keys.to_set.freeze
@@ -123,9 +133,18 @@ module Gemba
       },
     }.freeze
 
-    def initialize(path: nil)
+    def initialize(path: nil, subscribe: true)
       @path = path || self.class.default_path
       @data = load_file
+      subscribe_to_bus if subscribe
+    end
+
+    # Re-wire bus subscriptions onto the current Gemba.bus.
+    # Called by AppController after it creates a fresh EventBus, because the
+    # Config may have been instantiated earlier (e.g. by the CLI) and subscribed
+    # to whatever bus existed at that time (possibly nil).
+    def resubscribe
+      subscribe_to_bus
     end
 
     # @return [String] path to the config file
@@ -401,6 +420,82 @@ module Gemba
       global['pause_on_focus_loss'] = !!val
     end
 
+    # @return [String, nil] BIOS filename (relative to Config.bios_dir), or nil for HLE
+    def bios_path
+      global['bios_path']
+    end
+
+    def bios_path=(val)
+      global['bios_path'] = val.nil? ? nil : val.to_s
+    end
+
+    def skip_bios?
+      !!global['skip_bios']
+    end
+
+    def skip_bios=(val)
+      global['skip_bios'] = !!val
+    end
+
+    # @return [String] log level (debug, info, warn, error)
+    def log_level
+      global['log_level']
+    end
+
+    def log_level=(val)
+      global['log_level'] = val.to_s
+    end
+
+    # -- RetroAchievements ----------------------------------------------------
+
+    def ra_enabled?
+      global['ra_enabled']
+    end
+
+    def ra_enabled=(val)
+      global['ra_enabled'] = val ? true : false
+    end
+
+    def ra_username
+      global['ra_username'] || ''
+    end
+
+    def ra_username=(val)
+      global['ra_username'] = val.to_s
+    end
+
+    def ra_token
+      global['ra_token'] || ''
+    end
+
+    def ra_token=(val)
+      global['ra_token'] = val.to_s
+    end
+
+    def ra_hardcore?
+      global['ra_hardcore']
+    end
+
+    def ra_hardcore=(val)
+      global['ra_hardcore'] = val ? true : false
+    end
+
+    def ra_unofficial?
+      global['ra_unofficial']
+    end
+
+    def ra_unofficial=(val)
+      global['ra_unofficial'] = val ? true : false
+    end
+
+    def ra_rich_presence?
+      global['ra_rich_presence']
+    end
+
+    def ra_rich_presence=(val)
+      global['ra_rich_presence'] = val ? true : false
+    end
+
     # @return [String] directory for .grec recording files
     def recordings_dir
       global['recordings_dir'] || self.class.default_recordings_dir
@@ -568,8 +663,46 @@ module Gemba
       File.join(config_dir, 'recordings')
     end
 
+    # @return [String] default directory for session log files
+    def self.default_logs_dir
+      File.join(config_dir, 'logs')
+    end
+
+    # @return [String] default directory for cached box art images
+    def self.boxart_dir
+      File.join(config_dir, 'boxart')
+    end
+
+    # @return [String] directory for cached RA achievement lists (one JSON per rom_id)
+    def self.achievements_cache_dir
+      File.join(config_dir, 'achievements')
+    end
+
+    # @return [String] default directory for patched ROMs
+    def self.default_patches_dir
+      File.join(config_dir, 'patches')
+    end
+
+    # @return [String] directory for BIOS files
+    def self.bios_dir
+      File.join(config_dir, 'bios')
+    end
+
+    # @return [String] path to the per-ROM overrides JSON file
+    def self.rom_overrides_path
+      File.join(config_dir, 'rom_overrides.json')
+    end
+
     private
 
+    def subscribe_to_bus
+      Gemba.bus.on(:rom_loaded) do |rom_id:, path:, **|
+        activate_game(rom_id)
+        add_recent_rom(path)
+        save!
+      end
+    end
+
     def global
       @proxy || global_base
     end

data/lib/gemba/data/gb_games.json

@@ -0,0 +1 @@
+{"DMG-APAU":"Pokemon - Red Version (USA, Europe) (SGB Enhanced)","DMG-APEE":"Pokemon - Blue Version (USA, Europe) (SGB Enhanced)","DMG-APSU":"Pokemon - Yellow Version - Special Pikachu Edition (USA, Europe) (CGB+SGB Enhanced)"}