badline 0.15.0 → 0.16.0

data/lib/badline/snapshot/pet_setup.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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)
+
+    class PETSetup
+      MODELS = PET::Model::ALL.map(&:name).freeze
+
+      REFRESH_RATES = [50, 60].freeze
+
+      # The setup of `machine`.
+      def self.of(machine)
+        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)
+      end
+
+      # The model by name, the RAM, the frame rate and the ROMs, 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)
+      end
+
+      # A ROM the snapshot doesn't name is the model's own.
+      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)
+          raise FormatError, "the snapshot is of a PET with #{ram_kb}K of RAM, which badline doesn't build"
+        end
+
+        refresh_hz = input.int("refresh_hz", profile.crtc? ? 50 : 60)
+        unless REFRESH_RATES.include?(refresh_hz)
+          raise FormatError, "the snapshot is of a PET at #{refresh_hz} Hz, which badline doesn't build"
+        end
+
+        refresh_hz = 60 unless profile.crtc?
+        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))
+      end
+
+      # A machine built this way, at power-on, with the BASIC and editor
+      # 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))
+      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.
+      def to_s
+        text = "#{model} with #{ram_kb}K at #{refresh_hz} Hz"
+        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
+    end
+  end
+end

data/lib/badline/snapshot/plus4_setup.rb

@@ -4,20 +4,33 @@ module Badline
   module Snapshot
     # How a 264 series machine was built: its model's name, one of
     # Plus4::Model::ALL, which also says whether the Plus/4's function ROMs
-    # are fitted, its RAM in K, and whether a 1551's TCBM interface is
-    # plugged in, the arguments Plus4.new takes.
-    Plus4Setup = Data.define(:model, :ram_kb, :tcbm)
+    # are fitted, its RAM in K, whether a 1551's TCBM interface is plugged
+    # in, the SID card's SID model, or nil without one, and its address,
+    # and the RAM expansion's kind, or nil without one, the arguments
+    # Plus4.new takes.
+    Plus4Setup = Data.define(:model, :ram_kb, :tcbm, :sid_card, :sid_card_address, :ram_expansion)
 
     class Plus4Setup
       MODELS = Plus4::Model::ALL.map(&:name).freeze
 
+      SID_CARDS = %w[none mos6581 mos8580].freeze
+
+      RAM_EXPANSIONS = ["none", *Plus4::RAMExpansion::KINDS.keys.map(&:to_s)].freeze
+
       # The setup of `machine`.
-      def self.of(machine) = new(model: machine.model.name, ram_kb: machine.ram_kb, tcbm: !machine.tias.empty?)
+      def self.of(machine)
+        card = machine.sid_card
+        new(model: machine.model.name, ram_kb: machine.ram_kb, tcbm: !machine.tias.empty?, sid_card: card&.model,
+            sid_card_address: card ? card.address : Plus4::SIDCard::ADDRESSES.first,
+            ram_expansion: machine.ram_expansion&.kind)
+      end
 
-      # The model by name, the RAM and the TCBM interface, in a keyed
-      # snapshot module.
+      # The model by name, the RAM, the TCBM interface, the SID card's
+      # model and address and the RAM expansion's kind, "none" without
+      # them, in a keyed snapshot module.
       def write_fields(out)
-        out.text("model", model).int("ram_kb", ram_kb).bool("tcbm", tcbm)
+        out.text("model", model).int("ram_kb", ram_kb).bool("tcbm", tcbm).text("sid_card", (sid_card || :none).to_s)
+        out.int("sid_card_address", sid_card_address).text("ram_expansion", (ram_expansion || :none).to_s)
       end
 
       def self.read_fields(input)
@@ -27,13 +40,42 @@ module Badline
           raise FormatError, "the snapshot is of a Plus/4 with #{ram_kb}K of RAM, which badline doesn't build"
         end
 
