badline 0.11.0 → 0.12.0

data/lib/badline/cartridge/ocean.rb

@@ -19,14 +19,6 @@ 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

@@ -30,12 +30,12 @@ module Badline
       private
 
       def save_mapper(out)
-        save_windows(out, windows)
+        super
         @ram_banks.each { |ram| out.blob(ram.data) }
       end
 
       def load_mapper(input)
-        load_windows(input, windows)
+        super
         @ram_banks.each { |ram| input.blob_into(ram.data) }
       end
 

data/lib/badline/cartridge/retro_replay.rb

@@ -90,6 +90,11 @@ module Badline
 
       attr_reader :flash
 
+      def self.from_jumpers(crt, input)
+        input.boolean?
+        new(crt, flash_jumper: input.boolean?, bank_jumper: input.boolean?)
+      end
+
       def initialize(crt, flash_jumper: false, bank_jumper: false)
         @nordic = crt.subtype == 1
         @flash_jumper = flash_jumper
@@ -131,9 +136,7 @@ module Badline
         end
       end
 
-      def phi1_ultimax?
-        @phi1_ultimax
-      end
+      def phi1_ultimax? = @phi1_ultimax
 
       def ultimax_a000
         @isolated[ram_view_bank] if @nordic && @ram_at_a000 && @frozen
@@ -157,9 +160,7 @@ module Badline
 
       private
 
-      def freeze_allowed?
-        !@no_freeze && !@flash_jumper
-      end
+      def freeze_allowed? = !@no_freeze && !@flash_jumper
 
       def status
         ((@bank & 0x03) << 3) | ((@bank & 0x04) << 5) | ((@bank & 0x08) << 2) | (@flash_jumper ? 0x01 : 0) |

data/lib/badline/cartridge/rex_utility.rb

@@ -10,16 +10,12 @@ module Badline
       end
 
       def peek(addr)
-        if addr >= 0xdf00
-          self.mode = (addr & 0xff) < 0xc0 ? :off : :rom8k
-          changed!
-        end
+        select_mode((addr & 0xff) < 0xc0 ? :off : :rom8k) if addr >= 0xdf00
         open_bus(addr)
       end
 
       def reset
-        self.mode = :rom8k
-        changed!
+        select_mode(:rom8k)
       end
 
       private

data/lib/badline/cartridge/rgcd.rb

@@ -29,12 +29,12 @@ module Badline
       private
 
       def save_mapper(out)
-        save_windows(out, [*@banks, EMPTY_BANK])
+        super
         out.boolean(@disabled)
       end
 
       def load_mapper(input)
-        load_windows(input, [*@banks, EMPTY_BANK])
+        super
         @disabled = input.boolean?
       end
 

data/lib/badline/cartridge/simons_basic.rb

@@ -24,11 +24,6 @@ module Badline
 
       private
 
-      def select_mode(mode)
-        self.mode = mode
-        changed!
-      end
-
       def install_chips(chips)
         roml, romh = banks_from(chips)
         @roml = bank(roml, 0)

data/lib/badline/cartridge/super_games.rb

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

data/lib/badline/cartridge/westermann.rb

@@ -9,16 +9,12 @@ module Badline
       end
 
       def peek(addr)
-        if addr >= 0xdf00
-          self.mode = :rom8k
-          changed!
-        end
+        select_mode(:rom8k) if addr >= 0xdf00
         open_bus(addr)
       end
 
       def reset
-        self.mode = :rom16k
-        changed!
+        select_mode(:rom16k)
       end
 
       private

data/lib/badline/cartridge.rb

@@ -63,11 +63,7 @@ module Badline
       end
 
       def from_crt(crt, **)
-        mapper = HARDWARE_TYPES.fetch(crt.hardware_type) do
-          raise UnsupportedTypeError,
-                "Unsupported cartridge hardware type #{crt.hardware_type}"
-        end
-        mapper.new(crt, **)
+        mapper_for(crt).new(crt, **)
       end
 
       # A cartridge built afresh from what save_setup wrote, before
