badline 0.16.1 → 0.17.0

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

@@ -8,7 +8,9 @@ module 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.
+        # 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
@@ -16,6 +18,8 @@ module Badline
           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
 
@@ -33,9 +37,13 @@ module Badline
             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
 
@@ -57,9 +65,65 @@ module Badline
                 ignored << "#{section}: badline doesn't read this version, left out"
               end
             end
-            computer.save_modules.each { |section| sections << section if KEPT.include?(section.name) }
+            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))
+            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)
@@ -135,12 +199,12 @@ module Badline
               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(computer, Keyed::Reader.parse(counters), cycles)
+            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)
-            container.sections.reject { |section| READ.include?(section.name) }
+          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

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

@@ -44,8 +44,8 @@ module Badline
 
           def reads?(section) = section.major == MAJOR && section.minor == MINOR
 
-          # The VIA's module, from its BL-VIA fields in `input`.
-          def export(input)
+          # 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))
@@ -58,7 +58,7 @@ module Badline
             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)
+            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
@@ -96,13 +96,14 @@ module Badline
           end
 
           # The shift register from its mode, data and the ticks into its
-          # byte (#ticks), with the last bit put out on CB2.
+          # 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", ticks.zero? || data.anybits?(0x01))
+            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.

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

@@ -14,6 +14,9 @@ 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) }

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # The DOS's N command. With an ID it formats the disk: every block of
+      # the tracks the BAM covers is cleared, and the header, the BAM and an
+      # empty directory are written. Without one it only clears the disk:
+      # the header takes the new name and keeps its ID and whatever else it
+      # held, the BAM marks every block free, and the directory's first
+      # block is emptied. Either way the header, the BAM's blocks and the
+      # first directory block stay in use. Each format says where these go.
+      module Formatting
+        # The disk's ID, as the header holds it.
+        def disk_id = sector_at(*header_block)[header_name + Catalog::HEADER_ID, 2]
+
+        # Formats the disk under the name, or with no ID clears it.
+        def format(name, id = nil)
+          update_image do
+            full = !id.nil?
+            put_sector(*header_block, []) if full
+            id = (id || disk_id).first(2)
+            write_header(name, id)
+            clear_blocks if full
+            headers = bam_headers(id)
+            headers.each { |track, sector, bytes| write_at(track, sector, 0, bytes) }
+            put_sector(directory_track, directory_sector, [0, 0xff])
+            bam_tracks.each { |track| free_track(track) }
+            [header_block, *headers.map { |track, sector, _| [track, sector] }, [directory_track, directory_sector]]
+              .each { |block| mark(*block, false) }
+          end
+        end
+
+        private
+
+        # Every block the BAM covers but the header.
+        def clear_blocks
+          bam_tracks.each do |track|
+            (0...sectors_in(track)).each do |sector|
+              put_sector(track, sector, []) unless [track, sector] == header_block
+            end
+          end
+        end
+
+        # The link to the next block, the format's letter, the name, the ID
+        # and the DOS type, each field after the name set off with shifted
+        # spaces.
+        def write_header(name, id)
+          write_at(*header_block, 0, [*header_link, dos_type.getbyte(1), 0])
+          write_at(*header_block, header_name,
+                   encode_name(name) + [NAME_PADDING, NAME_PADDING] + id + [NAME_PADDING] +
+                   dos_type.bytes + Array.new(header_tail, NAME_PADDING))
+        end
+
+        # A free track counts its sectors and sets a bit for each.
+        def free_track(track)
+          count = sectors_in(track)
+          bits = (1 << count) - 1
+          @bytes[count_offset(track)] = count
+          bitmap_size.times { |i| @bytes[bitmap_offset(track) + i] = (bits >> (8 * i)) & 0xff }
+        end
+
+        def write_at(track, sector, offset, bytes)
+          @bytes[sector_offset(track, sector) + offset, bytes.length] = bytes
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,39 @@ module Badline
           files.length
         end
 
+        # Gives a file a new name in its directory entry. A missing file
+        # fails as FILE NOT FOUND, and a new name already on the disk as
+        # FILE EXISTS.
+        def rename(old_name, new_name)
+          entry = existing_entry(old_name)
+          raise WriteError, WriteError::FILE_EXISTS if entry_named(new_name)
+
+          update_image { @bytes[entry[:offset] + 5, Directory::NAME_LENGTH] = encode_name(new_name) }
+        end
+
+        # Writes a new file holding the files named, one after another, as
+        # the type of the first. A missing file fails as FILE NOT FOUND, and
+        # a new name already on the disk as FILE EXISTS.
+        def copy(new_name, names)
+          sources = names.map { |name| existing_entry(name) }
+          raise WriteError, WriteError::FILE_EXISTS if entry_named(new_name)
+
+          bytes = sources.flat_map { |entry| read_chain(entry[:track], entry[:sector]) }
+          update_image { add_file(new_name, bytes, sources.first[:type]) }
+        end
+
+        # Adds the files named to the end of a SEQ file. A missing file fails
+        # as FILE NOT FOUND, and a file of another type as FILE TYPE
+        # MISMATCH.
+        def concat(name, names)
+          entry = existing_entry(name)
+          sources = names.map { |source| existing_entry(source) }
+          raise WriteError, WriteError::FILE_TYPE_MISMATCH unless entry[:type] == :seq
+
+          bytes = [entry, *sources].flat_map { |source| read_chain(source[:track], source[:sector]) }
+          update_image { rewrite(entry, bytes, :seq) }
+        end
+
         # Raw block access for the DOS `U2` command. A block that the error
         # table marks bad reads cleanly once written.
         def write_block(track, sector, data)
