gemba 0.1.1 → 0.2.0

data/lib/gemba/rom_patcher.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Gemba
+  # Applies IPS, BPS, or UPS patch files to GBA ROM files.
+  #
+  # Format support:
+  #   IPS  — simplest; no checksums; RLE support
+  #   BPS  — Beat Patch System; delta encoding with CRC32 verification
+  #   UPS  — Universal Patching System; XOR hunks with CRC32 verification
+  #
+  # Usage:
+  #   RomPatcher.patch(rom_path: "game.gba", patch_path: "fix.ips", out_path: "patched.gba")
+  #   # or invoke a format class directly:
+  #   RomPatcher::IPS.apply(rom_bytes, patch_bytes)  # => patched_bytes
+  #
+  class RomPatcher
+    CHUNK = 256 * 1024 # 256 KB
+
+    # Auto-detect format, apply patch, write output file.
+    #
+    # Progress budget:
+    #   0–15%   read ROM
+    #   15–25%  read patch
+    #   25–90%  format apply (IPS/BPS/UPS)
+    #   90–100% write output
+    #
+    # @param rom_path   [String] source ROM (read-only)
+    # @param patch_path [String] patch file (.ips / .bps / .ups)
+    # @param out_path   [String] where to write the result
+    # @param on_progress [Proc, nil] called with a Float (0.0..1.0)
+    # @return [String] out_path
+    # @raise [RuntimeError] on unknown format or checksum failure
+    def self.patch(rom_path:, patch_path:, out_path:, on_progress: nil)
+      rom   = read_chunked(rom_path,   0.0, 0.15, on_progress)
+      patch = read_chunked(patch_path, 0.15, 0.25, on_progress)
+
+      klass = case detect_format(patch)
+              when :ips then IPS
+              when :bps then BPS
+              when :ups then UPS
+              else raise "Unknown patch format (expected IPS/BPS/UPS magic)"
+              end
+
+      apply_cb = on_progress && ->(pct) { on_progress.call(0.25 + pct * 0.65) }
+      result = klass.apply(rom, patch, on_progress: apply_cb)
+      on_progress&.call(0.90)
+
+      FileUtils.mkdir_p(File.dirname(out_path))
+      write_chunked(out_path, result, 0.90, 1.0, on_progress)
+      on_progress&.call(1.0)
+      out_path
+    end
+
+    # @return [:ips, :bps, :ups, nil]
+    def self.detect_format(patch_data)
+      return :ips if patch_data.start_with?("PATCH")
+      return :bps if patch_data.start_with?("BPS1")
+      return :ups if patch_data.start_with?("UPS1")
+      nil
+    end
+
+    # Return a path that does not collide with existing files.
+    # If +path+ exists, appends -(2), -(3), ... before the extension.
+    def self.safe_out_path(path)
+      return path unless File.exist?(path)
+      ext  = File.extname(path)
+      base = path.chomp(ext)
+      n = 2
+      loop do
+        candidate = "#{base}-(#{n})#{ext}"
+        return candidate unless File.exist?(candidate)
+        n += 1
+      end
+    end
+
+    # Read a file in chunks, reporting progress from +pct_start+ to +pct_end+.
+    def self.read_chunked(path, pct_start, pct_end, on_progress)
+      size = File.size(path).to_f
+      buf  = String.new(encoding: 'BINARY')
+      read = 0
+      File.open(path, 'rb') do |f|
+        while (chunk = f.read(CHUNK))
+          buf  << chunk
+          read += chunk.bytesize
+          on_progress&.call(pct_start + (read / size) * (pct_end - pct_start))
+        end
+      end
+      buf
+    end
+    private_class_method :read_chunked
+
+    # Write a string to a file in chunks, reporting progress from +pct_start+ to +pct_end+.
+    def self.write_chunked(path, data, pct_start, pct_end, on_progress)
+      size    = data.bytesize.to_f
+      written = 0
+      File.open(path, 'wb') do |f|
+        while written < data.bytesize
+          n = [CHUNK, data.bytesize - written].min
+          f.write(data.byteslice(written, n))
+          written += n
+          on_progress&.call(pct_start + (written / size) * (pct_end - pct_start))
+        end
+      end
+    end
+    private_class_method :write_chunked
+  end
+end