@@ -76,9 +72,21 @@ module Badline
         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?
+        mapper_for(crt).from_jumpers(crt, input)
+      end
 
-        from_crt(crt)
+      # A cartridge from its image and what save_jumpers wrote: whether
+      # there are jumpers, then their settings on a mapper that has them.
+      def from_jumpers(crt, input)
+        input.boolean?
+        new(crt)
+      end
+
+      def mapper_for(crt)
+        HARDWARE_TYPES.fetch(crt.hardware_type) do
+          raise UnsupportedTypeError,
+                "Unsupported cartridge hardware type #{crt.hardware_type}"
+        end
       end
     end
 
@@ -95,6 +103,7 @@ module Badline
       @exrom = crt.exrom
       @game = crt.game
       @roml = @romh = nil
+      @banks = nil
       @on_change = nil
       @on_nmi_change = nil
       @nmi = false
@@ -193,9 +202,22 @@ module Badline
       out.boolean(false)
     end
 
-    def save_mapper(_out); end
+    # The mapper's own state: where its windows point, for a mapper that
+    # moves them, and whatever a mapper adds after calling super.
+    def save_mapper(out)
+      save_windows(out, windows) if windows
+    end
 
-    def load_mapper(_input); end
+    def load_mapper(input)
+      load_windows(input, windows) if windows
+    end
+
+    # The banks and views ROML and ROMH can point at, which a snapshot
+    # names them by: the mapper's banks, or nothing for a mapper whose
+    # windows stay where install_chips put them.
+    def windows
+      [*@banks, EMPTY_BANK] if @banks
+    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.
@@ -232,6 +254,12 @@ module Badline
       @exrom, @game = MODES.fetch(mode)
     end
 
+    # Sets the lines and tells the machine to map the cartridge again.
+    def select_mode(mode)
+      self.mode = mode
+      changed!
+    end
+
     def open_bus(addr)
       @open_bus ? @open_bus.peek(addr) : 0xff
     end

data/lib/badline/cia/fast_forward.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  class CIA
+    # Running a CIA a stretch of cycles at once, for Drive::Idle.
+    module FastForward
+      # quiet_cycles for a CIA whose counters will never set a flag.
+      QUIET = 1 << 40
+
+      # Whether fast_forward can run the CIA: timer B stopped with nothing
+      # in its pipeline, no interrupt or acknowledge on its way, CNT where it
+      # was, the TOD clock stopped, and timer A either stopped, or free
+      # running (Timer#free_running?) with its interrupt masked and the
+      # serial port an idle input. Drive::Idle sleeps the 1571's CIA through
+      # such cycles, which its DOS leaves timer A running in.
+      def quiet?
+        return false unless @tb.idle? && @icr.quiet && @tod.quiet? && cnt_steady?
+
+        @ta.idle? ? @serial.idle : timer_a_free_running?
+      end
+
+      # How many cycles the CIA can run with nothing but its counters
+      # moving: as quiet? allows, but with timer B free running too, up to
+      # the cycle before it underflows. The 1581's DOS leaves timer B
+      # interrupting every 10 ms.
+      def quiet_cycles
+        return 0 unless @icr.quiet && @tod.quiet? && cnt_steady? && timer_a_quiet?
+        return QUIET if @tb.idle?
+        return 0 unless @tb.free_running? && @control_b.value.nobits?(0x60)
+
+        @tb.counter - 1
+      end
+
+      # Runs +cycles+ cycles at once while quiet? or for quiet_cycles, as
+      # cycle! would: timer A's underflows flag in the ICR, and reach the
+      # serial port's underflow line.
+      def fast_forward(cycles)
+        @tod.fast_forward(cycles)
+        @tb.fast_forward(cycles) unless @tb.idle?
+        return if @ta.idle?
+
+        @icr.flag(:timer_a) if @ta.fast_forward(cycles).positive?
+        @serial.follow_underflow(@ta.underflowed)
+      end
+
+      private
+
+      def timer_a_quiet? = @ta.idle? ? @serial.idle : timer_a_free_running?
+
+      # Timer A free running with its interrupt masked, and the serial port
+      # an idle input it only clocks.
+      def timer_a_free_running?
+        @ta.free_running? && !@control_a.serial_mode? && @icr.mask.value.nobits?(0x01) && @serial.drained?
+      end
+
+      # Whether CNT holds the level the last cycle sampled.
+      def cnt_steady? = @serial.cnt == @cnt_high && !@cnt_rise
+    end
+  end
+end