@@ -81,6 +114,8 @@ module Badline
 
         private
 
+        def existing_entry(name) = entry_named(name) || raise(WriteError, WriteError::FILE_NOT_FOUND)
+
         def update_image
           raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
 

data/lib/badline/storage/disk_image.rb

@@ -3,6 +3,7 @@
 require "badline/storage/disk_image/bam"
 require "badline/storage/disk_image/catalog"
 require "badline/storage/disk_image/directory"
+require "badline/storage/disk_image/formatting"
 require "badline/storage/disk_image/writing"
 
 module Badline
@@ -15,6 +16,7 @@ module Badline
       include Bam
       include Catalog
       include Directory
+      include Formatting
       include Writing
 
       SECTOR_SIZE = 256

data/lib/badline/storage.rb

@@ -24,6 +24,7 @@ module Badline
       WRITE_PROTECT_ON = 26
       FILE_NOT_FOUND = 62
       FILE_EXISTS = 63
+      FILE_TYPE_MISMATCH = 64
       DISK_FULL = 72
 
       attr_reader :code

data/lib/badline/support/cbm2_checkpoint.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a CBM-II: its CPU with both segment registers, the
+    # 2K of segment 15's RAM, the RAM board's segments, the screen RAM, the
+    # picture, the CRTC's registers and counters, the CIA, the ACIA's
+    # registers and both TPIs.
+    module CBM2Checkpoint
+      COMPONENTS = %w[cpu ram segments screen display crtc cia acia tpi1 tpi2].freeze
+
+      def self.take(machine)
+        bus = machine.bus
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu) +
+                                          [bus.execution_segment, bus.indirect_segment]),
+                         Checkpoint.fnv1a(Checkpoint.ram(bus.ram, 0x800)),
+                         Checkpoint.fnv1a(segments(bus)),
+                         Checkpoint.fnv1a(Array.new(0x800) { |offset| bus.screen.peek(0xd000 + offset) }),
+                         Checkpoint.fnv1a(machine.video.display),
+                         Checkpoint.fnv1a(crtc_state(machine.crtc)),
+                         Checkpoint.fnv1a(Checkpoint.cia_state(machine.cia)),
+                         Checkpoint.fnv1a(acia_state(machine.acia)),
+                         Checkpoint.fnv1a(tpi_state(machine.tpi1)),
+                         Checkpoint.fnv1a(tpi_state(machine.tpi2))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      # Every byte of the segments the RAM board fills, segment by segment.
+      def self.segments(bus)
+        bytes = []
+        bus.segment_ram.each { |memory| bytes.concat(Checkpoint.ram(memory, 0x10000)) if memory }
+        bytes
+      end
+
+      def self.crtc_state(crtc) = crtc.registers + [crtc.column, crtc.line, crtc.row]
+
+      def self.acia_state(acia) = [acia.command, acia.control, acia.status]
+
+      def self.tpi_state(tpi)
+        [tpi.port_a_output, tpi.port_b_output, tpi.port_c_output, tpi.latches, tpi.mask, tpi.control,
+         tpi.irq? ? 1 : 0, *tpi.stack]
+      end
+    end
+  end
+end

data/lib/badline/support/p500_checkpoint.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a P500: its CPU with both segment registers, the 2K
+    # of segment 15's RAM, segments 0 and 1, the static video matrix, the
+    # colour RAM's nibbles, the picture, the VIC's registers and beam, the
+    # SID's registers, the CIA, the ACIA's registers and both TPIs, the
+    # last three as CBM2Checkpoint digests them.
+    module P500Checkpoint
+      COMPONENTS = %w[cpu ram segments screen color_ram display vic sid cia acia tpi1 tpi2].freeze
+
+      def self.take(machine)
+        bus = machine.bus
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu) +
+                                          [bus.execution_segment, bus.indirect_segment]),
+                         Checkpoint.fnv1a(Checkpoint.ram(bus.ram, 0x800)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.segments(bus)),
+                         Checkpoint.fnv1a(Array.new(0x400) { |offset| bus.screen.peek(0xd000 + offset) }),
+                         Checkpoint.fnv1a(Checkpoint.color_ram(machine.color_ram, 0xd400)),
+                         Checkpoint.fnv1a(machine.vic.display),
+                         Checkpoint.fnv1a(Checkpoint.vic_state(machine.vic)),
+                         Checkpoint.fnv1a(Array.new(0x20) { |reg| machine.sid.register(reg) }),
+                         Checkpoint.fnv1a(Checkpoint.cia_state(machine.cia)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.acia_state(machine.acia)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.tpi_state(machine.tpi1)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.tpi_state(machine.tpi2))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+    end
+  end
+end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.16.1"
+  VERSION = "0.17.0"
 end

data/lib/badline.rb

@@ -3,6 +3,7 @@
 require "badline/core"
 require "badline/c128"
 require "badline/plus4"
+require "badline/cbm2"
 require "badline/options"
 require "badline/data_path"
 require "badline/snapshot"