badline 0.5.1 → 0.6.1

data/lib/badline/address_bus.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/address_bus/saved_state"
 require "badline/address_bus/ultimax_pages"
 
 module Badline
@@ -88,6 +89,7 @@ module Badline
 
       @color_ram = ColorMemory.new(@vic)
       @open_bus = OpenBus.new(@vic)
+      @cpu_off_bus = false
 
       @port_ddr = 0x00
       @port_out = 0x00
@@ -153,11 +155,19 @@ module Badline
         @ram.poke(addr, @vic.phi1_data)
         addr.zero? ? @port_ddr = value : @port_out = value
         update_port!
-      else
+      elsif !@cpu_off_bus
         @write_pages[addr >> 8].poke(addr, value)
       end
     end
 
+    # Runs a CPU cycle with the CPU off the bus, as an REU's /DMA line
+    # holds it: a write it makes reaches nothing but its own port.
+    def cycle_cpu_off_bus(cpu)
+      @cpu_off_bus = true
+      cpu.cycle!
+      @cpu_off_bus = false
+    end
+
     def inspect
       "#<#{self.class.name} port=#{format('0x%02x', @io_port.value)} " \
         "cartridge=#{@cartridge ? @cartridge.class.name : 'none'} " \

data/lib/badline/audio/cli.rb

@@ -2,18 +2,31 @@
 
 module Badline
   module Audio
-    # Runs `badline-ruby --headless` or `--audio-out` once its options have
-    # parsed: picks the song and its length, then plays it or renders it
-    # to a file. Played on a terminal, the console lets the listener step
+    # Runs `--headless` or `--audio-out`, in either build, once its options
+    # have parsed: picks the song and its length, then plays it or renders
+    # it to a file. Played on a terminal, the console lets the listener step
     # between songs.
     class CLI
       class Error < StandardError; end
 
+      # Plays or renders the tune as #run does, reports an error on stderr
+      # under the program's name, and returns the exit status.
+      def self.run(options, sink:, console:)
+        new(options, sink:, console:).run
+        0
+      rescue Error => e
+        warn "#{options.program}: #{e.message}"
+        1
+      rescue Interrupt
+        130
+      end
+
       # Playing needs `sink`, which builds the audio device given the rate
       # to ask for and whether it has to be exact, and, on a terminal,
       # `console`, which builds the terminal to play on given the input and
-      # output. The front end hands them in, so the native badline can hand
-      # in its own: badline-ruby's are SDLSink and Console.
+      # output. Each build's entry point hands them in: both builds' sink is
+      # Frontend::AudioSink, and the console is badline-ruby's Console or
+      # the native badline's Native::Console.
       def initialize(options, sink: nil, console: nil, out: $stdout, input: $stdin)
         @options = options
         @out = out

data/lib/badline/audio/console.rb

@@ -6,7 +6,8 @@ require "io/wait"
 module Badline
   module Audio
     # The terminal of `badline-ruby --headless`, put in raw mode with
-    # io/console.
+    # io/console. It is badline-ruby's side of the console seam, and
+    # exe/badline-ruby requires it: the native badline's is Native::Console.
     class Console < Terminal
       private
 

data/lib/badline/audio.rb

@@ -7,9 +7,6 @@ require "badline/audio/bare_player"
 require "badline/audio/machine_player"
 require "badline/audio/renderer"
 require "badline/audio/playback"
-require "badline/audio/sdl_sink"
-require "badline/audio/stream"
 require "badline/audio/terminal"
-require "badline/audio/console"
 require "badline/audio/jukebox"
 require "badline/audio/cli"

data/lib/badline/cartridge/action_replay.rb

@@ -64,6 +64,21 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, windows)
+        out.int(window_index(@rom, windows)).boolean(@active).boolean(@io2_ram).blob(@ram_data)
+      end
+
+      def load_mapper(input)
+        load_windows(input, windows)
+        @rom = window_at(input.int, windows)
+        @active = input.boolean?
+        @io2_ram = input.boolean?
+        input.blob_into(@ram_data)
+      end
+
+      def windows = [@through, @isolated, @contended, *@rom_banks, EMPTY_BANK]
+
       def io2_peek(addr)
         @io2_ram ? @ram_data[IO2_PAGE | (addr & 0xff)] : @rom.peek(addr)
       end