data/lib/badline/cia/serial.rb

@@ -79,6 +79,18 @@ module Badline
         @control.serial_mode?
       end
 
+      # Whether nothing is counting down or in the delay lines, so only
+      # timer A's underflows reach the register.
+      def drained? = idle?
+
+      # Takes timer A's underflow line as cycle! would have left it, with
+      # +underflowed+ its level on the last cycle, for a CIA run without
+      # the register in use (CIA#fast_forward).
+      def follow_underflow(underflowed)
+        @underflow_high = underflowed
+        @idle = !underflowed
+      end
+
       def cnt_in=(level)
         @cnt_in = level
         @cnt = level unless output?

data/lib/badline/cia/timer.rb

@@ -24,6 +24,32 @@ module Badline
         control.out_mode? ? @toggle : @underflowed
       end
 
+      # Whether the timer is stopped with nothing in its pipeline, so a
+      # cycle changes nothing.
+      def idle? = @empty && !started?
+
+      # Whether the timer counts ø2 in continuous mode with nothing pending
+      # but the reload after an underflow, so fast_forward can run it. A
+      # latch below 2 is left out.
+      def free_running?
+        started? && !@control.run_mode? && @control.value.nobits?(0x20) && @latch >= 2 && @pipe == 0b11 &&
+          (@load_delay | @oneshot_linger).zero? && (@settled || @reload)
+      end
+
+      # Runs a free-running timer +cycles+ cycles at once, as cycle! would:
+      # an underflow every latch + 1 cycles, each one followed by the
+      # reload. Returns the underflows.
+      def fast_forward(cycles)
+        return 0 if cycles.zero?
+        return after_underflow(cycles, 0) unless @settled
+
+        if cycles < @counter
+          @counter -= cycles
+          return 0
+        end
+        after_underflow(cycles - @counter, 1)
+      end
+
       def cycle!(feed)
         feed &&= @control.value & 0x01 != 0
         if @settled
@@ -98,6 +124,19 @@ module Badline
         @control.value & 0x01 != 0
       end
 
+      # Where fast_forward lands +cycles+ after an underflow, with
+      # +underflows+ underflows counted so far.
+      def after_underflow(cycles, underflows)
+        periods, rest = cycles.divmod(@latch + 1)
+        underflows += periods
+        @toggle = !@toggle if underflows.odd?
+        @underflowed = rest.zero?
+        @reload = rest.zero?
+        @counter = @latch - (rest.zero? ? 0 : rest - 1)
+        settle
+        underflows
+      end
+
       def enter
         @pipe = 0b10
         @empty = false

data/lib/badline/cia.rb

@@ -4,12 +4,14 @@ require "badline/cia/interrupt_register"
 require "badline/cia/serial"
 require "badline/cia/timer"
 require "badline/cia/state"
+require "badline/cia/fast_forward"
 
 module Badline
   # CIA (Complex Interface Adapter) chip
   class CIA
     include Addressable
     include State
+    include FastForward
 
     # The original NMOS 6526 of the breadbin C64, and the HMOS 6526A of the
     # C64C, which differs from it only in its interrupt control register.
@@ -59,14 +61,16 @@ module Badline
       @tb.latch = value
     end
 