data/lib/gemba/{rom_loader.rb → rom_resolver.rb}

@@ -6,14 +6,14 @@ module Gemba
   # Resolves ROM paths for the player. Handles both bare ROM files
   # and .zip archives containing a single ROM at the zip root.
   #
-  # @example Load a bare ROM
-  #   path = RomLoader.resolve("/path/to/game.gba")
+  # @example Resolve a bare ROM
+  #   path = RomResolver.resolve("/path/to/game.gba")
   #   # => "/path/to/game.gba"
   #
-  # @example Load from a zip
-  #   path = RomLoader.resolve("/path/to/game.zip")
+  # @example Resolve from a zip
+  #   path = RomResolver.resolve("/path/to/game.zip")
   #   # => "/Users/you/.config/gemba/tmp/game.gba"
-  class RomLoader
+  class RomResolver
     ROM_EXTENSIONS = %w[.gba .gb .gbc].freeze
     ZIP_EXTENSIONS = %w[.zip].freeze
     SUPPORTED_EXTENSIONS = (ROM_EXTENSIONS + ZIP_EXTENSIONS).freeze
@@ -85,7 +85,7 @@ module Gemba
         dir = tmp_dir
         FileUtils.mkdir_p(dir)
         out_path = File.join(dir, File.basename(rom_entry.name))
-        File.binwrite(out_path, rom_entry.get_input_stream.read)
+        rom_entry.get_input_stream { |s| File.binwrite(out_path, s.read) }
         out_path
       end
     rescue NoRomInZip, MultipleRomsInZip
@@ -97,4 +97,5 @@ module Gemba
     end
     private_class_method :extract_from_zip
   end
+
 end

data/lib/gemba/runtime.rb

@@ -1,39 +1,72 @@
 # frozen_string_literal: true
 
-# Shared runtime for gemba — loads the C extension, config, locale,
-# core, and ROM loader. Both the full GUI and headless entry points
-# require this.
+# Shared bootstrap — explicitly required by lib/gemba.rb (full GUI) and
+# lib/gemba/headless.rb (no Tk/SDL2).  Sets up Zeitwerk autoloading,
+# loads the C extension, and initializes the locale.
 
+require "zeitwerk"
 require "teek/platform"
 require "gemba_ext"
-require_relative "version"
-require_relative "config"
-require_relative "locale"
-require_relative "core"
-require_relative "rom_loader"
 
+# Define the Gemba module before loader.setup so Zeitwerk can register
+# autoloads directly on it (e.g. Gemba.autoload(:ChildWindow, ...)).
+# Without this, Gemba doesn't exist yet and Zeitwerk proxies through
+# lib/gemba.rb — which is never loaded in the headless path.
 module Gemba
   ASSETS_DIR = File.expand_path('../../assets', __dir__).freeze
 
-  # Lazily loaded user config — shared across the application.
-  # @return [Gemba::Config]
-  def self.user_config
-    @user_config ||= Config.new
-  end
+  class << self
+    # Lazily loaded user config — shared across the application.
+    # @return [Gemba::Config]
+    def user_config
+      @user_config ||= Config.new
+    end
 
-  # Override the user config (useful for tests).
-  # @param config [Gemba::Config, nil] pass nil to reset to default
-  def self.user_config=(config)
-    @user_config = config
-  end
+    # Override the user config (useful for tests).
+    # @param config [Gemba::Config, nil] pass nil to reset to default
+    attr_writer :user_config
 
-  # Load translations based on the config locale setting.
-  def self.load_locale
-    lang = user_config.locale
-    lang = nil if lang == 'auto'
-    Locale.load(lang)
-  end
+    # Load translations based on the config locale setting.
+    def load_locale
+      lang = user_config.locale
+      lang = nil if lang == 'auto'
+      Locale.load(lang)
+    end
+
+    # Event bus — auto-created on first access.
+    # AppController replaces it with a fresh bus at startup.
+    def bus
+      @bus ||= EventBus.new
+    end
+
+    attr_writer :bus
 
-  # Initialize locale on require
-  load_locale
+    # Session logger — lazily initialized on first write.
+    def logger
+      @logger ||= SessionLogger.new
+    end
+
+    attr_writer :logger
+
+    # Log a message at the given level.
+    # @example Gemba.log(:warn) { "something went wrong" }
+    def log(level = :info, &block)
+      logger.log(level, &block)
+    end
+  end
 end
