badline 0.17.0 → 0.18.0

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/pet.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/snapshot/vice/cbm2_acia"
 require "badline/snapshot/vice/pet_cpu"
 require "badline/snapshot/vice/pet_mem"
 require "badline/snapshot/vice/pet_pias"
@@ -22,8 +23,8 @@ module Badline
         # The models badline builds by the board PETMEM names (PETMem): the
         # discrete board is a 2001's where xpet's settings say so, and a
         # 3032 otherwise.
-        MODELS = { PETMem::CRTC40 => "4032", PETMem::CRTC80 => "8032", PETMem::CBM8096 => "8096",
-                   PETMem::CBM8296 => "8296" }.freeze
+        MODELS = { PETMem::CRTC40 => "4032", PETMem::CRTC80 => "8032", PETMem::SUPERPET => "superpet",
+                   PETMem::CBM8096 => "8096", PETMem::CBM8296 => "8296" }.freeze
         # The modules xpet resets the machine without, for the parts badline
         # doesn't model in VICE's terms, each as xpet leaves them with
         # nothing attached: no file system drive open, both cassette ports
@@ -50,7 +51,8 @@ module Badline
            PIAs.export("PIA1", machine.pia1, reader(readers, "BL-PIA1")),
            PIAs.export("PIA2", machine.pia2, reader(readers, "BL-PIA2")), VIA.export(reader(readers, "BL-VIA")),
            *Drive2031.export(machine, readers), *Drive8050.export(machine, readers)] +
-            PERIPHERALS.map { |name, major, minor, bytes| FieldWriter.new.bytes(bytes).section(name, major, minor) }
+            PERIPHERALS.map { |name, major, minor, bytes| FieldWriter.new.bytes(bytes).section(name, major, minor) } +
+            (machine.superpet? ? [CBM2::ACIA.export(reader(readers, "BL-ACIA"), machine.cycles)] : [])
         end
 
         def reader(readers, name) = readers[name] || Keyed::Reader.missing(name)
@@ -61,7 +63,9 @@ module Badline
         # xpet doesn't save the keyboard, the ROMs or an 8296's jumpers, so
         # a discrete board is a 3032 with the graphics keyboard unless it is
         # a 2001, each model has its own ROMs, and an 8296 none of its
-        # jumpers, as xpet's own has.
+        # jumpers, as xpet's own has. Nor does it save the SuperPET's
+        # switches: its CPU switch is at the CPU that has the bus, and its
+        # RAM switch at R/W, which is the only position xpet has.
         def setup(container)
           memory = memory(container)
           ram_kb = PETMem.ram_kb(memory)
@@ -75,8 +79,11 @@ module Badline
           crtc = nil unless crtc.nil? || CRTC.reads?(crtc)
           refresh_hz = refresh_hz(crtc, profile)
           profile = Badline::PET::Model.upgraded(profile, nil, editor(crtc, profile, refresh_hz))
+          superpet = profile.superpet?
+          cpu_switch = PETMem.m6809?(memory) ? "6809" : "6502"
           PETSetup.new(model: name, ram_kb:, refresh_hz:, basic: profile.basic, editor: profile.editor(refresh_hz),
-                       kernal: profile.kernal, characters: profile.characters, jumpers: "")
+                       kernal: profile.kernal, characters: profile.characters, jumpers: "",
+                       cpu_switch: superpet ? cpu_switch : "", ram_switch: superpet ? "rw" : "")
         end
 
         def memory(container)
@@ -94,8 +101,7 @@ module Badline
           name = MODELS[board]
           return name unless name.nil?
 
-          what = board == PETMem::SUPERPET ? "a SuperPET" : "board #{board}"
-          raise FormatError, "#{memory}: #{what}, which badline doesn't build"
+          raise FormatError, "#{memory}: board #{board}, which badline doesn't build"
         end
 
         # The editor's frame rate, from the cycles the CRTC's registers set

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

@@ -25,7 +25,11 @@ module Badline
 
           def reads?(section) = section.major == MAJOR && section.minor == MINOR
 
-          def export(machine) = write(machine, [machine.pia1.irq?, machine.pia2.irq?, machine.via.irq?].count(true))
+          def export(machine)
+            sources = [machine.pia1.irq?, machine.pia2.irq?, machine.via.irq?]
+            sources << machine.acia_irq? if machine.superpet?
+            write(machine, sources.count(true))
+          end
 
           # The module for `machine`, whose CPU's IRQ line `irqs` sources
           # pull.
@@ -52,16 +56,46 @@ module Badline
         end
 
         # The SuperPET's 6809, CPU6809 1.1, which xpet saves on every model