-    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL)
+    # +tod_hz+ is the rate of the pulses on the TOD pin, the region's mains
+    # unless a machine feeds it otherwise, and 0 for a pin held still.
+    def initialize(start: 0, peripheral: nil, model: :mos6526, region: Region::PAL, tod_hz: nil)
       raise ArgumentError, "unknown CIA model #{model}" unless MODELS.include?(model)
 
       addressable_at(start, length: 2**8)
 
       @model = model
       @clock_hz = region.clock_hz
-      @mains_hz = region.mains_hz
+      @mains_hz = tod_hz || region.mains_hz
 
       @peripheral = peripheral
       @port_b4_handler = nil
@@ -137,9 +141,10 @@ module Badline
 
     # Port A as driven by the data/direction registers alone, without
     # peripheral pulldown. Cheap path for the VIC bank lookup.
-    def port_a_lines
-      driven_lines(@data_port_a, @data_dir_a)
-    end
+    def port_a_lines = driven_lines(@data_port_a, @data_dir_a)
+
+    # Port B as driven by the data/direction registers alone.
+    def port_b_lines = driven_lines(@data_port_b, @data_dir_b)
 
     def read_port_b
       lines = driven_lines(@data_port_b, @data_dir_b)

data/lib/badline/computer/attachments.rb

@@ -3,9 +3,11 @@
 module Badline
   class Computer
     # What plugs into the machine besides its chips, the cartridge, the
-    # disk device 8 serves through the traps, a true 1541 and an REU, and
-    # their state for a snapshot.
+    # disk device 8 serves through the traps, its true drives (TrueDrives)
+    # and an REU, and their state for a snapshot.
     module Attachments
+      include TrueDrives
+
       # Puts the cartridge in the expansion port and wires its clock and NMI
       # line to the machine, leaving the machine's state as it is. A
       # restored snapshot's cartridge comes back through here.
@@ -44,36 +46,8 @@ module Badline
       # it.
       attr_reader :iec_bus
 
-      # Plugs in a Drive1541, which then runs alongside the C64 on its own
-      # clock and talks to it over the serial bus. The serial traps stop
-      # answering the drive's device number, so the KERNAL's TALK, LISTEN and
-      # byte transfers reach the drive. The LOAD and SAVE traps stay, and
-      # still serve a mounted image.
-      def attach_drive1541(drive)
-        @iec_bus.detach(@drive1541) if @drive1541
-        drive.host_clock_hz = region.clock_hz
-        @drive1541 = drive
-        drive.connect(iec_bus)
-        @serial_trap&.device = serial_trap_device
-      end
-
-      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
-      def detach_drive1541
-        return unless @drive1541
-
-        @iec_bus.detach(@drive1541)
-        @drive1541 = nil
-        @serial_trap&.device = serial_trap_device
-      end
-
       private
 
-      # The device number the serial traps answer: device 8, unless a true
-      # drive is on the bus as device 8.
-      def serial_trap_device
-        @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
-      end
-
       # CIA 2's port A drives the serial bus, which reads CLK and DATA back
       # into it.
       def plug_serial_bus
@@ -126,26 +100,6 @@ module Badline
         @save_trap.load_state(input)
       end
 
-      # A true 1541 on the serial bus. The leading flag is the bus itself,
-      # which every machine now has, kept so older snapshots still load.
-      def save_serial_bus(out)
-        out.boolean(true).boolean(!@drive1541.nil?)
-        return unless @drive1541
-
-        out.int(@drive1541.device)
-        @drive1541.save_state(out)
-      end
-
-      def load_serial_bus(input)
-        input.boolean?
-        return detach_drive1541 unless input.boolean?
-
-        device = input.int
-        detach_drive1541 if @drive1541 && @drive1541.device != device
-        attach_drive1541(Drive1541.new(device:)) unless @drive1541
-        @drive1541.load_state(input)
-      end
-
       # The REU, which the setup says the machine has, and whether it has
       # asked for the bus. Its IRQ line reaches the CPU as it was.
       def save_reu(out)