data/lib/badline/cartridge/comal80.rb

@@ -33,6 +33,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@roml_banks, *@romh_banks, EMPTY_BANK])
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@roml_banks, *@romh_banks, EMPTY_BANK])
+      end
+
       def select(number, mode)
         @roml = bank(@roml_banks, number)
         @romh = bank(@romh_banks, number)

data/lib/badline/cartridge/dinamic.rb

@@ -24,6 +24,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@banks, EMPTY_BANK])
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@banks, EMPTY_BANK])
+      end
+
       def install_chips(chips)
         @banks = banks_from(chips).first
         self.mode = :rom8k

data/lib/badline/cartridge/easy_flash.rb

@@ -78,9 +78,28 @@ module Badline
       private
 
       def select_bank
+        map_bank
+        changed!
+      end
+
+      def map_bank
         @roml = @low_flash.window(@bank * BANK_SIZE)
         @romh = @high_flash.window(@bank * BANK_SIZE)
-        changed!
+      end
+
+      def save_mapper(out)
+        out.int(@bank).int(@control).blob(@io_ram)
+        @low_flash.save_state(out)
+        @high_flash.save_state(out)
+      end
+
+      def load_mapper(input)
+        @bank = input.int
+        @control = input.int
+        input.blob_into(@io_ram)
+        @low_flash.load_state(input)
+        @high_flash.load_state(input)
+        map_bank
       end
 
       def apply_control

data/lib/badline/cartridge/epyx_fastload.rb

@@ -56,6 +56,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        out.int(@discharged_at)
+      end
+
+      def load_mapper(input)
+        @discharged_at = input.int
+      end
+
       def discharge!
         @discharged_at = @clock ? @clock.call : 0
       end

data/lib/badline/cartridge/final_cartridge3.rb

@@ -62,6 +62,18 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@roml_banks, *@romh_banks, EMPTY_BANK])
+        out.boolean(@register_visible).boolean(@phi1_ultimax)
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@roml_banks, *@romh_banks, EMPTY_BANK])
+        @io_bank = @roml
+        @register_visible = input.boolean?
+        @phi1_ultimax = input.boolean?
+      end
+
       def select(number)
         @io_bank = @roml = bank(@roml_banks, number)
         @romh = bank(@romh_banks, number)

data/lib/badline/cartridge/flash.rb

@@ -2,6 +2,37 @@
 
 module Badline
   class Cartridge
+    # A Flash chip's state, for a snapshot.
+    module FlashState
+      STATES = %i[read program_setup autoselect programming erase_window erasing suspended chip_erase
+                  program_error].freeze
+
+      # The array, the command state, a timed operation's end on the
+      # machine's clock, and the windows handed out so far, which load_state
+      # builds anew.
+      def save_state(out)
+        out.blob(@data).int(STATES.index(@state)).int(STATES.index(@base_state)).int(@cycle).int(@toggle)
+        out.optional_int(@done_at).optional_int(@programmed).optional_int(@remaining)
+        out.boolean(!@erasing_sectors.nil?)
+        out.ints(@erasing_sectors) if @erasing_sectors
+        out.ints(@windows.keys).ints(@status_windows.keys)
+      end
+
+      def load_state(input)
+        input.blob_into(@data)
+        @state = STATES.fetch(input.int).to_sym
+        @base_state = STATES.fetch(input.int).to_sym
+        @cycle = input.int
+        @toggle = input.int
+        @done_at = input.optional_int
+        @programmed = input.optional_int
+        @remaining = input.optional_int
+        @erasing_sectors = nil
+        @erasing_sectors = input.ints if input.boolean?
+        rebuild_windows(input.ints, input.ints)
+      end
+    end
+
     # An AMD 29F0x0 flash chip, driven through the JEDEC command set in the
     # AMD datasheets. Each command opens with two unlock cycles, $AA to the
     # first unlock address and $55 to the second, and a third write picks
