gemba 0.1.1 → 0.2.0

data/lib/gemba/bios.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Gemba
+  # Immutable value object representing a GBA BIOS file.
+  # The stored config value is just the filename; this object resolves
+  # it to a full path and computes metadata on demand (memoized).
+  class Bios
+    EXPECTED_SIZE = 16_384
+
+    attr_reader :path
+
+    def initialize(path:)
+      @path = path
+    end
+
+    # Build a Bios from a bare filename stored in config.
+    def self.from_config_name(name)
+      return nil if name.nil? || name.empty?
+      new(path: File.join(Config.bios_dir, name))
+    end
+
+    def filename = File.basename(@path)
+    def exists?  = File.exist?(@path)
+
+    def size
+      @size ||= exists? ? File.size(@path) : 0
+    end
+
+    def valid?
+      exists? && size == EXPECTED_SIZE
+    end
+
+    def checksum
+      return @checksum if defined?(@checksum)
+      @checksum = valid? ? Gemba.gba_bios_checksum(File.binread(@path)) : nil
+    end
+
+    def official? = checksum == GBA_BIOS_CHECKSUM
+    def ds_mode?  = checksum == GBA_DS_BIOS_CHECKSUM
+    def known?    = official? || ds_mode?
+
+    def label
+      return "Official GBA BIOS"  if official?
+      return "NDS GBA Mode BIOS"  if ds_mode?
+      "Unknown BIOS"
+    end
+
+    def status_text
+      return "File not found (#{@path})" unless exists?
+      return "Invalid size (#{size} bytes, expected #{EXPECTED_SIZE})" unless valid?
+      "#{label} · #{size} bytes"
+    end
+  end
+end

data/lib/gemba/boxart_fetcher/libretro_backend.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Gemba
+  class BoxartFetcher
+    # Resolves box art URLs from the LibRetro thumbnails CDN.
+    #
+    # URL pattern:
+    #   https://thumbnails.libretro.com/{system}/Named_Boxarts/{encoded_name}.png
+    #
+    # Requires game_code → canonical name mapping via GameIndex.
+    class LibretroBackend
+      SYSTEMS = {
+        "AGB" => "Nintendo - Game Boy Advance",
+        "CGB" => "Nintendo - Game Boy Color",
+        "DMG" => "Nintendo - Game Boy",
+      }.freeze
+
+      BASE_URL = "https://thumbnails.libretro.com"
+
+      # @param game_code [String] e.g. "AGB-BPEE"
+      # @return [String, nil] full URL to the box art PNG, or nil if unknown
+      def url_for(game_code)
+        platform = game_code.split("-", 2).first
+        system = SYSTEMS[platform]
+        return nil unless system
+
+        name = GameIndex.lookup(game_code)
+        return nil unless name
+
+        encoded_system = URI.encode_www_form_component(system).gsub("+", "%20")
+        encoded_name = URI.encode_www_form_component(name).gsub("+", "%20")
+
+        "#{BASE_URL}/#{encoded_system}/Named_Boxarts/#{encoded_name}.png"
+      end
+    end
+  end
+end

data/lib/gemba/boxart_fetcher/null_backend.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Gemba
+  class BoxartFetcher
+    # No-op backend that never resolves URLs. Used in tests and offline mode.
+    class NullBackend
+      def url_for(_game_code)
+        nil
+      end
+    end
+  end
+end