-        new(model:, ram_kb:, tcbm: input.bool("tcbm", false))
+        sid_card = named(input.choice("sid_card", SID_CARDS, "none"))
+        ram_expansion = named(input.choice("ram_expansion", RAM_EXPANSIONS, "none"))
+        new(model:, ram_kb:, tcbm: input.bool("tcbm", false), sid_card:, sid_card_address: sid_card_address(input),
+            ram_expansion:)
       end
 
+      # A choice's name as a Symbol, or nil for "none".
+      def self.named(name) = name == "none" ? nil : name.to_sym
+
+      def self.sid_card_address(input)
+        address = input.int("sid_card_address", Plus4::SIDCard::ADDRESSES.first)
+        return address if Plus4::SIDCard::ADDRESSES.include?(address)
+
+        raise FormatError, format("the snapshot is of a Plus/4 with a SID card at $%<address>04X, " \
+                                  "which badline doesn't build", address:)
+      end
+      private_class_method :named, :sid_card_address
+
       # A machine built this way, at power-on.
-      def build = Plus4.new(model:, ram: ram_kb, tcbm:)
+      def build = Plus4.new(model:, ram: ram_kb, tcbm:, sid_card:, sid_card_address:, ram_expansion:)
+
+      def to_s
+        parts = ["#{ram_kb}K"]
+        parts << "a TCBM interface" if tcbm
+        parts << sid_card_part if sid_card
+        parts << "a #{ram_expansion} RAM expansion" if ram_expansion
+        "#{model} with #{parts.join(' and ')}"
+      end
 
-      def to_s = "#{model} with #{ram_kb}K#{' and a TCBM interface' if tcbm}"
+      private
+
+      def sid_card_part
+        format("%<article>s %<model>s SID card at $%<address>04X", article: sid_card == :mos8580 ? "an" : "a",
+                                                                   model: sid_card.to_s.delete_prefix("mos"),
+                                                                   address: sid_card_address)
+      end
     end
   end
 end

data/lib/badline/snapshot/storage_setup.rb

@@ -11,6 +11,8 @@ module Badline
       D71 = 2
       D81 = 3
       T64_ARCHIVE = 4
+      D80 = 5
+      D82 = 6
 
       module_function
 
@@ -18,6 +20,8 @@ module Badline
         return D71 if image.is_a?(Storage::D71Image)
         return D64 if image.is_a?(Storage::D64Image)
         return D81 if image.is_a?(Storage::D81Image)
+        return D82 if image.is_a?(Storage::D82Image)
+        return D80 if image.is_a?(Storage::D80Image)
 
         raise ArgumentError, "#{image.class} can't go in a snapshot"
       end
@@ -37,7 +41,7 @@ module Badline
         end
       end
 
-      KIND_NAMES = %w[directory d64 d71 d81 t64].freeze
+      KIND_NAMES = %w[directory d64 d71 d81 t64 d80 d82].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
@@ -55,6 +59,8 @@ module Badline
         case kind
         when D64 then Storage::D64Image.new(path, read_only:, bytes:)
         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:)
         else Storage::D81Image.new(path, read_only:, bytes:)
         end
       end

data/lib/badline/snapshot.rb

@@ -35,9 +35,9 @@ module Badline
     # The machine's snapshot file. Saving first runs the machine on to the
     # 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 or a
-    # Plus/4's snapshot is in a container named as xvic, x128 or xplus4
-    # names its machine.
+    # 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.
     def dump(computer) = Image.of(computer).to_s
 
     def read(path) = Image.new(Container.parse(File.binread(path)), name: File.basename(path))
@@ -51,8 +51,8 @@ module Badline
     # snapshot that fails leaves the machine as it was.
     def restore(computer, path, &) = read(path).restore(computer, &)
 
-    # A machine's snapshots, as .vsf files and in memory. C64, Vic20, C128
-    # and Plus4 each include it.
+    # A machine's snapshots, as .vsf files and in memory. C64, Vic20, C128,
+    # Plus4 and PET each include it.
     module Files
       def save_snapshot(path) = Snapshot.save(self, path)
 