+
+loader = Zeitwerk::Loader.new
+loader.push_dir(File.expand_path("../..", __FILE__))  # lib/ as root
+loader.inflector.inflect(
+  "gba" => "GBA", "gb" => "GB", "gbc" => "GBC", "cli" => "CLI",
+  "ips" => "IPS", "bps" => "BPS", "ups" => "UPS"
+)
+loader.ignore(__FILE__)  # bootstrap file — not a constant
+loader.ignore(File.expand_path("../../gemba.rb", __FILE__))  # entry point, not a constant
+loader.ignore(File.expand_path("../platform_open.rb", __FILE__))  # module method, not a constant
+loader.ignore(File.expand_path("../version.rb", __FILE__))  # defines VERSION (all-caps), not Zeitwerk-compatible
+loader.setup
+
+# Initialize locale on require
+Gemba.load_locale

data/lib/gemba/save_state_manager.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require_relative 'locale'
 
 module Gemba
   # Manages save state persistence: save, load, screenshot capture,
@@ -22,13 +21,11 @@ module Gemba
   class SaveStateManager
     include Locale::Translatable
 
-    GBA_W = 240
-    GBA_H = 160
-
-    def initialize(core:, config:, app:)
+    def initialize(core:, config:, app:, platform:)
       @core = core
       @config = config
       @app = app
+      @platform = platform
       @last_save_time = 0
       @state_dir = nil
       @quick_save_slot = config.quick_save_slot
@@ -143,8 +140,8 @@ module Gemba
       photo_name = "__gemba_ss_#{object_id}"
 
       @app.command(:image, :create, :photo, photo_name,
-                   width: GBA_W, height: GBA_H)
-      @app.interp.photo_put_block(photo_name, pixels, GBA_W, GBA_H, format: :argb)
+                   width: @platform.width, height: @platform.height)
+      @app.interp.photo_put_block(photo_name, pixels, @platform.width, @platform.height, format: :argb)
       @app.command(photo_name, :write, path, format: :png)
       @app.command(:image, :delete, photo_name)
     rescue StandardError => e

data/lib/gemba/save_state_picker.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "child_window"
-require_relative "locale"
 
 module Gemba
   # Grid picker window for save state slots.
@@ -17,6 +15,7 @@ module Gemba
   class SaveStatePicker
     include ChildWindow
     include Locale::Translatable
+    include BusEmitter
 
     TOP = ".mgba_state_picker"
 
@@ -53,6 +52,20 @@ module Gemba
       cleanup_photos
     end
 
+    # ModalStack protocol
+    def show_modal(state_dir: nil, quick_slot: 1, **_)
+      @state_dir = state_dir
+      @quick_slot = quick_slot
+      build_ui unless @built
+      refresh
+      super()
+    end
+
+    def withdraw
+      super
+      cleanup_photos
+    end
+
     private
 
     def build_ui
@@ -189,9 +202,9 @@ module Gemba
     def on_slot_click(slot)
       ss_path = File.join(@state_dir, "state#{slot}.ss")
       if File.exist?(ss_path)
-        @callbacks[:on_load]&.call(slot)
+        emit(:state_load_requested, slot)
       else
-        @callbacks[:on_save]&.call(slot)
+        emit(:state_save_requested, slot)
       end
       hide
     end