data/lib/gemba/boxart_fetcher.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "fileutils"
+
+module Gemba
+  # Fetches and caches box art images for ROMs.
+  #
+  # Delegates URL resolution to a pluggable backend (anything responding to
+  # +#url_for(game_code)+). Downloads happen off the main thread via
+  # +Teek::BackgroundWork+ so the UI stays responsive.
+  #
+  # Cache layout:
+  #   {cache_dir}/{game_code}/boxart.png
+  #
+  # Usage:
+  #   fetcher = BoxartFetcher.new(app: app, cache_dir: Config.boxart_dir, backend: backend)
+  #   fetcher.fetch("AGB-BPEE") { |path| update_card_image(path) }
+  #
+  class BoxartFetcher
+    attr_reader :cache_dir
+
+    def initialize(app:, cache_dir:, backend:)
+      @app = app
+      @cache_dir = cache_dir
+      @backend = backend
+      @in_flight = {} # game_code => true, prevents duplicate fetches
+    end
+
+    # Fetch box art for a game code. If cached, yields the path immediately.
+    # Otherwise kicks off an async download and yields the path on completion.
+    #
+    # @param game_code [String] e.g. "AGB-BPEE"
+    # @yield [path] called on the main thread with the cached file path
+    # @yieldparam path [String] absolute path to the cached PNG
+    def fetch(game_code, &on_fetched)
+      return unless on_fetched
+
+      cached = cached_path(game_code)
+      if File.exist?(cached)
+        on_fetched.call(cached)
+        return
+      end
+
+      url = @backend.url_for(game_code)
+      return unless url
+      return if @in_flight[game_code]
+
+      @in_flight[game_code] = true
+
+      Teek::BackgroundWork.new(@app, { url: url, dest: cached, game_code: game_code }, mode: :thread) do |t, data|
+        uri = URI(data[:url])
+        response = Net::HTTP.get_response(uri)
+        if response.is_a?(Net::HTTPSuccess)
+          FileUtils.mkdir_p(File.dirname(data[:dest]))
+          File.binwrite(data[:dest], response.body)
+          t.yield(data[:dest])
+        else
+          t.yield(nil)
+        end
+      end.on_progress do |path|
+        @in_flight.delete(game_code)
+        on_fetched.call(path) if path
+      end.on_done do
+        @in_flight.delete(game_code)
+      end
+    end
+
+    # @return [String] path where box art would be cached for this game code
+    def cached_path(game_code)
+      File.join(@cache_dir, game_code, "boxart.png")
+    end
+
+    # @return [Boolean] whether box art is already cached
+    def cached?(game_code)
+      File.exist?(cached_path(game_code))
+    end
+  end
+end

data/lib/gemba/bus_emitter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Gemba
+  # Include in any class that emits events via Gemba.bus.
+  # No constructor changes needed — just include and call emit.
+  module BusEmitter
+    private
+
+    def emit(event, *args, **kwargs)
+      Gemba.bus.emit(event, *args, **kwargs)
+    end
+  end
+end

data/lib/gemba/child_window.rb

@@ -27,7 +27,10 @@ module Gemba
         parent_menu = @app.command('.', :cget, '-menu') rescue nil
         @app.command(top, :configure, menu: parent_menu) if parent_menu && !parent_menu.empty?
       end
-      @app.command(:wm, 'protocol', top, 'WM_DELETE_WINDOW', proc { hide })
+      @on_dismiss = @callbacks[:on_dismiss] if defined?(@callbacks)
+      @app.command(:wm, 'protocol', top, 'WM_DELETE_WINDOW', proc {
+        @on_dismiss ? @on_dismiss.call : hide
+      })
       yield if block_given?
       @app.command(:wm, 'withdraw', top)
     end
@@ -58,5 +61,25 @@ module Gemba
       @app.command(:wm, 'withdraw', top)
       @callbacks[:on_close]&.call if defined?(@callbacks)
     end
+
+    # ── ModalStack protocol ──────────────────────────────────────────
+
+    # Show the window for ModalStack (deiconify, grab, position).
+    # Override in subclasses to accept additional keyword arguments.
+    def show_modal(**_args)
+      top = self.class::TOP
+      position_near_parent
+      @app.command(:wm, 'deiconify', top)
+      @app.command(:raise, top)
+      @app.command(:grab, :set, top)
+      @app.command(:focus, top)
+    end
+
+    # Withdraw the window for ModalStack (release grab, withdraw — NO callback).
+    def withdraw
+      top = self.class::TOP
+      @app.command(:grab, :release, top)
+      @app.command(:wm, 'withdraw', top)
+    end
   end
 end

data/lib/gemba/cli/commands/config_cmd.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class ConfigCmd
+        def initialize(argv, dry_run: false)
+          @argv = argv
+          @dry_run = dry_run
+        end
+
+        def call
+          options = parse
+
+          if options[:help]
+            puts options[:parser] unless @dry_run
+            return { command: :config, help: true }
+          end
+
+          result = {
+            command: options[:reset] ? :config_reset : :config_show,
+            reset: options[:reset],
+            yes: options[:yes],
+            options: options.except(:parser)
+          }
+          return result if @dry_run
+
+          require "gemba"
+
+          if options[:reset]
+            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
+
+          path = Config.default_path
+          puts "Config: #{path}"
+          puts "  Exists: #{File.exist?(path)}"
+          if File.exist?(path)
+            config = Gemba.user_config
+            puts "  Scale: #{config.scale}"
+            puts "  Volume: #{config.volume}"
+            puts "  Muted: #{config.muted?}"
+            puts "  Locale: #{config.locale}"
+            puts "  Show FPS: #{config.show_fps?}"
+            puts "  Turbo speed: #{config.turbo_speed}"
+          end
+        end
+
+        def parse
+          options = {}
+          argv = @argv.dup
+
+          parser = OptionParser.new do |o|
+            o.banner = "Usage: gemba config [options]"
+            o.separator ""
+            o.separator "Show or reset configuration."
+            o.separator ""
+
+            o.on("--reset", "Delete settings file (keeps saves)") { options[:reset] = true }
+            o.on("-y", "--yes", "Skip confirmation prompts") { options[:yes] = true }
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:parser] = parser
+          options
+        end
+      end
+    end
+  end
+end

