badline 0.16.0 → 0.17.0

data/lib/badline/snapshot/field_doc.rb

@@ -37,8 +37,11 @@ module Badline
       # The machines the doc is made from: each family at power-on, the C64
       # with each kind of expansion, cartridge and media, and a second SID,
       # the 264 series' models, its TCBM interface, cartridge, tape and
-      # true drives, the 1541 and the 1551, and a CRTC PET, a 2001, an 8096
-      # and a PET with a disk and tapes.
+      # true drives, the 1541 and the 1551, a CRTC PET, a 2001, an 8096,
+      # an 8296 with its user port jumpered, a PET with a disk and tapes and
+      # one with a true 2031, one with an 8050 and one with an 8250, and a
+      # 610, a 720, a 610 with a cartridge and one with a disk, and a PAL
+      # and an NTSC 510.
       def self.machines
         {
           "c64" => [C64.new, C64.new(ram_expansion: :plus256k), C64.new(reu: 512),
@@ -50,7 +53,11 @@ module Badline
                       Plus4.new(sid_card: :mos8580, sid_card_address: 0xfe80),
                       Plus4.new(ram_expansion: :csory256),
                       plus4_with_cartridge, plus4_with_tape, plus4_with_drive, plus4_with_drive("1551")],
-          "pet" => [PET.new, PET.new(model: "2001"), PET.new(model: "8096"), pet_with_media]
+          "pet" => [PET.new, PET.new(model: "2001"), PET.new(model: "8096"),
+                    PET.new(model: "8296", characters: "din", jumpers: %w[userport]), pet_with_media,
+                    pet_with_drive, pet_with_unit("8050"), pet_with_unit("8250")],
+          "cbm2" => [CBM2.new, CBM2.new(model: "720", kernal: "03b", mains_hz: 60), cbm2_with_cartridge,
+                     cbm2_with_disk, CBM2::P500.new, CBM2::P500.new(model: "510ntsc")]
         }
       end
 
@@ -65,8 +72,37 @@ module Badline
         end
       end
 
+      # A PET with a 2031 holding a blank disk.
+      def self.pet_with_drive
+        PET.new.tap do |machine|
+          image = Storage::D64Image.new("", bytes: blank(174_848))
+          machine.plug_true_drive.insert(Drives::Model1541::Disk.decode(image))
+        end
+      end
+
+      # A PET with an 8050 or an 8250 holding a blank disk in drive 0.
+      def self.pet_with_unit(model)
+        image = if model == "8250"
+                  Storage::D82Image.new("", bytes: blank(1_066_496))
+                else
+                  Storage::D80Image.new("", bytes: blank(533_248))
+                end
+        PET.new.tap { |machine| machine.plug_drive8050(model).insert(Drives::Model8050::Disk.new(image)) }
+      end
+
       def self.blank(length) = Array.new(length, 0)
 
+      # A 610 with a disk in device 8 through the traps.
+      def self.cbm2_with_disk
+        CBM2.new.tap { |machine| machine.mount(Storage::D64Image.new("", read_only: true, bytes: blank(174_848))) }
+      end
+
+      # A 610 with an 8K cartridge ROM at $2000.
+      def self.cbm2_with_cartridge
+        chip = Storage::CRTFile::Chip.new(chip_type: 0, bank: 0, address: 0x2000, data: blank(0x2000))
+        CBM2.new.tap { |machine| machine.attach_cartridge([chip]) }
+      end
+
       def self.with_cartridge(type)
         chips = [0x8000, 0xa000].map do |address|
           Storage::CRTFile::Chip.new(chip_type: 2, bank: 0, address:, data: blank(0x2000))

data/lib/badline/snapshot/image.rb

@@ -34,7 +34,15 @@ module Badline
     # of a machine in memory (.of).
     class Image
       MACHINE = "BL-MACHINE"