@@ -66,6 +97,8 @@ module Badline
         alias [] peek
       end
 
+      include FlashState
+
       attr_reader :data, :state
       attr_writer :clock
 
@@ -95,6 +128,14 @@ module Badline
         end
       end
 
+      # Hands out new windows at the bases given, as #window would have.
+      def rebuild_windows(bases, status_bases)
+        @windows = {}
+        @status_windows = {}
+        bases.each { |base| @windows[base] = Window.new(self, base) }
+        status_bases.each { |base| @status_windows[base] = StatusWindow.new(self, base) }
+      end
+
       def array_mode?
         @state == :read || @state == :program_setup
       end

data/lib/badline/cartridge/fun_play.rb

@@ -28,6 +28,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@banks, EMPTY_BANK])
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@banks, EMPTY_BANK])
+      end
+
       def install_chips(chips)
         @banks = []
         chips.each { |chip| @banks[self.class.bank_number(chip.bank)] = rom_bank(chip.data) }

data/lib/badline/cartridge/g_mod2.rb

@@ -47,6 +47,18 @@ module Badline
         changed!
       end
 
+      def save_mapper(out)
+        out.int(@bank).boolean(@flash_writes)
+        @flash.save_state(out)
+      end
+
+      def load_mapper(input)
+        @bank = input.int
+        @flash_writes = input.boolean?
+        @flash.load_state(input)
+        @roml = @flash.window(@bank * BANK_SIZE)
+      end
+
       def install_chips(chips)
         data = Array.new(BANKS * BANK_SIZE, 0xff)
         chips.each do |chip|

data/lib/badline/cartridge/game_system.rb

@@ -25,6 +25,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@banks, EMPTY_BANK])
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@banks, EMPTY_BANK])
+      end
+
       def select(addr)
         @roml = bank(@banks, addr & 0x3f)
         changed!

data/lib/badline/cartridge/geo_ram.rb

@@ -52,8 +52,24 @@ module Badline
         @block = @page = @window = 0
       end
 
+      # A GEO-RAM is built from its size alone.
+      def save_setup(out)
+        out.int(GEO_RAM_SETUP).int(@size)
+      end
+
       private
 
+      def save_mapper(out)
+        out.blob(@ram_data).int(@block).int(@page).int(@window)
+      end
+
+      def load_mapper(input)
+        input.blob_into(@ram_data)
+        @block = input.int
+        @page = input.int
+        @window = input.int
+      end
+
       def install_chips(_chips)
         @ram_data = Array.new(@size * 1024, 0)
         reset

data/lib/badline/cartridge/magic_desk.rb

@@ -20,6 +20,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@banks, EMPTY_BANK])
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@banks, EMPTY_BANK])
+      end
+
       def install_chips(chips)
         @banks = banks_from(chips).first
         @bank_mask = (bank_mask(@banks) | 0x03) & 0x7f

data/lib/badline/cartridge/ocean.rb

@@ -19,6 +19,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@banks, EMPTY_BANK])
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@banks, EMPTY_BANK])
+      end
+
       # In 16K mode the selected bank shows through ROMH as well.
       def select_bank(number)
         @roml = bank(@banks, number)

data/lib/badline/cartridge/pagefox.rb

@@ -29,6 +29,18 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, windows)
+        @ram_banks.each { |ram| out.blob(ram.data) }
+      end
+
+      def load_mapper(input)
+        load_windows(input, windows)
+        @ram_banks.each { |ram| input.blob_into(ram.data) }
+      end
+
+      def windows = [*@roml_banks, *@romh_banks, *@ram_banks, @open_bus || EMPTY_BANK, EMPTY_BANK]
+
       def select(value)
         half = (value >> 1) & 0x01
         chip = (value >> 2) & 0x03

data/lib/badline/cartridge/retro_replay.rb