@@ -95,4 +95,8 @@ module Badline
   class Plus4
     include Snapshot::Files
   end
+
+  class PET
+    include Snapshot::Files
+  end
 end

data/lib/badline/storage/d80_image.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # An 8050 disk: 77 tracks on one side, in four speed zones.
+    class D80Image < DiskImage
+      ERROR_TABLES = { 535_331 => 2083 }.freeze
+
+      # The last track of each zone but the innermost, from the outermost
+      # in: tracks 1-39, 40-53 and 54-64, and the last zone from 65 on.
+      ZONE_LAST_TRACKS = [39, 53, 64].freeze
+
+      # The sectors a track holds in each zone, from the outermost in.
+      ZONE_SECTORS = [29, 27, 25, 23].freeze
+
+      # The tracks a side holds.
+      SIDE_TRACKS = 77
+
+      def sectors_in(track)
+        zone = ZONE_LAST_TRACKS.count { |last| track > last }
+        ZONE_SECTORS[zone]
+      end
+
+      private
+
+      def error_tables = ERROR_TABLES
+
+      # The header block holds the disk name at $06 and the ID at $18,
+      # after the link to the BAM's first block and the format, "C".
+      def header_name = 0x06
+      def directory_track = 39
+      def directory_sector = 1
+      def directory_interleave = 3
+      def interleave = 6
+
+      # 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.
+      def reserved_tracks = [39]
+
+      # The BAM takes blocks 0, 3, 6 and 9 of track 38 as it needs them,
+      # each covering 50 tracks with a free count and a four-byte bitmap
+      # each from offset 6.
+      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))]
+    end
+  end
+end

data/lib/badline/storage/d82_image.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # An 8250 disk: an 8050's 77 tracks on each side, tracks 78-154 on the
+    # second, one directory and one BAM for both.
+    class D82Image < D80Image
+      ERROR_TABLES = { 1_070_662 => 4166 }.freeze
+
+      def sectors_in(track)
+        track > SIDE_TRACKS ? super(track - SIDE_TRACKS) : super
+      end
+
+      private
+
+      def error_tables = ERROR_TABLES
+
+      def bam_tracks = 1..(2 * SIDE_TRACKS)
+    end
+  end
+end

data/lib/badline/storage/g64_image.rb

@@ -47,7 +47,7 @@ module Badline
       # track 1 and 1 for track 1.5, laid out as VICE lays one out: every
       # block as long as the longest track.
       def self.create(path, tracks, half_tracks: HALF_TRACKS)
-        max = tracks.values.map { |bytes, _| bytes.length }.push(MAX_TRACK_SIZE).max
+        max = [MAX_TRACK_SIZE, *tracks.values.map { |bytes, _| bytes.length }].max
         offsets = Array.new(half_tracks, 0)
         zones = Array.new(half_tracks, 0)
         blocks = +"".b

data/lib/badline/storage/tap.rb

@@ -3,7 +3,7 @@
 module Badline
   module Storage
     # Raw datasette pulse stream. The header holds the signature, the
-    # version at $0c, the platform at $0d (0 C64, 1 VIC-20, 2 C16) and the
+    # version at $0c, the platform at $0d (0 C64, 1 VIC-20, 2 C16, 3 PET) and the
     # data size at $10; the data runs from $14, every byte the time to the
     # next falling edge on the tape read line, in units of 8 cycles. A
     # version 2 tape, the C16's and the Plus/4's, times half waves instead,
@@ -16,18 +16,31 @@ module Badline
       HEADER_SIZE = 0x14
       OVERFLOW = 0x100 * 8
 
+      # The platform byte of a PET tape, a version 1 tape timed in PET
+      # cycles.
+      PET_PLATFORM = 3
+
       # The file it was read from, expanded, and the file's bytes.
       attr_reader :version, :platform, :path, :bytes
 
       # A blank tape for `platform` at `path`, written to the host file: a