data/lib/gemba/cli/commands/decode.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class Decode
+        def initialize(argv, dry_run: false)
+          @argv = argv
+          @dry_run = dry_run
+        end
+
+        def call
+          options = parse
+
+          if options[:help]
+            puts options[:parser] unless @dry_run
+            return { command: :decode, help: true }
+          end
+
+          if options[:list]
+            list_grec_recordings unless @dry_run
+            return { command: :decode_list }
+          end
+
+          unless options[:grec]
+            list_grec_recordings unless @dry_run
+            return { command: :decode_list }
+          end
+
+          result = {
+            command: options[:stats] ? :decode_stats : :decode,
+            grec: options[:grec],
+            stats: options[:stats],
+            output: options[:output],
+            video_codec: options[:video_codec],
+            audio_codec: options[:audio_codec],
+            scale: options[:scale],
+            ffmpeg_args: options[:ffmpeg_args],
+            options: options.except(:parser)
+          }
+          return result if @dry_run
+
+          require "gemba/headless"
+
+          grec_path = options[:grec]
+
+          if options[:stats]
+            info = RecorderDecoder.stats(grec_path)
+            puts "Recording: #{grec_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"
+            return
+          end
+
+          output_path = options[:output] || grec_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(grec_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
+
+        def parse
+          options = {}
+          argv = @argv.dup
+
+          parser = OptionParser.new do |o|
+            o.banner = "Usage: gemba decode [options] GREC_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."
+            o.separator ""
+
+            o.on("-o", "--output PATH", "Output path (default: INPUT.mp4)") { |v| options[:output] = v }
+            o.on("--video-codec CODEC", "Video codec (default: libx264)") { |v| options[:video_codec] = v }
+            o.on("--audio-codec CODEC", "Audio codec (default: aac)") { |v| options[:audio_codec] = v }
+            o.on("-s", "--scale N", Integer, "Scale factor (default: native)") { |v| options[:scale] = v.clamp(1, 10) }
+            o.on("-l", "--list", "List available .grec recordings") { options[:list] = true }
+            o.on("--stats", "Show recording stats (no ffmpeg needed)") { options[:stats] = true }
+            o.on("--no-progress", "Disable progress indicator") { options[:progress] = false }
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:grec] = argv.shift
+          options[:ffmpeg_args] = argv unless argv.empty?
+          options[:parser] = parser
+          options
+        end
+
+        private
+
+        def list_grec_recordings
+          require "gemba/headless"
+
+          dir = Config.default_recordings_dir
+          unless File.directory?(dir)
+            puts "No recordings directory found at #{dir}"
+            return
+          end
+
+          grec_files = Dir.glob(File.join(dir, '*.grec')).sort
+          if grec_files.empty?
+            puts "No .grec recordings in #{dir}"
+            return
+          end
+
+          entries = grec_files.map do |path|
+            info = RecorderDecoder.stats(path)
+            {
+              path: path,
+              frames: "#{info[:frame_count]} frames",
+              duration: "#{'%.1f' % info[:duration]}s",
+              size: format_size(File.size(path))
+            }
+          end
+
+          path_w   = entries.map { |e| e[:path].length }.max
+          frames_w = entries.map { |e| e[:frames].length }.max
+          dur_w    = entries.map { |e| e[:duration].length }.max
+          size_w   = entries.map { |e| e[:size].length }.max
+
+          entries.each do |e|
+            puts "#{e[:path].ljust(path_w)}  #{e[:frames].rjust(frames_w)}  #{e[:duration].rjust(dur_w)}  #{e[:size].rjust(size_w)}"
+          end
+        end
+
+        def 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
+      end
+    end
+  end
+end