data/lib/badline/computer/true_drives.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Badline
+  class Computer
+    # The true drives on the C64's serial bus: a Drive1541, and a Drive1581
+    # (Drive1581::Slot), each in a field of its own, and their state for a
+    # snapshot.
+    module TrueDrives
+      include Drive1581::Slot
+
+      # Plugs in a Drive1541, which then runs alongside the C64 on its own
+      # clock and talks to it over the serial bus. The serial traps stop
+      # answering the drive's device number, so the KERNAL's TALK, LISTEN and
+      # byte transfers reach the drive. The LOAD and SAVE traps stay, and
+      # still serve a mounted image.
+      def attach_drive1541(drive)
+        @iec_bus.detach(@drive1541) if @drive1541
+        drive.host_clock_hz = region.clock_hz
+        @drive1541 = drive
+        drive.connect(iec_bus)
+        @serial_trap&.device = serial_trap_device
+      end
+
+      # The true drive on the serial bus: the Drive1581 ahead of the
+      # Drive1541, or nil.
+      def true_drive = @drive1581 || @drive1541
+
+      # Plugs a Drive1541 in as device 8, in place of a 1581 there, and
+      # returns it.
+      def plug_true_drive
+        detach_drive1581 if drive1581_on_device8?
+        Drive1541.new.tap { |drive| attach_drive1541(drive) }
+      end
+
+      # Unplugs the Drive1541, leaving the serial bus with nothing on it.
+      def detach_drive1541
+        return unless @drive1541
+
+        @iec_bus.detach(@drive1541)
+        @drive1541 = nil
+        @serial_trap&.device = serial_trap_device
+      end
+
+      private
+
+      # The device number the serial traps answer: device 8, unless a true
+      # drive is on the bus as device 8.
+      def serial_trap_device
+        device = KernalTrap::Routine::DEVICE
+        @drive1541&.device == device || drive1581_on_device8? ? nil : device
+      end
+
+      # A true 1541 on the serial bus, then a 1581. The leading flag is the
+      # bus itself, which every machine now has.
+      def save_serial_bus(out)
+        out.boolean(true).boolean(!@drive1541.nil?)
+        if @drive1541
+          out.int(@drive1541.device)
+          @drive1541.save_state(out)
+        end
+        save_drive1581(out)
+      end
+
+      def load_serial_bus(input)
+        input.boolean?
+        load_drive1541(input)
+        load_drive1581(input)
+      end
+
+      def load_drive1541(input)
+        return detach_drive1541 unless input.boolean?
+
+        device = input.int
+        detach_drive1541 if @drive1541 && @drive1541.device != device
+        attach_drive1541(Drive1541.new(device:)) unless @drive1541
+        @drive1541.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/computer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/computer/true_drives"
 require "badline/computer/attachments"
 require "badline/computer/kernal_traps"
 require "badline/computer/saved_state"
@@ -77,6 +78,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
+      @drive1581 = nil
       plug_serial_bus
       @reu = reu ? plug_reu(reu) : nil
     end
@@ -101,6 +103,7 @@ module Badline
       watch_freeze if @freezing
       clock_cpu
       @drive1541&.host_cycle!
+      @drive1581&.host_cycle!
 
       @cycles += 1
     end
@@ -174,6 +177,7 @@ module Badline
       @dma = false
       @drive&.reset!
       @drive1541&.reset!
+      @drive1581&.reset!
       @freezing = false
       @nmi_asserted = false
       cpu.reset!

data/lib/badline/core.rb

@@ -38,6 +38,8 @@ require "badline/vic"
 require "badline/keyboard_buffer"
 require "badline/iec_bus"
 require "badline/drive1541"
+require "badline/drive1581"
+require "badline/drive1581/slot"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
 require "badline/computer"