-      # version 1 tape for the C64 (0) or the VIC-20 (1), and a version 2
-      # C16 tape for the 264 series (2).
+      # version 1 tape for the C64 (0), the VIC-20 (1) or the PET (3), and
+      # a version 2 C16 tape for the 264 series (2).
       def self.create(path, platform:)
         header = platform == 2 ? C16_SIGNATURE + [2] : SIGNATURE + [1]
         File.binwrite(path, (header + [platform, 0, 0, 0, 0, 0, 0]).pack("C*"))
         new(path)
       end
 
+      # The platform byte of the tape at `path`, or nil when it isn't a
+      # TAP file, read from its header alone.
+      def self.platform_of(path)
+        header = File.binread(path, HEADER_SIZE)&.bytes || []
+        return unless [SIGNATURE, C16_SIGNATURE].include?(header[0, SIGNATURE.length]) && header.length > 0x0d
+
+        header[0x0d]
+      end
+
       # `bytes` stands in for the host file's contents, as a snapshot
       # restores the tape it holds.
       def initialize(path, bytes: nil)

data/lib/badline/storage.rb

@@ -7,6 +7,8 @@ require "badline/storage/disk_image"
 require "badline/storage/d64_image"
 require "badline/storage/d71_image"
 require "badline/storage/d81_image"
+require "badline/storage/d80_image"
+require "badline/storage/d82_image"
 require "badline/storage/g64_image"
 require "badline/storage/t64"
 require "badline/storage/tap"

data/lib/badline/support/pet_checkpoint.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a PET: its CPU, the RAM below $8000, the screen RAM,
+    # the picture the video paints, both PIAs, the VIA, the CRTC's
+    # registers and counters, and the 8096's control register and 64K
+    # board, or nothing on another model.
+    module PETCheckpoint
+      COMPONENTS = %w[cpu ram screen display pia1 pia2 via crtc expansion].freeze
+
+      def self.take(machine)
+        ram = machine.ram
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(ram, ram.length)),
+                         Checkpoint.fnv1a(machine.bus.screen.cells),
+                         Checkpoint.fnv1a(machine.video.display),
+                         Checkpoint.fnv1a(pia_state(machine.pia1)),
+                         Checkpoint.fnv1a(pia_state(machine.pia2)),
+                         Checkpoint.fnv1a(Vic20Checkpoint.via_state(machine.via)),
+                         Checkpoint.fnv1a(crtc_state(machine.crtc)),
+                         Checkpoint.fnv1a(expansion_state(machine.bus.expansion))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.pia_state(pia) = [pia.port_a_output, pia.port_b_output, pia.cra, pia.crb]
+
+      def self.crtc_state(crtc) = crtc.registers + [crtc.column, crtc.line, crtc.row]
+
+      def self.expansion_state(expansion)
+        expansion ? [expansion.control, *expansion.cells] : []
+      end
+    end
+  end
+end

data/lib/badline/timing.rb

@@ -5,8 +5,9 @@ module Badline
   #
   # What a front end needs to run a machine's frames and show them: the CPU
   # clock, the raster's cycles per line and lines per frame, and the
-  # [left, top, width, height] of the raster it shows, and how many of the
-  # window's square pixels wide each of its pixels shows. Each machine
-  # derives it from its region.
-  Timing = Data.define(:clock_hz, :cycles_per_line, :lines_per_frame, :crop, :pixel_width)
+  # [left, top, width, height] of the raster it shows, how many of the
+  # window's square pixels wide each of its pixels shows, and how many of
+  # its pixels share one window pixel, as an 80-column screen's dots do.
+  # Each machine derives it from its region.
+  Timing = Data.define(:clock_hz, :cycles_per_line, :lines_per_frame, :crop, :pixel_width, :dots)
 end

data/lib/badline/version.rb

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

