badline 0.16.1 → 0.18.0

data/lib/badline/snapshot/kim1_setup.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a KIM-1 was built: its RAM, one of KIM1::Bus::RAM_CONFIGURATIONS
+    # by name, the argument KIM1.new takes. The ROMs are the board's own.
+    KIM1Setup = Data.define(:ram)
+
+    class KIM1Setup
+      RAM = KIM1::Bus::RAM_CONFIGURATIONS.map(&:to_s).freeze
+
+      # The setup of `machine`.
+      def self.of(machine) = new(ram: machine.bus.ram_configuration.to_s)
+
+      # The RAM by name, in a keyed snapshot module.
+      def write_fields(out)
+        out.text("ram", ram)
+      end
+
+      def self.read_fields(input) = new(ram: input.choice("ram", RAM, "1k"))
+
+      # A machine built this way, at power-on.
+      def build = KIM1.new(ram: ram.to_sym)
+
+      def to_s = "KIM-1 with #{ram == 'expanded' ? 'expanded' : ram.upcase} RAM"
+    end
+  end
+end

data/lib/badline/snapshot/pet_setup.rb

@@ -5,9 +5,11 @@ module Badline
     # 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, 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)
+    # KERNAL and the characters, the 8296 board's jumpers, by name and
+    # comma-separated, and the SuperPET's CPU and RAM switches, as
+    # PET::SuperPET::Board names their positions, empty on the others.
+    PETSetup = Data.define(:model, :ram_kb, :refresh_hz, :basic, :editor, :kernal, :characters, :jumpers,
+                           :cpu_switch, :ram_switch)
 
     class PETSetup
       MODELS = PET::Model::ALL.map(&:name).freeze
@@ -20,20 +22,24 @@ module Badline
         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,
-            jumpers: machine.jumpers.join(","))
+            jumpers: machine.jumpers.join(","), cpu_switch: machine.superpet? ? machine.board.cpu_switch : "",
+            ram_switch: machine.superpet? ? machine.board.ram_switch : "")
       end
 
-      # The model by name, the RAM, the frame rate, the ROMs and the
-      # jumpers where a board has any, in a keyed snapshot module.
+      # The model by name, the RAM, the frame rate, the ROMs, the jumpers
+      # where a board has any and the switches where it has them, 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?
+        out.text("cpu_switch", cpu_switch).text("ram_switch", ram_switch) unless cpu_switch.empty?
       end
 
-      # A ROM the snapshot doesn't name is the model's own, and a board
-      # without jumpers named has none fitted.
+      # A ROM the snapshot doesn't name is the model's own, a board without
+      # jumpers named has none fitted, and a SuperPET without its switches
+      # named has them at 6502 and R/W.
       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)
@@ -47,18 +53,27 @@ module Badline
         end
 
         refresh_hz = 60 unless profile.crtc?
+        superpet = profile.superpet?
         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), jumpers: input.text("jumpers", ""))
+            characters: input.text("rom.characters", profile.characters), jumpers: input.text("jumpers", ""),
+            cpu_switch: superpet ? input.choice("cpu_switch", PET::SuperPET::Board::CPU_SWITCH, "6502") : "",
+            ram_switch: superpet ? input.choice("ram_switch", PET::SuperPET::Board::RAM_SWITCH, "rw") : "")
       end
 
       # 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),