data/lib/gemba/session_logger.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Gemba
+  # Session logger that writes to the user config logs/ directory.
+  # File and directory are created lazily on first write.
+  class SessionLogger
+    MAX_LOG_FILES = 25
+    LEVELS = { debug: Logger::DEBUG, info: Logger::INFO,
+               warn: Logger::WARN, error: Logger::ERROR }.freeze
+
+    # @param dir [String] log directory (default: Config.default_logs_dir)
+    # @param level [Symbol] minimum log level (:debug, :info, :warn, :error)
+    def initialize(dir: nil, level: :info)
+      @dir = dir
+      @level = LEVELS.fetch(level, Logger::INFO)
+      @logger = nil
+      prune
+    end
+
+    # Log a message at the given level. Uses block form to avoid
+    # allocating the message string when the level is filtered.
+    # @param level [Symbol] :debug, :info, :warn, :error
+    def log(level, &block)
+      severity = LEVELS.fetch(level, Logger::INFO)
+      return if severity < @level
+
+      ensure_logger
+      @logger.add(severity, nil, 'gemba', &block)
+    end
+
+    # @return [String] resolved log directory
+    def log_dir
+      @dir ||= Config.default_logs_dir
+    end
+
+    private
+
+    def ensure_logger
+      return if @logger
+
+      FileUtils.mkdir_p(log_dir)
+      path = File.join(log_dir, "gemba-#{Time.now.strftime('%Y-%m-%d')}.log")
+      @logger = Logger.new(path)
+      @logger.level = @level
+      @logger.formatter = proc { |sev, time, _prog, msg|
+        "#{time.strftime('%H:%M:%S.%L')} [#{sev}] #{msg}\n"
+      }
+    end
+
+    def prune
+      dir = log_dir
+      return unless File.directory?(dir)
+
+      logs = Dir.glob(File.join(dir, 'gemba-*.log')).sort
+      excess = logs.length - MAX_LOG_FILES
+      return unless excess > 0
+
+      logs.first(excess).each { |f| File.delete(f) }
+    end
+  end
+
+end

data/lib/gemba/settings/audio_tab.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+
+module Gemba
+  module Settings
+    class AudioTab
+      include Locale::Translatable
+      include BusEmitter
+
+      FRAME        = "#{Paths::NB}.audio"
+      VOLUME_SCALE = "#{FRAME}.vol_row.vol_scale"
+      MUTE_CHECK   = "#{FRAME}.mute_row.mute"
+
+      VAR_VOLUME = '::mgba_volume'
+      VAR_MUTE   = '::mgba_mute'
+
+      def initialize(app, tips:, mark_dirty:)
+        @app = app
+        @mark_dirty = mark_dirty
+      end
+
+      def load_from_config(config)
+        @app.set_variable(VAR_VOLUME, config.volume.to_s)
+        @app.command(@vol_val_label, 'configure', text: "#{config.volume}%")
+        @app.set_variable(VAR_MUTE, config.muted? ? '1' : '0')
+      end
+
+      def build
+        @app.command('ttk::frame', FRAME)
+        @app.command(Paths::NB, 'add', FRAME, text: translate('settings.audio'))
+
+        # Volume slider
+        vol_row = "#{FRAME}.vol_row"
+        @app.command('ttk::frame', vol_row)
+        @app.command(:pack, vol_row, fill: :x, padx: 10, pady: [15, 5])
+
+        @app.command('ttk::label', "#{vol_row}.lbl", text: translate('settings.volume'))
+        @app.command(:pack, "#{vol_row}.lbl", side: :left)
+
+        @vol_val_label = "#{vol_row}.vol_label"
+        @app.command('ttk::label', @vol_val_label, text: '100%', width: 5)
+        @app.command(:pack, @vol_val_label, side: :right)
+
+        @app.set_variable(VAR_VOLUME, '100')
+        @app.command('ttk::scale', VOLUME_SCALE,
+          orient: :horizontal,
+          from: 0,
+          to: 100,
+          length: 150,
+          variable: VAR_VOLUME,
+          command: proc { |v, *|
+            pct = v.to_f.round
+            @app.command(@vol_val_label, 'configure', text: "#{pct}%")
+            emit(:volume_changed, pct / 100.0)
+            @mark_dirty.call
+          })
+        @app.command(:pack, VOLUME_SCALE, side: :right, padx: [5, 5])
+
+        # Mute checkbox
+        mute_row = "#{FRAME}.mute_row"
+        @app.command('ttk::frame', mute_row)
+        @app.command(:pack, mute_row, fill: :x, padx: 10, pady: 5)
+
+        @app.set_variable(VAR_MUTE, '0')
+        @app.command('ttk::checkbutton', MUTE_CHECK,
+          text: translate('settings.mute'),
+          variable: VAR_MUTE,
+          command: proc { |*|
+            muted = @app.get_variable(VAR_MUTE) == '1'
+            emit(:mute_changed, muted)
+            @mark_dirty.call
+          })
+        @app.command(:pack, MUTE_CHECK, side: :left)
+      end
+    end
+  end
+end