badline 0.16.0 → 0.17.0

data/lib/badline/snapshot/vice/pet_restore.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # Restores a PET from a snapshot xpet wrote. The modules badline
+        # reads become the PET's own keyed modules (Keyed), which it loads
+        # as it loads its own snapshot. Whatever they don't set stays as the
+        # machine has it at power-on, and the datasettes' tapes and the
+        # disk device 8 serves stay as they are. A snapshot with a true 2031,
+        # 8050 or 8250 puts one on the bus, with the disks badline's drive
+        # of that model had in it, and one without takes badline's off.
+        module Restore
+          # MAINCPU and PETMEM hold the machine itself, so a version badline
+          # doesn't read fails the restore. The others are left out and
+          # reported.
+          READ = [MainCPU::NAME, PETMem::NAME, CRTC::NAME, "PIA1", "PIA2", VIA::NAME].freeze
+          # The host's media, which a restore keeps.
+          KEPT = %w[BL-TAPE1 BL-TAPE2 BL-TRAPDOS].freeze
+          # The disks in a true drive's drives, which a restore keeps.
+          DISKS = %w[BL-D8-DISK BL-D8-DISK1].freeze
+
+          module_function
+
+          # Applies the modules badline reads to `computer`, and returns a
+          # Report. The snapshot goes into a new machine first, so one that
+          # fails leaves `computer` as it was, and one of a machine built
+          # another way fails too.
+          def import(container, computer)
+            unless computer.family == :pet
+              raise FormatError, "the snapshot is of a PET, not a #{Image::FAMILIES.fetch(computer.family.to_s)}"
+            end
+
+            setup = PET.setup(container)
+            ours = PETSetup.of(computer)
+            raise FormatError, "the snapshot is of a #{setup}, not a #{ours}" unless setup == ours
+
+            apply(container, setup.build)
+            had_drive = computer.true_drive
+            computer.power_cycle!
+            report = apply(container, computer)
+            kept = computer.mounted? ? ["the disk mounted in device 8 stays mounted"] : []
+            if had_drive && !computer.true_drive.equal?(had_drive)
+              kept << "the #{had_drive.model_name} on device #{had_drive.device} is taken off the bus"
+            end
+            Report.new(applied: report.applied, ignored: report.ignored + kept)
+          end
+
+          # Applies the modules badline reads to `computer`, a machine built
+          # as the snapshot's was, and returns the Report.
+          def apply(container, computer)
+            applied = []
+            ignored = []
+            sections = []
+            READ.each do |name|
+              section = container[name]
+              next if section.nil?
+
+              if reads?(section)
+                applied << name
+              else
+                raise FormatError, "#{section}: badline doesn't read this version" if required?(name)
+
+                ignored << "#{section}: badline doesn't read this version, left out"
+              end
+            end
+            disks = []
+            computer.save_modules.each do |section|
+              sections << section if KEPT.include?(section.name)
+              disks << section if DISKS.include?(section.name)
+            end
+            sections += drive(container, applied, ignored, kept_disks(container, computer, disks))
+            computer.load_modules(Keyed::Modules.new(modules(container, computer, applied) + sections))
+            Report.new(applied:, ignored: ignored + left_out(container, applied))
+          end
+
+          # The disks badline's true drive has, which stay in the drive the
+          # snapshot puts on the bus when it is of the same model.
+          def kept_disks(container, computer, disks)
+            drive = computer.true_drive
+            return [] if drive.nil?
+
+            if Drive8050.present?(container)
+              Drive8050.model(container) == drive.model_name ? disks : []
+            else
+              drive.model_name == "2031" ? disks.first(1) : []
+            end
+          end
+
+          # The true drive's modules where the snapshot has one badline
+          # reads, or none.
+          def drive(container, applied, ignored, disks)
+            return drive8050(container, applied, ignored, disks) if Drive8050.present?(container)
+            return [] unless Drive2031.present?(container)
+
+            names = [Drive2031::UNITS.first, Drive2031::CPU, Drive2031::VIA1, Drive2031::VIA2]
+            return [] unless readable?(container, names, "2031", ignored) { |section| Drive2031.reads?(section) }
+
+            applied.concat(names)
+            Drive2031.import(container, disks.first)
+          end
+
+          def drive8050(container, applied, ignored, disks)
+            model = Drive8050.model(container)
+            return [] unless readable?(container, Drive8050::NAMES, model || "8050", ignored) do |section|
+              Drive8050.reads?(section)
+            end
+
+            if model.nil?
+              ignored << "the true drive: badline doesn't read its #{Drive8050::UNIT}'s type, left out"
+              return []
+            end
+
+            applied.concat(Drive8050::NAMES)
+            Drive8050.import(container, Drive8050.reference(model), disks)
+          end
+
+          # Whether the snapshot has every module `names` lists at a version
+          # badline reads, saying which it doesn't in `ignored`.
+          def readable?(container, names, model, ignored, &reads)
+            unread = names.map { |name| container[name] }.reject { |section| section && reads.call(section) }
+            return true if unread.empty?
+
+            ignored << "the true #{model}: badline doesn't read #{unread.compact.join(', ')}, left out"
+            false
+          end
+
+          def required?(name) = [MainCPU::NAME, PETMem::NAME].include?(name)
+
+          def reads?(section)
+            case section.name
+            when MainCPU::NAME then MainCPU.reads?(section)
+            when PETMem::NAME then PETMem.reads?(section)
+            when CRTC::NAME then CRTC.reads?(section)
+            when VIA::NAME then VIA.reads?(section)
+            else PIAs.reads?(section)
+            end
+          end
+
+          # The PET's keyed modules from the ones `applied` names.
+          def modules(container, computer, applied)
+            model = computer.model
+            crtc = applied.include?(CRTC::NAME) ? container[CRTC::NAME] : nil
+            video = video(crtc, computer)
+            drive = driving?(crtc, video, model)
+            sections = [Keyed.section("BL-MACHINE") { |out| machine(out, container, computer, drive) },
+                        Keyed.section("BL-RAM") do |out|
+                          PETMem.import(container[PETMem::NAME], out, model.screen_bytes)
+                        end]
+            sections << Keyed.section("BL-CPU") { |out| MainCPU.import(container[MainCPU::NAME], out) }
+            %w[PIA1 PIA2].each do |name|
+              next unless applied.include?(name)
+
+              sections << Keyed.section("BL-#{name}") do |out|
+                PIAs.import(container[name], out)
+                out.bool("cb.c1_high", drive) if name == "PIA1"
+              end
+            end
+            if applied.include?(VIA::NAME)
+              sections << Keyed.section("BL-VIA") { |out| VIA.import(container[VIA::NAME], out) }
+            end
+            sections + video
+          end
+
+          def machine(out, container, computer, drive)
+            out.text("family", "pet")
+            PETSetup.of(computer).write_fields(out)
+            out.int("cycles", FieldReader.new(container[MainCPU::NAME]).qword).bool("vertical_drive", drive)
+          end
+
+          # The vertical drive line, low in the CRTC's vertical sync or past
+          # the discrete video's rows, as the video's module, `video`, has it.
+          def driving?(crtc, video, model)
+            return true if crtc.nil?
+
+            fields = Keyed::Reader.parse(video.first)
+            if model.video == :discrete
+              fields.int("line", 0) < Badline::PET::DiscreteVideo::DISPLAYED_LINES
+            else
+              fields.int("vsync_lines", 0).zero?
+            end
+          end
+
+          # The discrete video's module, or the CRTC's, run on from xpet's
+          # counters to where badline's drops the vertical drive line on the
+          # cycle xpet's does (CRTC::CRTC_LEAD). The CRTC runs on from the
+          # start of the beam's line, or for a beam in the first cycles of
+          # its line, a frame less those cycles on, which lands on the same
+          # counters while the registers stood through the frame as they
+          # stand.
+          def video(crtc, computer)
+            return [] if crtc.nil?
+
+            model = computer.model
+            return [Keyed.section("BL-VIDEO") { |out| CRTC.import_discrete(crtc, out) }] if model.video == :discrete
+
+            counters = Keyed.section("BL-CRTC") do |out|
+              CRTC.import(crtc, out, CRTC.columns(model), CRTC.attributes(model))
+            end
+            cycles = (CRTC::CRTC_LEAD + CRTC.column_of(crtc)) % CRTC.frame_cycles(CRTC.registers(crtc))
+            fields = CRTC.run_on(CRTC.fresh_crtc(computer), Keyed::Reader.parse(counters), cycles)
+            [Keyed.section("BL-CRTC") { |out| CRTC.copy(fields, out) }]
+          end
+
+          def left_out(container, applied)
+            container.sections.reject { |section| READ.include?(section.name) || applied.include?(section.name) }
+                     .map { |section| "#{section}: badline doesn't read this module, left out" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_via.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # VIA 2.2, the 6522 at $E840: port A's and port B's output and
+        # direction registers, timer 1's latch and counter, timer 2's low
+        # and high latch, the value it was last loaded with and its counter,
+        # which timers will set their interrupt flag (timer 1 in bit 7,
+        # timer 2 in bit 6 while it counts cycles), the shift register, the
+        # ACR, the PCR, the interrupt flags and enable mask, timer 1's level
+        # on PB7 in bit 7, the shift register's clock ticks into its byte,
+        # CA2's level in bit 7, and whether timer 2's next underflow sets
+        # its flag. xpet saves each counter as a read on the next cycle
+        # finds it, where badline's holds it before that cycle counts.
+        #
+        # Written: timer 2's high latch and the value it was loaded with,
+        # which badline doesn't keep, as xpet has them before a program
+        # loads it, or while the shift register clocks off it, as its low
+        # byte reloads. Free-running, the shift register's ticks are only
+        # whether CB1 is low.
+        #
+        # Read: the registers and both timers with their latches, as they
+        # count from the next cycle, and the shift register where its clock
+        # ticks are. A load or reload under way, a shift clock tick due off
+        # timer 2 and the latched ports start afresh, and CB2's level
+        # follows from the PCR.
+        module VIA
+          NAME = "VIA"
+          MAJOR = 2
+          MINOR = 2
+          T1_ARMED = 0x80
+          T2_TIMED = 0x40
+          LEVELS = 0x60
+          # The shift register's clock ticks a byte takes, which an idle
+          # register's count stands at.
+          TICKS = 16
+          SIZE = 28
+          # The shift register's modes that clock off timer 2.
+          T2_SHIFTS = [1, 4, 5].freeze
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The VIA's module, under `name`, from its BL-VIA fields in `input`.
+          def export(input, name = NAME)
+            fields = FieldWriter.new
+            %w[ora ddra orb ddrb].each { |key| fields.byte(input.int(key, 0)) }
+            fields.word(input.int("t1.latch", 0xffff)).word(timer1(input))
+            t2 = timer2(input)
+            latch_low = input.int("t2.latch_low", 0xff)
+            fields.byte(latch_low).byte(0xff).word(shifting?(input) ? (t2 & 0xff00) | latch_low : 0xffff).word(t2)
+            fields.byte(armed(input)).byte(input.int("sr.data", 0))
+            fields.byte(input.int("acr", 0)).byte(input.int("pcr", 0))
+            fields.byte(input.int("ifr.flags", 0)).byte(input.int("ifr.enable", 0))
+            fields.byte(input.bool("t1.pb7", true) ? 0x80 : 0)
+            fields.byte(ticks(input))
+            fields.byte(LEVELS | (input.bool("ca.c2_output", true) ? 0x80 : 0)).zeros(2)
+            fields.byte(input.bool("t2.armed", false) ? 1 : 0).zeros(2).section(name, MAJOR, MINOR)
+          end
+
+          # Timer 1's counter as a read on the next cycle finds it: as it
+          # stands while a load holds it, the latch while it reloads, and one
+          # less otherwise.
+          def timer1(input)
+            counter = input.int("t1.counter", 0xffff)
+            return counter if input.bool("t1.hold", false)
+            return input.int("t1.latch", 0xffff) if input.bool("t1.reload", false)
+
+            (counter - 1) & 0xffff
+          end
+
+          # Timer 2's counter as a read on the next cycle finds it: as it
+          # stands while it counts pulses or a load holds it, and one less
+          # otherwise.
+          def timer2(input)
+            counter = input.int("t2.counter", 0xffff)
+            return counter if input.bool("t2.hold", false) || input.bool("t2.counting_pulses", false)
+
+            (counter - 1) & 0xffff
+          end
+
+          # The shift register's clock ticks into its byte: two a bit, the
+          # first one dropping CB1, TICKS when idle. Free-running, its bits
+          # never run out, and only whether CB1 is low counts.
+          def ticks(input)
+            bits = input.int("sr.bits", 0)
+            return TICKS if bits.zero?
+
+            low = input.bool("sr.clock", true) ? 0 : 1
+            return low if input.int("sr.mode", 0) == 4
+
+            ((8 - bits) * 2) + low
+          end
+
+          # The shift register from its mode, data and the ticks into its
+          # byte (#ticks), with the last bit put out on CB2, or CB2 high
+          # as it is at power-on while the register is off.
+          def shift_register(out, mode, data, ticks)
+            ticks = [ticks, TICKS].min
+            bits = ticks == TICKS ? 0 : 8 - (ticks / 2)
+            bits = 8 if mode == 4 && ticks < TICKS
+            out.int("sr.mode", mode).int("sr.data", data).int("sr.bits", bits).int("sr.delay", 0)
+            out.bool("sr.clock", ticks.even?).bool("sr.cb2", mode.zero? || ticks.zero? || data.anybits?(0x01))
+          end
+
+          # Whether the shift register clocks off timer 2.
+          def shifting?(input) = T2_SHIFTS.include?((input.int("acr", 0) >> 2) & 0x07)
+
+          # Timer 2 sets its flag, or clocks the shift register, while it
+          # counts cycles.
+          def armed(input)
+            pulses = input.bool("t2.count_pulses", false)
+            timed = !pulses && (input.bool("t2.armed", false) || shifting?(input))
+            (input.bool("t1.armed", false) ? T1_ARMED : 0) | (timed ? T2_TIMED : 0)
+          end
+
+          # The registers, the timers and the control lines by their BL-VIA
+          # keys, in a keyed module's writer.
+          def import(section, out)
+            bytes = FieldReader.new(section).bytes(SIZE)
+            acr = bytes[0x10]
+            pcr = bytes[0x11]
+            out.int("ora", bytes[0]).int("ddra", bytes[1]).int("orb", bytes[2]).int("ddrb", bytes[3])
+            out.int("acr", acr).int("pcr", pcr)
+            timers(out, bytes, acr)
+            shift_register(out, (acr >> 2) & 0x07, bytes[0x0f], bytes[0x15])
+            out.int("ifr.flags", bytes[0x12] & 0x7f).int("ifr.enable", bytes[0x13] & 0x7f)
+            control_lines(out, "ca.", pcr & 0x0f, bytes[0x16].anybits?(0x80))
+            control_lines(out, "cb.", pcr >> 4, true)
+          end
+
+          def timers(out, bytes, acr)
+            out.int("t1.latch", bytes[4] | (bytes[5] << 8)).int("t1.counter",
+                                                                ((bytes[6] | (bytes[7] << 8)) + 1) & 0xffff)
+            out.bool("t1.hold", false)
+            out.bool("t1.reload", false).bool("t1.armed", bytes[0x0e].anybits?(T1_ARMED))
+            out.bool("t1.pb7", bytes[0x14].anybits?(0x80))
+            pulses = acr.anybits?(0x20)
+            t2 = bytes[0x0c] | (bytes[0x0d] << 8)
+            out.int("t2.latch_low", bytes[8]).int("t2.counter", pulses ? t2 : (t2 + 1) & 0xffff).bool("t2.hold", false)
+            out.bool("t2.low_reload", false).bool("t2.low_underflowed", false)
+            out.bool("t2.armed", bytes[0x19].anybits?(0x01))
+            out.bool("t2.count_pulses", pulses).bool("t2.counting_pulses", pulses)
+          end
+
+          # A handshake under way holds C2 low.
+          def control_lines(out, prefix, control, c2_high)
+            mode = control >> 1
+            handshake_low = mode == 4 && !c2_high
+            output = case mode
+                     when 4 then !handshake_low
+                     when 6 then false
+                     else true
+                     end
+            out.int("#{prefix}control", control).bool("#{prefix}handshake_low", handshake_low)
+            out.int("#{prefix}pulse", 0).bool("#{prefix}c2_output", output)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/sid_registers.rb

@@ -38,7 +38,8 @@ module Badline
 
         def import(section, computer)
           registers = FieldReader.new(section).skip(4).bytes(0x20)
-          registers.first(0x19).each_with_index { |value, reg| computer.sid.poke(0xd400 + reg, value) }
+          sid = computer.sid
+          registers.first(0x19).each_with_index { |value, reg| sid.poke(sid.start + reg, value) }
         end
       end
     end

data/lib/badline/snapshot/vice/vicii_import.rb

@@ -4,20 +4,24 @@ module Badline
   module Snapshot
     module Vice
       module VICII
-        # Reads a VIC-II module and puts it into badline's VIC.
+        # Reads a VIC-II module and puts it into badline's VIC. A reader of
+        # another layout passes no fields and sets the same state itself.
         class Import
           def initialize(fields)
             @fields = fields
+            return if fields.nil?
+
             read_beam
             read_counters
             read_sprites
           end
 
-          def apply(computer)
-            vic = computer.vic
-            computer.address_bus.color_ram.tap do |ram|
-              @color_ram.each_with_index { |value, offset| ram.poke(0xd800 + offset, value) }
-            end
+          def apply(computer) = apply_to(computer.vic, computer.address_bus.color_ram, 0xd800)
+
+          # Puts it into `vic`, with its colour RAM into `color_ram` from
+          # `base`.
+          def apply_to(vic, color_ram, base)
+            @color_ram.each_with_index { |value, offset| color_ram.poke(base + offset, value) }
             load_registers(vic)
             position(vic)
             load_counters(vic)

data/lib/badline/snapshot/vice.rb

@@ -13,6 +13,10 @@ require "badline/snapshot/vice/peripherals"
 require "badline/snapshot/vice/vicii"
 require "badline/snapshot/vice/vicii_import"
 require "badline/snapshot/vice/restore"
+require "badline/snapshot/vice/pet"
+require "badline/snapshot/vice/cbm2"
+require "badline/snapshot/vice/p500"
+require "badline/snapshot/vice/p500_restore"
 
 module Badline
   module Snapshot

data/lib/badline/snapshot.rb

@@ -36,8 +36,8 @@ module Badline
     # end of the instruction its CPU is in, and of an REU transfer under
     # way (Machine::Settling), so a save advances it by a few cycles, and a
     # second save straight after runs none. A VIC-20's, a C128's, a
-    # Plus/4's or a PET's snapshot is in a container named as xvic, x128,
-    # xplus4 or xpet names its machine.
+    # Plus/4's, a PET's or a CBM-II's snapshot is in a container named as
+    # xvic, x128, xplus4, xpet or xcbm2 names its machine.
     def dump(computer) = Image.of(computer).to_s
 
     def read(path) = Image.new(Container.parse(File.binread(path)), name: File.basename(path))
@@ -52,7 +52,7 @@ module Badline
     def restore(computer, path, &) = read(path).restore(computer, &)
 
     # A machine's snapshots, as .vsf files and in memory. C64, Vic20, C128,
-    # Plus4 and PET each include it.
+    # Plus4, PET, CBM2 and CBM2::P500 each include it.
     module Files
       def save_snapshot(path) = Snapshot.save(self, path)
 
@@ -99,4 +99,12 @@ module Badline
   class PET
     include Snapshot::Files
   end
+
+  class CBM2
+    include Snapshot::Files
+
+    class P500
+      include Snapshot::Files
+    end
+  end
 end

data/lib/badline/storage/crt_file.rb

@@ -8,6 +8,7 @@ module Badline
       SIGNATURE = "C64 CARTRIDGE   ".b
       VIC20_SIGNATURE = "VIC20 CARTRIDGE ".b
       PLUS4_SIGNATURE = "PLUS4 CARTRIDGE ".b
+      CBM2_SIGNATURE = "CBM2 CARTRIDGE  ".b
       CHIP_SIGNATURE = "CHIP".b
       CHIP_HEADER_SIZE = 0x10
       RAM_CHIP = 1
@@ -19,6 +20,9 @@ module Badline
       # What .write needs of an image: the fields a parsed CRTFile reads.
       Image = Data.define(:hardware_type, :subtype, :exrom, :game, :name, :chips)
 
+      # Whether the file at +path+ is signed as a CBM-II's cartridge.
+      def self.cbm2?(path) = File.binread(path, CBM2_SIGNATURE.length) == CBM2_SIGNATURE
+
       def self.write(path, image)
         File.binwrite(path, encode(image))
       end
@@ -36,7 +40,8 @@ module Badline
       end
 
       # `bytes` stands in for the file's contents. `machine` is the one the
-      # image has to be for, :c64, :vic20 or :plus4, or nil for any.
+      # image has to be for, :c64, :vic20, :plus4 or :cbm2, or nil for
+      # any.
       def initialize(path = nil, bytes: nil, machine: :c64)
         parse(bytes || File.binread(path))
         return if machine.nil? || @machine == machine
@@ -60,6 +65,7 @@ module Badline
         return :c64 if bytes.start_with?(SIGNATURE)
         return :vic20 if bytes.start_with?(VIC20_SIGNATURE)
         return :plus4 if bytes.start_with?(PLUS4_SIGNATURE)
+        return :cbm2 if bytes.start_with?(CBM2_SIGNATURE)
 
         raise FormatError, "Missing CRT signature"
       end

data/lib/badline/storage/d64_image.rb

@@ -52,6 +52,13 @@ module Badline
       def bam_tracks = 1..35
       def bam_count(track) = [18, 0, 4 * track]
       def bam_bitmap(track) = [18, 0, (4 * track) + 1]
+      def bitmap_size = 3
+
+      # The header links the directory and holds the BAM itself.
+      def header_link = [18, 1]
+      def dos_type = "2A"
+      def header_tail = 4
+      def bam_headers(_id) = []
     end
   end
 end

data/lib/badline/storage/d80_image.rb

@@ -31,7 +31,7 @@ module Badline
       def directory_track = 39
       def directory_sector = 1
       def directory_interleave = 3
-      def interleave = 6
+      def interleave = 5
 
       # Only the directory track is kept from files. The BAM's blocks on
       # track 38 are marked in use, and the rest of that track holds files.
@@ -43,6 +43,22 @@ module Badline
       def bam_tracks = 1..SIDE_TRACKS
       def bam_count(track) = [38, 3 * ((track - 1) / 50), 6 + (5 * ((track - 1) % 50))]
       def bam_bitmap(track) = [38, 3 * ((track - 1) / 50), 7 + (5 * ((track - 1) % 50))]
+      def bitmap_size = 4
+
+      # The header links the BAM's first block, and each BAM block the next,
+      # the last one the directory. A BAM block names the format and the
+      # first track it covers and the one past its last.
+      def header_link = [38, 0]
+      def dos_type = "2C"
+      def header_tail = 4
+
+      def bam_headers(_id)
+        groups = bam_tracks.each_slice(50).to_a
+        groups.each_with_index.map do |tracks, block|
+          link = block == groups.length - 1 ? [directory_track, directory_sector] : [38, 3 * (block + 1)]
+          [38, 3 * block, [*link, dos_type.getbyte(1), 0, tracks.first, tracks.last + 1]]
+        end
+      end
     end
   end
 end

data/lib/badline/storage/d81_image.rb

@@ -21,6 +21,20 @@ module Badline
       def bam_tracks = 1..80
       def bam_count(track) = [40, track > 40 ? 2 : 1, 0x10 + (((track - 1) % 40) * 6)]
       def bam_bitmap(track) = [40, track > 40 ? 2 : 1, 0x11 + (((track - 1) % 40) * 6)]
+      def bitmap_size = 5
+
+      # The header links the directory's first block, at 40/3. Each BAM
+      # block links the next, names the format and its complement, and
+      # holds the ID and the I/O byte.
+      def header_link = [40, 3]
+      def dos_type = "3D"
+      def header_tail = 2
+
+      def bam_headers(id)
+        [[40, 1, [40, 2]], [40, 2, [0, 0xff]]].map do |track, sector, link|
+          [track, sector, [*link, 0x44, 0xbb, *id, 0xc0, 0]]
+        end
+      end
 
       def sectors_in(_track) = 40
     end

data/lib/badline/storage/disk_image/bam.rb

@@ -71,17 +71,32 @@ module Badline
         end
 
         # A chain's first block goes on the free track nearest the
-        # directory. Each block after it goes the interleave further round
-        # the same track, or on the next track out once that one is full.
+        # directory, from its sector 0. Each block after it looks from the
+        # interleave further round the track (#next_sector), on the same
+        # track or, once that one is full, from the same sector on the next
+        # track out.
         def next_block(track = nil, sector = nil)
           candidates = track ? [track, *tracks_after(track)] : allocation_order
+          start = track ? next_sector(track, sector) : 0
           candidates.each do |candidate|
-            free = free_sector(candidate, candidate == track ? sector + interleave : 0)
+            free = free_sector(candidate, start)
             return [candidate, free] if free
           end
           nil
         end
 
+        # The interleave on from the sector. Past the track's last sector
+        # it comes round again one short, but never below sector 0, as
+        # the 2031, 8050, 8250 and 1581 DOS do.
+        def next_sector(track, sector)
+          start = sector + interleave
+          count = sectors_in(track)
+          return start if start < count
+
+          start -= count
+          start.positive? ? start - 1 : start
+        end
+
         def free_sector(track, first)
           count = sectors_in(track)
           (0...count).map { |i| (first + i) % count }.find { |s| block_free?(track, s) }