-                characters: fitted_characters, jumpers: jumpers.split(","))
+        editor_name = PET::ROMSets::EDITORS.key(editor)
+        unless cpu_switch.empty?
+          return PET::SuperPET.new(refresh_hz:, basic: version, editor: editor_name, cpu: cpu_switch,
+                                   bank_ram: ram_switch)
+        end
+
+        PET.new(model:, ram_kb:, refresh_hz:, basic: version, editor: editor_name, 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
@@ -68,6 +83,7 @@ module Badline
       def to_s
         text = "#{model} with #{ram_kb}K at #{refresh_hz} Hz"
         text = "#{text} jumpered #{jumpers}" unless jumpers.empty?
+        text = "#{text} with its CPU switch at #{cpu_switch} and RAM switch at #{ram_switch}" unless cpu_switch.empty?
         roms = [basic, editor, kernal, characters]
         profile = PET::Model.named(model)
         stock = [profile.basic, profile.editor(refresh_hz), profile.kernal, profile.characters]

data/lib/badline/snapshot/storage_setup.rb

@@ -13,6 +13,7 @@ module Badline
       T64_ARCHIVE = 4
       D80 = 5
       D82 = 6
+      D67 = 7
 
       module_function
 
@@ -22,6 +23,7 @@ module Badline
         return D81 if image.is_a?(Storage::D81Image)
         return D82 if image.is_a?(Storage::D82Image)
         return D80 if image.is_a?(Storage::D80Image)
+        return D67 if image.is_a?(Storage::D67Image)
 
         raise ArgumentError, "#{image.class} can't go in a snapshot"
       end
@@ -41,7 +43,7 @@ module Badline
         end
       end
 
-      KIND_NAMES = %w[directory d64 d71 d81 t64 d80 d82].freeze
+      KIND_NAMES = %w[directory d64 d71 d81 t64 d80 d82 d67].freeze
 
       # Opens the storage write_fields wrote: the same directory by its
       # path, an archive with the bytes it held, or a disk image with the
@@ -61,6 +63,7 @@ module Badline
         when D71 then Storage::D71Image.new(path, read_only:, bytes:)
         when D80 then Storage::D80Image.new(path, read_only:, bytes:)
         when D82 then Storage::D82Image.new(path, read_only:, bytes:)
+        when D67 then Storage::D67Image.new(path, read_only:, bytes:)
         else Storage::D81Image.new(path, read_only:, bytes:)
         end
       end

data/lib/badline/snapshot/vic20_setup.rb

@@ -3,26 +3,30 @@
 module Badline
   module Snapshot
     # How a VIC-20 was built: its RAM expansion, a key of
-    # Vic20::Bus::RAM_CONFIGURATIONS, the argument Vic20.new takes.
-    Vic20Setup = Data.define(:ram)
+    # Vic20::Bus::RAM_CONFIGURATIONS, and its model, one of Vic20::MODELS,
+    # the arguments Vic20.new takes.
+    Vic20Setup = Data.define(:ram, :model)
 
     class Vic20Setup
       RAM_CONFIGURATIONS = Vic20::Bus::RAM_CONFIGURATIONS.keys.freeze
 
-      # The RAM expansion by name, in a keyed snapshot module.
+      # The RAM expansion and the model by name, in a keyed snapshot module.
+      # A snapshot without a model is of a PAL machine, the only one badline
+      # built before the NTSC one.
       def write_fields(out)
-        out.text("ram", ram.to_s)
+        out.text("ram", ram.to_s).text("model", model)
       end
 
       def self.read_fields(input)
         text = input.choice("ram", RAM_CONFIGURATIONS.map(&:to_s), "unexpanded")
-        new(ram: RAM_CONFIGURATIONS.find { |name| name.to_s == text } || :unexpanded)
+        new(ram: RAM_CONFIGURATIONS.find { |name| name.to_s == text } || :unexpanded,
+            model: input.choice("model", Vic20::MODELS, "pal"))
       end
 
       # A machine built this way, at power-on.
-      def build = Vic20.new(ram:)
+      def build = Vic20.new(ram:, model:)
 
-      def to_s = ram.to_s
+      def to_s = model == "pal" ? ram.to_s : "#{ram} #{model}"
     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

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # CBM2MEM 1.0: the RAM board's size in units of 128K, the RAM xcbm2
+        # maps into segment 15 beyond the B series' own (none on a B series
+        # as built, $40 on a P500), its model line (0 a 700, 1 a 600 at
+        # 60 Hz, 2 a 600 at 50 Hz), the execution and indirection segment
+        # registers, then segment 15's 2K of RAM, the 2K of screen RAM, and
+        # the board's segments from segment 1 up.
+        #
+        # xcbm2 keeps the segment registers in segment 15's bytes $0000 and
+        # $0001 too, and they are written there. Under the registers
+        # badline's RAM is never written, so those two bytes read as 0.
+        # xcbm2's ROMs aren't in the snapshot.
+        module CBM2Mem
+          NAME = "CBM2MEM"
+          MAJOR = 1
+          MINOR = 0
+          SEGMENT = 0x10000
+          SYSTEM_RAM = 0x800
+          SCREEN_RAM = 0x800
+          HEADER = 5
+          # The model lines.
+          M700 = 0
+          M600_60HZ = 1
+          M600_50HZ = 2
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          def model_line(machine)
+            return M700 if machine.model.high_profile
+
+            machine.mains_hz == 60 ? M600_60HZ : M600_50HZ
+          end
+
+          def export(machine)
+            bus = machine.bus
+            system = bus.ram.snapshot
+            system[0] = bus.execution_segment
+            system[1] = bus.indirect_segment
+            fields = FieldWriter.new.byte(machine.model.ram_segments.length / 2).byte(0).byte(model_line(machine))
+            fields.byte(bus.execution_segment).byte(bus.indirect_segment)
+            fields.bytes(system).bytes(bus.screen.snapshot)
+            machine.model.ram_segments.each { |segment| fields.bytes(bus.segment_ram[segment].snapshot) }
+            fields.section(NAME, MAJOR, MINOR)
+          end
+
+          # The RAM in K, the RAM mapped into segment 15 and the model line.
+          def ram_kb(section) = FieldReader.new(section).byte * 128
+
+          def mapped(section) = FieldReader.new(section).skip(1).byte
+
+          def line(section) = FieldReader.new(section).skip(2).byte
+
+          # The RAM and the segment registers by their BL-RAM keys, in a
+          # keyed module's writer, for a machine whose board fills
+          # `segments`.
+          def import(section, out, segments)
+            fields = FieldReader.new(section).skip(3)
+            out.int("execution_segment", fields.byte & 0x0f).int("indirect_segment", fields.byte & 0x0f)
+            system = fields.string(SYSTEM_RAM)
+            out.bytes("system", "\0\0".b + system.byteslice(2, SYSTEM_RAM - 2))
+            out.bytes("screen", fields.string(SCREEN_RAM))
+            segments.each { |segment| out.bytes("segment#{segment}", fields.string(SEGMENT)) }
+          end
+        end
+      end
+    end
+  end
+end