data/lib/gemba/cli/commands/patch.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class Patch
+        def initialize(argv, dry_run: false)
+          @argv = argv
+          @dry_run = dry_run
+        end
+
+        def call
+          options = parse
+
+          if options[:help]
+            puts options[:parser] unless @dry_run
+            return { command: :patch, help: true }
+          end
+
+          unless options[:rom] && options[:patch]
+            $stderr.puts "gemba patch: ROM_FILE and PATCH_FILE are required"
+            $stderr.puts options[:parser]
+            return { command: :patch, error: :missing_args }
+          end
+
+          rom_path   = options[:rom]
+          patch_path = options[:patch]
+          out_path   = if options[:output]
+                         options[:output]
+                       else
+                         ext  = File.extname(rom_path)
+                         base = rom_path.chomp(ext)
+                         "#{base}-patched#{ext}"
+                       end
+
+          result = { command: :patch, rom: rom_path, patch: patch_path, out: out_path }
+          return result if @dry_run
+
+          require "gemba/rom_patcher"
+          require "gemba/rom_patcher/ips"
+          require "gemba/rom_patcher/bps"
+          require "gemba/rom_patcher/ups"
+
+          safe_out = RomPatcher.safe_out_path(out_path)
+          puts "Patching #{File.basename(rom_path)} with #{File.basename(patch_path)}…"
+          RomPatcher.patch(rom_path: rom_path, patch_path: patch_path, out_path: safe_out)
+          puts "Written: #{safe_out}"
+        end
+
+        def parse
+          options = {}
+          argv = @argv.dup
+
+          parser = OptionParser.new do |o|
+            o.banner = "Usage: gemba patch [options] ROM_FILE PATCH_FILE"
+            o.separator ""
+            o.separator "Apply an IPS, BPS, or UPS patch to a ROM file."
+            o.separator ""
+            o.separator "The output file is written to --output or, by default, next to the ROM."
+            o.separator "If the output path already exists, -(2), -(3) etc. are appended."
+            o.separator ""
+
+            o.on("-o", "--output PATH", "Output ROM path") { |v| options[:output] = File.expand_path(v) }
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:rom]   = File.expand_path(argv[0]) if argv[0]
+          options[:patch] = File.expand_path(argv[1]) if argv[1]
+          options[:parser] = parser
+          options
+        end
+      end
+    end
+  end
+end

data/lib/gemba/cli/commands/play.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Gemba
+  class CLI
+    module Commands
+      class Play
+        def initialize(argv, dry_run: false)
+          @argv = argv
+          @dry_run = dry_run
+        end
+
+        def call
+          options = parse
+
+          if options[:help]
+            puts options[:parser] unless @dry_run
+            return { command: :play, help: true }
+          end
+
+          result = {
+            command: :play,
+            rom: options[:rom],
+            sound: options.fetch(:sound, true),
+            fullscreen: options[:fullscreen],
+            options: options.except(:parser)
+          }
+          return result if @dry_run
+
+          require "gemba"
+
+          apply(Gemba.user_config, options)
+          Gemba.load_locale if options[:locale]
+          Gemba::AppController.new(result[:rom], sound: result[:sound], fullscreen: result[:fullscreen]).run
+        end
+
+        def parse
+          options = {}
+          argv = @argv.dup
+
+          parser = OptionParser.new do |o|
+            o.banner = "Usage: gemba [play] [options] [ROM_FILE]"
+            o.separator ""
+            o.separator "Launch the GBA emulator. ROM_FILE is optional."
+            o.separator ""
+
+            o.on("-s", "--scale N", Integer, "Window scale (1-4)") { |v| options[:scale] = v.clamp(1, 4) }
+            o.on("-v", "--volume N", Integer, "Volume (0-100)") { |v| options[:volume] = v.clamp(0, 100) }
+            o.on("-m", "--mute", "Start muted") { options[:mute] = true }
+            o.on("--no-sound", "Disable audio entirely") { options[:sound] = false }
+            o.on("-f", "--fullscreen", "Start in fullscreen") { options[:fullscreen] = true }
+            o.on("--show-fps", "Show FPS counter") { options[:show_fps] = true }
+            o.on("--turbo-speed N", Integer, "Fast-forward speed (0=uncapped, 2-4)") { |v| options[:turbo_speed] = v.clamp(0, 4) }
+            o.on("--bios PATH", "Path to GBA BIOS file (overrides saved setting)") { |v| options[:bios] = File.expand_path(v) }
+            o.on("--locale LANG", "Language (en, ja, auto)") { |v| options[:locale] = v }
+            o.on("-h", "--help", "Show this help") { options[:help] = true }
+          end
+
+          parser.parse!(argv)
+          options[:rom] = File.expand_path(argv.first) if argv.first
+          options[:parser] = parser
+          options
+        end
+
+        def 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]
+          config.bios_path = options[:bios] if options[:bios]
+        end
+      end
+    end
+  end
+end