-      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET" }.freeze
+      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET",
+                   "cbm2" => "CBM-II" }.freeze
+
+      # The snapshots VICE's emulators write that badline doesn't read, by
+      # the machine their container names.
+      UNREAD = {
+        Container::VIC20 => "VIC-20 snapshots, not xvic's", Container::C128 => "C128 snapshots, not x128's",
+        Container::PLUS4 => "Plus/4 snapshots, not xplus4's"
+      }.freeze
 
       attr_reader :container
 
@@ -54,18 +62,37 @@ module Badline
       end
 
       # The snapshot with VICE's modules ahead of the BL-* ones for a C64,
-      # so x64sc opens it too. Raises FormatError for a Plus/4 or a PET,
-      # whose snapshots badline doesn't write for xplus4 or xpet.
+      # a PET, a CBM-II's B series or a P500, so x64sc, xpet, xcbm2 or
+      # xcbm5x0 opens it too. Raises FormatError for a Plus/4, whose
+      # snapshots badline doesn't write for xplus4.
       def self.exported(computer)
         raise FormatError, "badline doesn't export a Plus/4's snapshot for VICE" if computer.family == :plus4
-        raise FormatError, "badline doesn't export a PET's snapshot for VICE" if computer.family == :pet
 
-        computer.settle_for_snapshot!
+        computer.settle_for_vice!
         sections = computer.save_modules
-        sections = Vice.export(computer) + sections if computer.family == :c64
+        case computer.family
+        when :c64 then sections = Vice.export(computer) + sections
+        when :pet then sections = Vice::PET.export(computer, sections) + sections
+        when :cbm2 then sections = cbm2_export(computer, sections) + sections
+        end
         new(Container.new(sections, machine: machine_name(computer)))
       end
 
+      # xcbm2's or xcbm5x0's modules for a CBM-II.
+      def self.cbm2_export(computer, sections)
+        computer.is_a?(CBM2::P500) ? Vice::P500.export(computer, sections) : Vice::CBM2.export(computer, sections)
+      end
+
+      # The VICE emulator a machine's VICE modules are for.
+      def self.vice_emulator(computer)
+        case machine_name(computer)
+        when Container::PET then "xpet"
+        when Container::CBM2 then "xcbm2"
+        when Container::CBM2_5X0 then "xcbm5x0"
+        else "x64sc"
+        end
+      end
+
       # The machine as VICE's emulators name it.
       def self.machine_name(computer)
         case computer.family
@@ -73,6 +100,7 @@ module Badline
         when :c128 then Container::C128
         when :plus4 then Container::PLUS4
         when :pet then Container::PET
+        when :cbm2 then computer.is_a?(CBM2::P500) ? Container::CBM2_5X0 : Container::CBM2
         else Container::MACHINE
         end
       end
@@ -85,6 +113,7 @@ module Badline
         when "c128" then C128Setup.read_fields(machine)
         when "plus4" then Plus4Setup.read_fields(machine)
         when "pet" then PETSetup.read_fields(machine)
+        when "cbm2" then CBM2Setup.read_fields(machine)
         else C64Setup.read_fields(machine)
         end
       end
@@ -100,16 +129,16 @@ module Badline
 
       # A new machine, built as the snapshot's was and restored from it. A
       # badline snapshot restores from its BL-* modules alone, and a VICE
-      # one through the modules badline reads. xvic's, x128's, xplus4's and
-      # xpet's own modules aren't read. Yields a line for each thing left
-      # out, or warns it without a block. `detached` restores it without
-      # the host's files (Keyed::Modules).
+      # one through the modules badline reads, x64sc's, xpet's, xcbm2's or xcbm5x0's. xvic's,
+      # x128's and xplus4's own modules aren't read. Yields a line for
+      # each thing left out, or warns it without a block. `detached`
+      # restores it without the host's files (Keyed::Modules).
       def load(detached: false, &)
         refuse_old_layout
-        raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" if vic20? && !badline?
-        raise FormatError, "badline reads only its own C128 snapshots, not x128's" if c128? && !badline?
-        raise FormatError, "badline reads only its own Plus/4 snapshots, not xplus4's" if plus4? && !badline?
-        raise FormatError, "badline reads only its own PET snapshots, not xpet's" if pet? && !badline?
+        refuse_unread
+        return load_xpet(&) if pet? && !badline?
+        return load_xcbm2(&) if cbm2? && !badline?
+        return load_xcbm5x0(&) if p500? && !badline?
         return load_vice(&) unless badline?
 
         modules = Keyed::Modules.new(sections, detached:)