data/lib/badline/vic20/attachments.rb

@@ -23,12 +23,17 @@ module Badline
       # Puts a cartridge's ROM chips, each a CRTFile::Chip with its address
       # and bytes, into their blocks, and switches the machine off and on,
       # as a cartridge goes in with the power off. The KERNAL then starts
-      # the cartridge in BLK5 that signs itself with A0CBM.
-      def attach_cartridge(chips)
+      # the cartridge in BLK5 that signs itself with A0CBM. +name+ is the
+      # name it goes by (#cartridge_name).
+      def attach_cartridge(chips, name = "")
         chips.each { |chip| @bus.map_rom(chip.address, chip.data) }
+        @bus.cartridge_name = name
         power_cycle!
       end
 
+      # The name of the cartridge in the expansion blocks, or an empty one.
+      def cartridge_name = @bus.cartridge_name
+
       private
 
       # The VIC-20's KERNAL, which the traps stand in for.

data/lib/badline/vic20/bus/keyed_state.rb

@@ -11,9 +11,9 @@ module Badline
       end
 
       # The bytes each side's data lines hold, under `prefix`, and a
-      # cartridge's ROM chips as rom<N>.start and rom<N>.bytes, in a keyed
-      # snapshot module (Snapshot::Keyed). The pages are mapped again once
-      # they are loaded.
+      # cartridge's name and its ROM chips as rom<N>.start and rom<N>.bytes,
+      # in a keyed snapshot module (Snapshot::Keyed). The pages are mapped
+      # again once they are loaded.
       module KeyedState
         def save_fields(out, prefix)
           out.int("#{prefix}data", @data).int("#{prefix}video_data", @video_data)
@@ -28,7 +28,7 @@ module Badline
         def cartridge? = !@roms.empty?
 
         def save_rom_fields(out)
-          out.int("roms", @roms.length)
+          out.text("name", @cartridge_name).int("roms", @roms.length)
           @roms.each_with_index do |rom, number|
             out.int("rom#{number}.start", rom.start)
             rom.save_fields(out, "rom#{number}.bytes")
@@ -37,6 +37,7 @@ module Badline
 
         def load_rom_fields(input)
           @roms = []
+          @cartridge_name = input.text("name", "")
           input.int("roms", 0).times do |number|
             bytes = input.bytes("rom#{number}.bytes", "".b).bytes
             @roms << ROM.new(bytes, length: bytes.length, start: input.word("rom#{number}.start", 0))

data/lib/badline/vic20/bus.rb

@@ -160,6 +160,10 @@ module Badline
       # The last byte on the V-bus.
       attr_reader :video_data
 
+      # The name of the cartridge whose ROM chips are in the expansion
+      # blocks, or an empty one.
+      attr_accessor :cartridge_name
+
       # +vic+, +via1+ and +via2+ are the chips in I/O 0, each answering
       # peek and poke with the CPU's address. +blocks+ names the expansion
       # blocks that hold RAM (BLOCKS), and +kernal+ the KERNAL ROM's file.
@@ -177,6 +181,7 @@ module Badline
         @read_pages = Array.new(256, @open_bus)
         @write_pages = Array.new(256, @open_bus)
         @roms = []
+        @cartridge_name = ""
         @debug_register = nil
         @via_write_handler = nil
         self.blocks = blocks

data/lib/badline/vic20.rb

@@ -120,7 +120,7 @@ module Badline
       blanked = profile.blanked_lines
       Timing.new(clock_hz: profile.clock_hz, cycles_per_line: profile.cycles_per_line,
                  lines_per_frame: profile.lines_per_frame,
-                 crop: [0, blanked, width, profile.lines_per_frame - blanked], pixel_width: 2)
+                 crop: [0, blanked, width, profile.lines_per_frame - blanked], pixel_width: 2, dots: 1)
     end
 
     # The RESTORE key pulls VIA 1's CA1 low while it is held. The KERNAL