-        # and won't load a snapshot without: the clock and the registers as
-        # an xpet with no SuperPET board leaves them. badline doesn't read
-        # it.
+        # and won't load a snapshot without: the clock, X, Y, U, S and PC,
+        # DP, CC, A and B, then five bytes. xpet 3.10's layout was inferred
+        # from its snapshots of a 6809 running a loop that loads each
+        # register with a value of its own; the five bytes are 0 in every
+        # snapshot xpet wrote.
+        #
+        # Written: the clock and the registers, the SuperPET's 6809's
+        # between instructions while it has the bus, and otherwise the
+        # registers of a 6809 that hasn't run, as xpet leaves them. Read:
+        # the registers, with the 6809 on an instruction boundary, as
+        # xpet's snapshot is taken on one.
         module CPU6809
           NAME = "CPU6809"
+          MAJOR = 1
+          MINOR = 1
+          # The CC an xpet without a SuperPET board saves.
+          IDLE_CC = 0x04
 
           module_function
 
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
           def export(machine)
-            FieldWriter.new.qword(machine.cycles).zeros(11).byte(0x04).zeros(7).section(NAME, 1, 1)
+            fields = FieldWriter.new.qword(machine.cycles)
+            unless machine.superpet? && machine.m6809_running?
+              return fields.zeros(11).byte(IDLE_CC).zeros(7).section(NAME, MAJOR, MINOR)
+            end
+
+            cpu = machine.m6809
+            [cpu.x, cpu.y, cpu.u, cpu.s, cpu.pc].each { |register| fields.word(register) }
+            fields.byte(cpu.dp).byte(cpu.cc).byte(cpu.a).byte(cpu.b).zeros(5).section(NAME, MAJOR, MINOR)
+          end
+
+          # The registers by their BL-M6809 keys, in a keyed module's writer,
+          # with the 6809's cycle count the machine's `cycles`.
+          def import(section, out, cycles)
+            fields = FieldReader.new(section).skip(8)
+            %w[x y u s pc].each { |name| out.int(name, fields.word) }
+            %w[dp cc a b].each { |name| out.int(name, fields.byte) }
+            out.int("cycles", cycles).bool("nmi.armed", true)
           end
         end
       end

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

@@ -6,7 +6,7 @@ module Badline
       module PET
         # CRTC 1.2, which xpet saves on every model, the discrete boards'
         # video too, as a 6545 with the registers fixed: the board's screen
-        # settings, the registers, the one selected, the beam's character,
+        # settings, the character set VIA CA2 picks, the registers, the one selected, the beam's character,
         # row and line in the row, whether the frame is in its vertical
         # adjust, the row's start in screen RAM, the lines of vertical sync
         # left, whether the rows show, the picture's size, the lines in the
@@ -36,6 +36,13 @@ module Badline
           SETTINGS = [0xff, 0x03, 0x00, 0x20, 0x00, 0x20, 0x00, 0x10, 0xff, 0x1f].freeze
           # The 8296's, whose screen RAM spans 4K.
           SETTINGS_8296 = [0xff, 0x0f, 0x00, 0x20, 0x00, 0x20, 0xff, 0x0f, 0xff, 0x1f].freeze
+          # The SuperPET's, whose character ROM spans 4K, inferred from
+          # xpet 3.10's SuperPET snapshots.
+          SETTINGS_SUPERPET = [0xff, 0x03, 0x00, 0x20, 0x00, 0x20, 0x00, 0x10, 0xff, 0x3f].freeze
+          # The word after the settings while VIA CA2 is high, picking the
+          # character ROM's second set, as xpet 3.10 writes it and paints
+          # the picture from on every PET board.
+          SECOND_SET = 0x1000
           # The 2001's and 3000 series' video as xpet's CRTC runs it: 64
           # cycles a line, 32 rows of 8 lines and 4 more, the first 25 rows
           # shown.
@@ -85,7 +92,7 @@ module Badline
                      crtc_beam(run_on(fresh_crtc(machine), crtc_input, -CRTC_LEAD % frame_cycles(registers)),
                                registers)
                    end
-            fields = FieldWriter.new.bytes(model.cbm8296? ? SETTINGS_8296 : SETTINGS).word(attributes(model))
+            fields = FieldWriter.new.bytes(settings(model)).word(machine.via.ca2_output ? SECOND_SET : 0)
             fields.byte(0).byte(columns(model))
             fields.byte(model.basic1? ? 1 : 0).bytes(registers).byte(discrete ? 0 : crtc_input.int("selected", 0))
             beam_fields(fields, beam, registers, model)
@@ -93,6 +100,12 @@ module Badline
             fields.section(NAME, MAJOR, MINOR)
           end
 
+          def settings(model)
+            return SETTINGS_8296 if model.cbm8296?
+
+            model.superpet? ? SETTINGS_SUPERPET : SETTINGS
+          end
+
           def crtc_registers(input)
             registers = input.bytes("registers", "".b).bytes
             Array.new(REGISTERS) { |index| registers[index] || 0 }