@@ -130,12 +159,24 @@ module Badline
       # Whether the machine is a PET, as the container names it.
       def pet? = @container.machine == Container::PET
 
+      # Whether the machine is a CBM-II's B series, as the container names
+      # it.
+      def cbm2? = @container.machine == Container::CBM2
+
+      # Whether the machine is a P500, as the container names it.
+      def p500? = @container.machine == Container::CBM2_5X0
+
       # Restores `computer` from the snapshot, and returns the Report. The
       # snapshot goes into a new machine first, so one that fails, or is of
       # a machine built another way, leaves `computer` as it was.
       def restore(computer, &)
         refuse_old_layout
-        report = badline? ? restore_modules(computer) : Vice::Restore.import(@container, computer)
+        report = if badline? then restore_modules(computer)
+                 elsif pet? then Vice::PET::Restore.import(@container, computer)
+                 elsif cbm2? then Vice::CBM2::Restore.import(@container, computer)
+                 elsif p500? then Vice::P500::Restore.import(@container, computer)
+                 else Vice::Restore.import(@container, computer)
+                 end
         tell(report, &)
         report
       end
@@ -148,6 +189,24 @@ module Badline
         computer
       end
 
+      def load_xpet(&)
+        computer = Vice::PET.setup(@container).build
+        tell(Vice::PET::Restore.apply(@container, computer), &)
+        computer
+      end
+
+      def load_xcbm2(&)
+        computer = Vice::CBM2.setup(@container).build
+        tell(Vice::CBM2::Restore.apply(@container, computer), &)
+        computer
+      end
+
+      def load_xcbm5x0(&)
+        computer = Vice::P500.setup(@container).build
+        tell(Vice::P500::Restore.apply(@container, computer), &)
+        computer
+      end
+
       # The snapshot goes into a new machine first, so one that fails
       # leaves `computer` as it was.
       def restore_modules(computer)
@@ -164,6 +223,11 @@ module Badline
         report(modules, computer)
       end
 
+      def refuse_unread
+        unread = UNREAD[@container.machine]
+        raise FormatError, "badline reads only its own #{unread}" if unread && !badline?
+      end
+
       # A snapshot from a badline before the keyed modules, which only the
       # version that saved it reads.
       def refuse_old_layout

data/lib/badline/snapshot/pet_setup.rb

@@ -4,9 +4,10 @@ module Badline
   module Snapshot
     # How a PET was built: its model's name, one of PET::Model::ALL, its
     # RAM below $8000 in K and its editor's frame rate, the arguments
-    # PET.new takes, and the ROMs it runs by file: BASIC, the editor, the
-    # KERNAL and the characters.
-    PETSetup = Data.define(:model, :ram_kb, :refresh_hz, :basic, :editor, :kernal, :characters)
+    # PET.new takes, the ROMs it runs by file: BASIC, the editor, the
+    # KERNAL and the characters, and the 8296 board's jumpers, by name and
+    # comma-separated.
+    PETSetup = Data.define(:model, :ram_kb, :refresh_hz, :basic, :editor, :kernal, :characters, :jumpers)
 
     class PETSetup
       MODELS = PET::Model::ALL.map(&:name).freeze
@@ -18,22 +19,25 @@ module Badline
         model = machine.model
         refresh_hz = machine.refresh_hz
         new(model: model.name, ram_kb: machine.ram.length >> 10, refresh_hz:, basic: model.basic,
-            editor: model.editor(refresh_hz), kernal: model.kernal, characters: model.characters)
+            editor: model.editor(refresh_hz), kernal: model.kernal, characters: model.characters,
+            jumpers: machine.jumpers.join(","))
       end
 