@@ -2,6 +2,44 @@
 
 module Badline
   class Cartridge
+    # A Retro Replay's registers, RAM and flash, for a snapshot.
+    module RetroReplayState
+      private
+
+      def save_jumpers(out)
+        out.boolean(true).boolean(@flash_jumper).boolean(@bank_jumper)
+      end
+
+      def save_mapper(out)
+        [@active, @frozen, @phi1_ultimax, @ram_enabled, @ram_at_a000, @allow_bank, @no_freeze, @reu_mapping,
+         @write_once].each { |flag| out.boolean(flag) }
+        out.int(@bank).int(RetroReplay::CONTROL_MODES.index(@config))
+        @ram_data.each { |data| out.blob(data) }
+        @flash.save_state(out)
+      end
+
+      def load_mapper(input)
+        load_flags(input)
+        @bank = input.int
+        @config = RetroReplay::CONTROL_MODES.fetch(input.int)
+        @ram_data.each { |data| input.blob_into(data) }
+        @flash.load_state(input)
+        map_windows
+      end
+
+      def load_flags(input)
+        @active = input.boolean?
+        @frozen = input.boolean?
+        @phi1_ultimax = input.boolean?
+        @ram_enabled = input.boolean?
+        @ram_at_a000 = input.boolean?
+        @allow_bank = input.boolean?
+        @no_freeze = input.boolean?
+        @reu_mapping = input.boolean?
+        @write_once = input.boolean?
+      end
+    end
+
     # Retro Replay: an Am29F010 flash chip of two 64K halves, each eight 8K
     # ROM banks, and four 8K RAM banks, with the Action Replay's register at
     # $DE00 and an extended one at $DE01. The Nordic Replay (subtype 1) adds
@@ -44,6 +82,7 @@ module Badline
     # the half in bit 5.
     class RetroReplay < Cartridge
       include Freezer
+      include RetroReplayState
 
       CONTROL_MODES = %i[rom8k rom16k off ultimax].freeze
       IO1_PAGE = 0x1e00
@@ -212,11 +251,15 @@ module Badline
       end
 
       def configure
+        map_windows
+        changed!
+      end
+
+      def map_windows
         self.mode = @config
         @rom = flash_window(@bank)
         @roml = roml_window
         @romh = romh_window
-        changed!
       end
 
       def roml_window

data/lib/badline/cartridge/rgcd.rb

@@ -28,6 +28,16 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@banks, EMPTY_BANK])
+        out.boolean(@disabled)
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@banks, EMPTY_BANK])
+        @disabled = input.boolean?
+      end
+
       def select(value)
         value ^= 0x07 if @hucky
         if value.anybits?(0x08)

data/lib/badline/cartridge/super_games.rb

@@ -20,6 +20,16 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        save_windows(out, [*@roml_banks, *@romh_banks, EMPTY_BANK])
+        out.boolean(@locked)
+      end
+
+      def load_mapper(input)
+        load_windows(input, [*@roml_banks, *@romh_banks, EMPTY_BANK])
+        @locked = input.boolean?
+      end
+
       def select(value)
         @roml = bank(@roml_banks, value & 0x03)
         @romh = bank(@romh_banks, value & 0x03)

data/lib/badline/cartridge/zaxxon.rb

@@ -31,6 +31,14 @@ module Badline
         def peek(addr)
           @bank.peek(addr)
         end
+
+        def save_state(out)
+          out.int([*@banks, EMPTY_BANK].index { |bank| bank.equal?(@bank) })
+        end
+
+        def load_state(input)
+          @bank = [*@banks, EMPTY_BANK].fetch(input.int)
+        end
       end
 
       def reset
@@ -39,6 +47,14 @@ module Badline
 
       private
 
+      def save_mapper(out)
+        @romh.save_state(out)
+      end
+
+      def load_mapper(input)
+        @romh.load_state(input)
+      end
+
       def install_chips(chips)
         roml, romh = banks_from(chips)
         @romh = High.new(romh)

data/lib/badline/cartridge.rb