-      # The model by name, the RAM, the frame rate and the ROMs, in a keyed
-      # snapshot module.
+      # The model by name, the RAM, the frame rate, the ROMs and the
+      # jumpers where a board has any, in a keyed snapshot module.
       def write_fields(out)
         out.text("model", model).int("ram_kb", ram_kb).int("refresh_hz", refresh_hz)
         out.text("rom.basic", basic).text("rom.editor", editor).text("rom.kernal", kernal)
         out.text("rom.characters", characters)
+        out.text("jumpers", jumpers) unless jumpers.empty?
       end
 
-      # A ROM the snapshot doesn't name is the model's own.
+      # A ROM the snapshot doesn't name is the model's own, and a board
+      # without jumpers named has none fitted.
       def self.read_fields(input)
         profile = PET::Model.named(input.choice("model", MODELS, PET::Model::DEFAULT))
         ram_kb = input.int("ram_kb", profile.ram_kb)
-        unless PET::Model::RAM_SIZES.include?(ram_kb)
+        unless PET::Model.ram_fits?(profile, ram_kb)
           raise FormatError, "the snapshot is of a PET with #{ram_kb}K of RAM, which badline doesn't build"
         end
 
@@ -46,26 +50,39 @@ module Badline
         new(model: profile.name, ram_kb:, refresh_hz:, basic: input.text("rom.basic", profile.basic),
             editor: input.text("rom.editor", profile.editor(refresh_hz)),
             kernal: input.text("rom.kernal", profile.kernal),
-            characters: input.text("rom.characters", profile.characters))
+            characters: input.text("rom.characters", profile.characters), jumpers: input.text("jumpers", ""))
       end
 
-      # A machine built this way, at power-on, with the BASIC and editor
-      # PET::ROMSets names for its ROMs.
+      # A machine built this way, at power-on, with the BASIC, editor and
+      # character ROMs PET::ROMSets names for its ROMs.
       def build
         version = PET::ROMSets::BASICS.find { |_, roms| roms.first == basic }&.first
-        PET.new(model:, ram_kb:, refresh_hz:, basic: version, editor: PET::ROMSets::EDITORS.key(editor))
+        PET.new(model:, ram_kb:, refresh_hz:, basic: version, editor: PET::ROMSets::EDITORS.key(editor),
+                characters: fitted_characters, jumpers: jumpers.split(","))
       rescue ArgumentError => e
         raise FormatError, "the snapshot is of a #{self}, which badline doesn't build: #{e.message}"
       end
 
-      # The ROMs are named where they aren't the model's own.
+      # The ROMs are named where they aren't the model's own, and the
+      # jumpers where any are fitted.
       def to_s
         text = "#{model} with #{ram_kb}K at #{refresh_hz} Hz"
+        text = "#{text} jumpered #{jumpers}" unless jumpers.empty?
         roms = [basic, editor, kernal, characters]
         profile = PET::Model.named(model)
         stock = [profile.basic, profile.editor(refresh_hz), profile.kernal, profile.characters]
         roms == stock ? text : "#{text} running #{roms.join(', ')}"
       end
+
+      private
+
+      # The name of a character ROM other than the model's own, nil for its
+      # own.
+      def fitted_characters
+        return nil if characters == PET::Model.named(model).characters
+
+        PET::ROMSets::CHARACTERS.key(characters) || characters
+      end
     end
   end
 end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "badline/snapshot/vice/cbm2_mem"
+require "badline/snapshot/vice/cbm2_tpi"
+require "badline/snapshot/vice/cbm2_acia"
+require "badline/snapshot/vice/cbm2_crtc"
+require "badline/snapshot/vice/cbm2_mains"
+require "badline/snapshot/vice/cbm2_restore"
+
+module Badline
+  module Snapshot
+    module Vice
+      # xcbm2's modules for the CBM-II's B series: the CPU, the RAM, the
+      # CRTC, the CIA, both TPIs, the ACIA and the SID, written from
+      # badline's machine and read into it. Each module's file says what
+      # maps and what is approximated. The CPU's, the CIA's and the SID's
+      # are the PET's and the C64's. They go through the machine's own
+      # keyed fields (Keyed), which a save writes and a load reads, but for
+      # the CIA and the SID, which go through the chips as the C64's do.
+      module CBM2
+        # The models badline builds by the RAM board's size in K and
+        # whether the model line is a 700's.
+        MODELS = { [128, false] => "610", [256, false] => "620", [128, true] => "710", [256, true] => "720" }.freeze
+        # The modules xcbm2 resets the machine without, each as xcbm2 leaves
+        # them with nothing attached: no cartridge, no file system drive
+        # open, the cassette port on with a datasette in it, and nothing in
+        # the user port.
+        PERIPHERALS = [["CBM2CART", 0, 1, [0x00]], ["FSDRIVE", 0, 0, Array.new(258, 0)],
+                       ["TAPEPORT", 1, 0, [0x01, 0x01]], ["USERPORT", 1, 0, [0x01, 0x00]]].freeze
+
+        module_function
+
+        # The modules xcbm2 3.10 reads, in its order, describing `machine`,
+        # which Machine::Settling has brought between instructions, from
+        # its keyed modules, `sections`.
+        def export(machine, sections)
+          readers = {}
+          sections.each { |section| readers[section.name] = Keyed::Reader.parse(section) }
+          machine.sid.catch_up!
+          cart, *rest = PERIPHERALS.map do |name, major, minor, bytes|
+            FieldWriter.new.bytes(bytes).section(name, major, minor)
+          end
+          [PET::MainCPU.write(machine, machine.tpi1.irq? ? 1 : 0), CBM2Mem.export(machine), cart,
+           CRTC.export(machine, reader(readers, "BL-CRTC"), reader(readers, "BL-VIDEO")),
+           CIAs.section(machine.cia, "CIA1"),
+           *TPI::NAMES.map { |name| TPI.export(name, reader(readers, "BL-#{name}")) },
+           ACIA.export(reader(readers, "BL-ACIA"), machine.cycles),
+           SIDRegisters.export(machine), SIDExtended.export(machine), *drives(machine, readers), *rest]
+        end
+
+        # The true drive's modules, as xpet's (PET::Drive2031,
+        # PET::Drive8050), or with no true drive, DRIVE8 to DRIVE11 as
+        # xcbm2 and xcbm5x0 save no drive.
+        def drives(machine, readers)
+          return no_drives unless machine.true_drive
+
+          PET::Drive2031.export(machine, readers) + PET::Drive8050.export(machine, readers)
+        end
+
+        def no_drives = PET::Drive2031::UNITS.map { |name| PET::Drive2031.unit(PET::Drive2031::NONE, name) }
+
+        def reader(readers, name) = readers[name] || Keyed::Reader.missing(name)
+
+        # How the machine xcbm2 saved was built: the model from the RAM
+        # board's size and the model line, and the mains from the model
+        # line too, 60 Hz on a 600 whose line says so and 50 Hz otherwise:
+        # xcbm2 has no 700 at 60 Hz. xcbm2 doesn't save its ROMs, so the
+        # KERNAL is 901244-04a, xcbm2's own.
+        def setup(container)
+          memory = memory(container)
+          ram_kb = CBM2Mem.ram_kb(memory)
+          line = CBM2Mem.line(memory)
+          unless CBM2Mem.mapped(memory).zero?
+            raise FormatError, "#{memory}: RAM in segment 15 beyond the B series', which badline doesn't build"
+          end
+
+          model = MODELS[[ram_kb, line == CBM2Mem::M700]]
+          raise FormatError, "#{memory}: a CBM-II with #{ram_kb}K of RAM, which badline doesn't build" if model.nil?
+
+          CBM2Setup.new(model:, kernal: "04a", mains_hz: line == CBM2Mem::M600_60HZ ? 60 : 50, refresh: true)
+        end
+
+        def memory(container)
+          section = container[CBM2Mem::NAME]
+          raise FormatError, "the snapshot has no #{CBM2Mem::NAME} module" if section.nil?
+          raise FormatError, "#{section}: badline doesn't read this version" unless CBM2Mem.reads?(section)
+
+          section
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # Acia1 1.1, the 6551: the transmitter's and the receiver's data
+        # registers, the status, the command and control registers, the
+        # transmitter's state (0 idle, 2 a byte waiting), then four clocks:
+        # the cycles to the transmitter's next character end, a clock
+        # xcbm2 leaves 0, the cycles to its next receiver poll and another
+        # 0.
+        #
+        # Written: the registers, the status as a read finds it, and while
+        # the transmitter is on, the cycles to its character's end in both
+        # clocks. Read: the registers, the receiver full, the transmitter
+        # empty, the interrupt and the errors from the status, and the
+        # transmitter's character end from its clock, or one a character's
+        # time on when the clock has run out. Nothing is plugged
+        # in, in either, and a character being shifted out is lost.
+        module ACIA
+          NAME = "Acia1"
+          MAJOR = 1
+          MINOR = 1
+          WAITING = 2
+          ERRORS = 0x07
+          RECEIVER_FULL = 0x08
+          TRANSMITTER_EMPTY = 0x10
+          IRQ = 0x80
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The module from the ACIA's BL-ACIA fields in `input`, for a
+          # machine at `cycles`.
+          def export(input, cycles)
+            empty = input.bool("transmitter_empty", true)
+            status = input.int("errors", 0) | Chips::ACIA::DCD | Chips::ACIA::DSR
+            status |= RECEIVER_FULL if input.bool("receiver_full", false)
+            status |= TRANSMITTER_EMPTY if empty
+            status |= IRQ if input.bool("irq", false)
+            at = input.int("transmit_at", Chips::ACIA::NEVER)
+            due = at == Chips::ACIA::NEVER ? 0 : [at - cycles, 0].max
+            FieldWriter.new.byte(input.int("transmit_data", 0)).byte(input.int("receive_data", 0)).byte(status)
+                       .byte(input.int("command", 0)).byte(input.int("control", 0)).byte(empty ? 0 : WAITING)
+                       .dword(due).dword(0).dword(due).dword(0).section(NAME, MAJOR, MINOR)
+          end
+
+          # The ACIA by its BL-ACIA keys, in a keyed module's writer, for a
+          # machine at `cycles`.
+          def import(section, out, cycles)
+            fields = FieldReader.new(section)
+            transmit, receive, status, command, control = fields.bytes(5)
+            fields.skip(1)
+            due = fields.dword
+            out.int("command", command).int("control", control).int("errors", status & ERRORS)
+            out.bool("receiver_full", status.anybits?(RECEIVER_FULL))
+            out.bool("transmitter_empty", status.anybits?(TRANSMITTER_EMPTY)).bool("irq", status.anybits?(IRQ))
+            out.int("receive_data", receive).int("transmit_data", transmit).int("shifting", Chips::ACIA::IDLE)
+            out.int("transmit_remainder", 0)
+            return out.int("transmit_at", Chips::ACIA::NEVER) unless transmitting?(command)
+
+            out.optional_int("transmit_at", due.positive? ? cycles + due : nil)
+          end
+
+          def transmitting?(command)
+            control = command & 0x0c
+            control != 0 && control != 0x0c
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # CRTC 1.2 as xcbm2 saves it, laid out as xpet's (PET::CRTC): the
+        # board's screen settings, the registers, the one selected, the
+        # beam, the picture's size and the frame's lines, then xcbm2's
+        # picture. xcbm2's board has the 6845's cursor and reads one byte a
+        # character from 2K of screen RAM. After the beam's line come the
+        # fields left in the cursor's blink phase, counted down from 32, and
+        # whether the cursor shows: xcbm2 blinks it 32 fields on and 32 off,
+        # where badline's 6845 blinks it 16 and 16, or 8 and 8.
+        #
+        # xcbm2 ticks the mains once a frame, as vertical sync ends, so its
+        # mains follows the CRTC (Mains).
+        #
+        # Written: the registers and the beam as badline's CRTC has them,
+        # and the cursor shown as badline's is, its phase scaled to xcbm2's.
+        # The picture is left blank, as xcbm2 paints it again. Read: the
+        # registers and the beam as xpet's are (PET::CRTC), the cursor shown
+        # as xcbm2's is, its phase scaled to badline's, and where the
+        # picture is in its frame. The picture starts again with the next
+        # frame.
+        module CRTC
+          NAME = PET::CRTC::NAME
+          SETTINGS = [0xff, 0x07, 0x00, 0x10, 0x00, 0x20, 0x00, 0xe0, 0xff, 0x3f].freeze
+          # The 6845's cursor, one byte a character, and not a 2001.
+          BOARD = [0x01, 0x01, 0x00].freeze
+          WIDTH = 704
+          # The picture's lines and the line its first row starts on, for a
+          # 600 and a 700.
+          FRAMES = { false => [266, 33], true => [366, 8] }.freeze
+          BLINK = 32
+          # Where R10 is in the module, and the blink's fields left.
+          R10_AT = PET::CRTC::SETTINGS.length + 5 + 10
+          BLINK_AT = PET::CRTC::SELECTED + 4
+          # R10's blink of 8 fields on and 8 off.
+          FAST_BLINK = 0x40
+
+          module_function
+
+          def reads?(section) = PET::CRTC.reads?(section)
+
+          def fresh_crtc(machine) = CBM2Setup.of(machine).build.crtc
+
+          # The module from the BL-CRTC and BL-VIDEO fields in `crtc_input`
+          # and `video_input`.
+          def export(machine, crtc_input, video_input)
+            registers = PET::CRTC.crtc_registers(crtc_input)
+            beam = beam(machine, crtc_input, registers)
+            height, top = FRAMES.fetch(machine.model.high_profile)
+            fields = FieldWriter.new.bytes(SETTINGS).word(0).bytes(BOARD).bytes(registers)
+            fields.byte(crtc_input.int("selected", 0)).byte(beam.column).byte(beam.row).byte(beam.raster)
+            fields.bytes(blink(video_input.int("frames", 0), registers[10])).byte(1)
+            fields.word(0).word(beam.start & PET::CRTC::SCREEN_BITS).byte(beam.vsync).byte(0).flag(beam.shown)
+            fields.word(WIDTH).word(height).byte(PET::CRTC::AFTER_SIZE).zeros(3).byte(top).byte(0)
+            fields.word(PET::CRTC.frame_lines(registers)).word(beam.frame_line).byte(1)
+            fields.dword(0).dword(WIDTH).dword(height).dword(WIDTH).zeros(WIDTH * (height + 4))
+            fields.section(NAME, PET::CRTC::MAJOR, PET::CRTC::MINOR)
+          end
+
+          # The beam where xcbm2's is with badline's CRTC where `input` has
+          # it (PET::CRTC::CRTC_LEAD). On a line's last character xcbm2's
+          # beam has moved on to the next line, a cycle before it starts.
+          def beam(machine, input, registers)
+            cycles = -PET::CRTC::CRTC_LEAD % PET::CRTC.frame_cycles(registers)
+            beam = PET::CRTC.crtc_beam(PET::CRTC.run_on(fresh_crtc(machine), input, cycles), registers)
+            return beam unless beam.column == registers[0]
+
+            PET::CRTC.crtc_beam(PET::CRTC.run_on(fresh_crtc(machine), input, cycles + 1), registers).with(column: 0xff)
+          end
+
+          # The fields left in xcbm2's blink phase and whether its cursor
+          # shows, for badline's fields counted, `frames`, and R10.
+          def blink(frames, r10)
+            fast = r10 & 0x60 == FAST_BLINK
+            shown = frames.nobits?(fast ? 0x08 : 0x10)
+            phase = fast ? (frames & 0x07) << 1 : frames & 0x0f
+            [BLINK - (phase << 1), shown ? 1 : 0]
+          end
+
+          # badline's fields counted for xcbm2's blink in `section`.
+          def frames(section)
+            r10 = FieldReader.new(section).skip(R10_AT).byte
+            left, shown = FieldReader.new(section).skip(BLINK_AT).bytes(2)
+            phase = ((BLINK - [left, BLINK].min) >> 1) & 0x0f
+            return (shown.zero? ? 0x08 : 0) | (phase >> 1) if r10 & 0x60 == FAST_BLINK
+
+            (shown.zero? ? 0x10 : 0) | phase
+          end
+
+          # The BL-CRTC module, run on from xcbm2's beam as xpet's is.
+          def import(section, machine)
+            counters = Keyed.section("BL-CRTC") { |out| PET::CRTC.import(section, out, 1, 0) }
+            frame = PET::CRTC.frame_cycles(PET::CRTC.registers(section))
+            cycles = (PET::CRTC::CRTC_LEAD + PET::CRTC.column_of(section)) % frame
+            fields = PET::CRTC.run_on(fresh_crtc(machine), Keyed::Reader.parse(counters), cycles)
+            Keyed.section("BL-CRTC") { |out| PET::CRTC.copy(fields, out) }
+          end
+
+          # The BL-VIDEO module for a CRTC whose BL-CRTC fields `crtc` holds:
+          # the cursor's blink, the line the frame paints next and the frame's
+          # layout. The picture stays as the machine has it.
+          def video(section, crtc)
+            registers = PET::CRTC.crtc_registers(crtc)
+            Keyed.section("BL-VIDEO") do |out|
+              out.int("frames", frames(section)).int("line", painted(crtc, registers)).bool("line_shown", false)
+              out.int("origin", Badline::CBM2::CRTCVideo::LEFT - ((registers[0] + 1 - registers[2]) << 3))
+              out.ints("layout", registers.values_at(0, 1, 2, 4, 5, 6, 9, 12, 13))
+            end
+          end
+
+          # The lines the frame has displayed so far.
+          def painted(crtc, registers)
+            lines = registers[9] + 1
+            shown = registers[6] * lines
+            return shown if crtc.bool("adjusting", false) || !crtc.bool("row_display", true)
+
+            [(crtc.int("row", 0) * lines) + crtc.int("line", 0), shown].min
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # The mains on TPI1's I0. xcbm2 saves no mains: it ticks it once a
+        # frame of its CRTC, as vertical sync ends, whatever the mains is
+        # set to. A machine read from its snapshot has its mains' next
+        # falling edge where xcbm2's tick would come, and runs it at its own
+        # 50 or 60 Hz from there. A snapshot written for xcbm2 ticks where
+        # its CRTC says.
+        module Mains
+          # The cycle of the line where vertical sync ends that the tick
+          # latches on, counted as badline's CRTC counts columns.
+          TICK_COLUMN = 0
+
+          module_function
+
+          # The cycles to the mains' next falling edge for a CRTC whose
+          # BL-CRTC fields `crtc` holds.
+          def next_tick(crtc)
+            registers = crtc.bytes("registers", "".b).bytes
+            regs = Array.new(Chips::CRTC::MASKS.length) { |index| registers[index] || 0 }
+            line_cycles = regs[0] + 1
+            lines = regs[9] + 1
+            rows = regs[4] + 1
+            frame_lines = (rows * lines) + regs[5]
+            line = crtc.int("line", 0)
+            line += crtc.bool("adjusting", false) ? rows * lines : crtc.int("row", 0) * lines
+            tick_line = ((regs[7] * lines) + Chips::CRTC::VSYNC_LINES) % frame_lines
+            frame = line_cycles * frame_lines
+            cycles = ((tick_line * line_cycles) + TICK_COLUMN - ((line * line_cycles) + crtc.int("column", 0))) % frame
+            cycles.zero? ? frame : cycles
+          end
+
+          # The BL-MACHINE mains fields for a mains `half_period` cycles high
+          # and as long low, whose next falling edge is `cycles` away.
+          def write(out, cycles, half_period)
+            high = cycles <= half_period
+            countdown = high ? cycles : [cycles - half_period, half_period].min
+            out.int("mains_countdown", countdown).bool("mains_high", high)
+            high
+          end
+        end
+      end
+    end
+  end
+end