@@ -69,9 +69,28 @@ module Badline
         end
         mapper.new(crt, **)
       end
+
+      # A cartridge built afresh from what save_setup wrote, before
+      # load_state puts its state in.
+      def from_setup(input)
+        return GeoRAM.new(size: input.int) if input.int == GEO_RAM_SETUP
+
+        crt = Storage::CRTFile.new(bytes: input.string)
+        return RetroReplay.new(crt, flash_jumper: input.boolean?, bank_jumper: input.boolean?) if input.boolean?
+
+        from_crt(crt)
+      end
     end
 
+    # What save_setup writes first: a cartridge from a CRT image, or a
+    # GEO-RAM.
+    CRT_SETUP = 0
+    GEO_RAM_SETUP = 1
+
+    # Keeps the image it was built from, so a snapshot's machine can build
+    # the same cartridge before the snapshot's state goes into it.
     def initialize(crt)
+      @crt = crt
       @name = crt.name
       @exrom = crt.exrom
       @game = crt.game
@@ -88,6 +107,31 @@ module Badline
       @on_change = block
     end
 
+    # What builds the same cartridge afresh (Cartridge.from_setup): the CRT
+    # image it was built from, and the jumpers of a mapper that has them.
+    def save_setup(out)
+      out.int(CRT_SETUP).string(Storage::CRTFile.encode(@crt))
+      save_jumpers(out)
+    end
+
+    # The lines, the pull on NMI, the button and the mapper's own state.
+    # Loading sets them without calling back into the machine, which maps
+    # the cartridge again afterwards.
+    def save_state(out)
+      out.marker("CARTRIDGE")
+      out.int(@exrom).int(@game).boolean(@nmi).boolean(@button == true)
+      save_mapper(out)
+    end
+
+    def load_state(input)
+      input.marker("CARTRIDGE")
+      @exrom = input.int
+      @game = input.int
+      @nmi = input.boolean?
+      @button = input.boolean?
+      load_mapper(input)
+    end
+
     # Called with the level of the cartridge's pull on the NMI line when it
     # changes. The line is wired-OR with CIA 2's.
     def on_nmi_change(&block)
@@ -142,6 +186,34 @@ module Badline
 
     private
 
+    def save_jumpers(out)
+      out.boolean(false)
+    end
+
+    def save_mapper(_out); end
+
+    def load_mapper(_input); end
+
+    # Where the ROML and ROMH windows point, as their places in `windows`,
+    # the banks and views the mapper picks them from, or -1 for none.
+    def save_windows(out, windows)
+      out.int(window_index(@roml, windows)).int(window_index(@romh, windows))
+    end
+
+    def load_windows(input, windows)
+      @roml = window_at(input.int, windows)
+      @romh = window_at(input.int, windows)
+    end
+
+    def window_index(window, windows)
+      return -1 if window.nil?
+
+      windows.index { |candidate| candidate.equal?(window) } ||
+        raise(ArgumentError, "#{self.class.name}: a window that isn't among its banks")
+    end
+
+    def window_at(index, windows) = index.negative? ? nil : windows.fetch(index)
+
     def nmi=(level)
       return if @nmi == level
 

data/lib/badline/cia/interrupt_register.rb

@@ -34,6 +34,23 @@ module Badline
 
       def interrupted? = status.value >= 0x80
 
+      def save_state(out)
+        out.int(@mask.value).int(@status.value).int(@pending)
+        [@read, @read_last_cycle, @read_two_cycles_ago].each { |read| out.optional_int(read) }
+        out.boolean(@timer_b_bug).boolean(@quiet)
+      end
+
+      def load_state(input)
+        @mask.value = input.int
+        @status.value = input.int
+        @pending = input.int
+        @read = input.optional_int
+        @read_last_cycle = input.optional_int
+        @read_two_cycles_ago = input.optional_int
+        @timer_b_bug = input.boolean?
+        @quiet = input.boolean?
+      end
+
       # Raises IR on this cycle.
       def assert_now
         status.interrupt = true