badline 0.16.0 → 0.17.0

data/lib/badline/options/table.rb

@@ -20,7 +20,17 @@ module Badline
 
     # The PETs and CBMs, as PET::Model names them, the 8032 first, the
     # default.
-    PET_MODELS = %w[8032 8096 4032 3032 3032b 2001].freeze
+    PET_MODELS = %w[8032 8096 8296 4032 3032 3032b 2001].freeze
+
+    # The CBM-II's B series, as CBM2::Model names them, the 610 first, the
+    # default, and the P500, as CBM2::P500::Model names them.
+    CBM2_MODELS = %w[610 620 710 720 510 510ntsc].freeze
+
+    # The B series' KERNALs --kernal names, 901244-04a first, the default.
+    CBM2_KERNALS = %w[04a 03b].freeze
+
+    # The P500's one KERNAL, 901234-02.
+    P500_KERNALS = %w[02].freeze
 
     # The true drives --drive-type names for the Plus/4.
     PLUS4_DRIVE_TYPES = %w[1541 1551].freeze
@@ -47,7 +57,8 @@ module Badline
                  section: "Window options", needs: :window),
       Option.new("--no-sound", "Don't play the SID", section: "Window options", needs: :window, build: :native),
       Option.new("--true-drive", "Put a true 1541 on device 8 instead of the KERNAL traps, a 1571 on the C128, " \
-                                 "a 1551 on the Plus/4",
+                                 "a 1551 on the Plus/4, a 2031 on the PET or the CBM-II, or for a .d80 or .d82 " \
+                                 "an 8050 or 8250",
                  section: "Window options", needs: :window),
       Option.new("--drive-type MODEL", "The Plus/4's true drive: 1541 or 1551 (default: 1551); implies --true-drive",
                  section: "Window options", needs: :window),
@@ -55,7 +66,7 @@ module Badline
                  section: "Window options", needs: :window),
       Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal; " \
                                  "C128: #{C128_MODELS.join(', ')}; Plus/4: #{PLUS4_MODELS.join(', ')}; " \
-                                 "PET: #{PET_MODELS.join(', ')}",
+                                 "PET: #{PET_MODELS.join(', ')}; CBM-II: #{CBM2_MODELS.join(', ')}",
                  section: "Window options", needs: :window),
       Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
       Option.new("--c64", "Start the C128 in C64 mode, holding C= at power-on",
@@ -63,13 +74,22 @@ module Badline
       Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded); " \
                                "Plus/4 RAM: 16k, 32k or 64k; PET RAM: 4k, 8k, 16k or 32k (default: the model's own)",
                  section: "Window options", needs: :window),
-      Option.new("--60hz", "Run a CRTC PET's 60 Hz editor instead of its 50 Hz one",
+      Option.new("--60hz", "Run a CRTC PET's 60 Hz editor instead of its 50 Hz one, or a CBM-II on 60 Hz mains",
+                 section: "Window options", needs: :window),
+      Option.new("--kernal VERSION", "Fit a CBM-II with KERNAL #{CBM2_KERNALS.join(' or ')} " \
+                                     "(default: #{CBM2_KERNALS.first}); the P500 takes #{P500_KERNALS.first}",
                  section: "Window options", needs: :window),
       Option.new("--basic VERSION", "Fit a PET with BASIC 1, 2 or 4, as its board takes (default: its own)",
                  section: "Window options", needs: :window),
       Option.new("--editor NAME", "Fit a PET with an editor ROM its board and BASIC take: " \
                                   "#{PET::ROMSets::EDITORS.keys.join(', ')}",
                  section: "Window options", needs: :window),
+      Option.new("--characters NAME", "Fit an 8296 with a character ROM: ascii or din (default: ascii)",
+                 section: "Window options", needs: :window),
+      Option.new("--jumpers LIST", "Fit an 8296's board with jumpers, comma-separated: ram9 and rama for RAM at " \
+                                   "$9000 and $A000, userport for the user port's PA0-PA2 to switch in " \
+                                   "the RAM under the ROMs",
+                 section: "Window options", needs: :window),
       Option.new("--c1lo FILE", "Put a .bin ROM image in the Plus/4's cartridge 1, low slot ($8000)",
                  section: "Window options", needs: :window),
       Option.new("--c1hi FILE", "Put a .bin ROM image in cartridge 1's high slot ($C000)",
@@ -112,7 +132,7 @@ module Badline
                  section: "Testing options", needs: :window),
       Option.new("--save-snapshot FILE", "Save the machine as a .vsf snapshot after the last frame",
                  section: "Testing options", needs: :window),
-      Option.new("--vice", "Add VICE's modules to --save-snapshot's C64 snapshot, for x64sc",
+      Option.new("--vice", "Add VICE's modules to --save-snapshot's C64, PET or CBM-II snapshot",
                  section: "Testing options", needs: :window),
       Option.new("--at FRAME:EVENT", "Run EVENT once FRAME frames have run (see above)",
                  section: "Testing options", needs: :window),

data/lib/badline/options/validation.rb

@@ -57,6 +57,12 @@ module Badline
         value
       end
 
+      def kernal_for(value)
+        raise Error, "invalid argument: --kernal #{value}" unless (CBM2_KERNALS + P500_KERNALS).include?(value)
+
+        value
+      end
+
       def reu_size(value)
         raise Error, "invalid argument: --reu #{value}" unless REU_SIZES.include?(value)
 
@@ -102,6 +108,7 @@ module Badline
         validate_vic20 if @family == :vic20
         @family == :plus4 ? validate_plus4 : refuse_plus4_options
         @family == :pet ? validate_pet : refuse_pet_options
+        @family == :cbm2 ? validate_cbm2 : refuse_cbm2_options
         if @family == :c128
           validate_c128
         elsif @c64_mode
@@ -170,24 +177,40 @@ module Badline
         raise Error, "--sid-card-address needs --sid-card" unless @sid_card_address.nil? || @sid_card
       end
 
-      # Only the PET has a frame rate to pick and BASIC and editor ROMs to
-      # fit.
+      # Only the PET has BASIC and editor ROMs to fit, and only it and the
+      # CBM-II a frame rate to pick.
       def refuse_pet_options
-        raise Error, "--60hz needs pet" unless @refresh_hz.nil?
+        raise Error, "--60hz needs pet or cbm2" unless @refresh_hz.nil? || @family == :cbm2
         raise Error, "--basic needs pet" unless @basic.nil?
         raise Error, "--editor needs pet" unless @editor.nil?
+        raise Error, "--characters needs pet" unless @characters.nil?
+        raise Error, "--jumpers needs pet" unless @jumpers.empty?
       end
 
-      # The PET runs in the window, without the C64's SID and REU or a true
-      # drive, at the frame rate its editor sets.
+      # The PET runs in the window, without the C64's SID and REU, at the
+      # frame rate its editor sets.
       def validate_pet
         raise Error, "--ntsc needs the C64; a CRTC PET's 60 Hz editor is --60hz" if @models.include?("ntsc")
         raise Error, "--sid needs the C64" unless @sid_model.nil?
         raise Error, "--reu needs the C64" unless @reu.nil?
-        raise Error, "the PET has no true drive yet" if @true_drive
         raise Error, "the PET needs the window" if headless?
 
-        validate_pet_roms if PET_MODELS.include?(model)
+        return unless PET_MODELS.include?(model)
+
+        validate_pet_roms
+        validate_pet_board
+      end
+
+      # --characters names a character ROM the board takes, --jumpers the
+      # 8296 board's jumpers, and the 8296 has all of its RAM soldered on.
+      def validate_pet_board
+        unless @characters.nil? || PET::ROMSets.characters(model).include?(@characters)
+          raise Error, "the #{model} takes no character ROM #{@characters}"
+        end
+
+        unknown = @jumpers.find { |jumper| !PET::ROMSets.jumpers(model).include?(jumper) }
+        raise Error, "the #{model} has no jumper #{unknown}" unless unknown.nil?
+        raise Error, "the 8296 has 32k of RAM" if model == "8296" && ![nil, 32].include?(@ram_kb)
       end
 
       # --basic and --editor name ROMs the model's board takes
@@ -216,6 +239,23 @@ module Badline
         @refresh_hz = editor_hz
       end
 
+      # Only the CBM-II has a KERNAL to pick.
+      def refuse_cbm2_options
+        raise Error, "--kernal needs cbm2" unless @kernal.nil?
+      end
+
+      # The CBM-II runs in the window, without the C64's SID and REU, and
+      # its model takes the KERNAL named.
+      def validate_cbm2
+        raise Error, "--ntsc needs the C64; a CBM-II on 60 Hz mains is --60hz" if @models.include?("ntsc")
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the CBM-II needs the window" if headless?
+
+        kernals = p500? ? P500_KERNALS : CBM2_KERNALS
+        raise Error, "the #{model} takes KERNAL #{kernals.join(' or ')}" unless kernals.include?(kernal)
+      end
+
       # `sid` takes directories as well as tunes.
       def validate_tune(path)
         return if !File.exist?(path) || File.extname(path).casecmp?(".sid")

data/lib/badline/options.rb

@@ -13,10 +13,11 @@ module Badline
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
   # first, plays .sid tunes and directories of them in the terminal.
-  # `c64`, `vic20`, `c128`, `plus4` or `pet`, given first, names the
-  # machine family, and without one the family is the C64, the C128 for a
-  # program that loads where C128 BASIC starts, or the PET for an 8050's
-  # or 8250's disk or a PET tape.
+  # `c64`, `vic20`, `c128`, `plus4`, `pet` or `cbm2`, given first, names
+  # the machine family, and without one the family is the C64, the C128
+  # for a program that loads where C128 BASIC starts, the PET for an
+  # 8050's or 8250's disk or a PET tape, or the CBM-II for a cartridge
+  # signed as its own.
   # The native build adds --no-sound and --version, and badline-ruby adds
   # --disable-jit.
   #
@@ -77,12 +78,16 @@ module Badline
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
     # The machine family to build (Badline::Machine), :c64, :vic20, :c128,
-    # :plus4 or :pet.
+    # :plus4, :pet or :cbm2.
     attr_reader :family
 
-    # The ROMs --basic and --editor fit a PET with, keys of
-    # PET::ROMSets::BASICS and PET::ROMSets::EDITORS, or nil for its own.
-    attr_reader :basic, :editor
+    # The ROMs --basic, --editor and --characters fit a PET with, keys of
+    # PET::ROMSets::BASICS, PET::ROMSets::EDITORS and
+    # PET::ROMSets::CHARACTERS, or nil for its own.
+    attr_reader :basic, :editor, :characters
+
+    # The 8296's board jumpers --jumpers names (PET::Bus::Expansion::JUMPERS).
+    attr_reader :jumpers
 
     # The VIC-20's RAM expansion --ram names, a key of
     # Vic20::Bus::RAM_CONFIGURATIONS, or nil without --ram.
@@ -132,9 +137,8 @@ module Badline
       @ram = nil
       @ram_kb = nil
       @ram_name = nil
-      @refresh_hz = nil
-      @basic = nil
-      @editor = nil
+      initialize_pet
+      @kernal = nil
       @cartridges = {}
       @autostart = true
       @writable = false
@@ -244,9 +248,20 @@ module Badline
     def c64_mode? = @c64_mode
 
     # The frame rate of a CRTC PET's editor: 60 with --60hz or a 60 Hz
-    # --editor, else 50.
+    # --editor, else 50. A B series CBM-II's mains, which its editor
+    # follows.
     def refresh_hz = @refresh_hz || 50
 
+    # The CBM-II's mains, 60 with --60hz, or nil for the model's own.
+    def mains_hz = @refresh_hz
+
+    # The CBM-II's KERNAL --kernal names, one of CBM2_KERNALS or, on the
+    # P500, P500_KERNALS, the first of them without it.
+    def kernal = @kernal || (p500? ? P500_KERNALS : CBM2_KERNALS).first
+
+    # Whether the CBM-II to run is a P500, a 510 of either region.
+    def p500? = @family == :cbm2 && model.start_with?("510")
+
     def help? = @help
 
     def version? = @version
@@ -262,7 +277,7 @@ module Badline
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
-      return if @sid_command || %i[vic20 plus4 pet].include?(@family) || headless? || !@window_only.empty?
+      return if @sid_command || %i[vic20 plus4 pet cbm2].include?(@family) || headless? || !@window_only.empty?
       return if @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
@@ -322,9 +337,9 @@ module Badline
       when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
       when "--ram" then @ram_name = value
-      when "--basic" then @basic = value
-      when "--editor" then @editor = value
+      when "--basic", "--editor", "--characters", "--jumpers" then pet_option(name, value)
       when "--drive-type" then @drive_type = drive_type_for(value)
+      when "--kernal" then @kernal = kernal_for(value)
       when "--c1lo", "--c1hi", "--c2lo", "--c2hi" then @cartridges[CARTRIDGE_SLOTS.fetch(name)] = value
       when "--frames" then @frames = number(flag, value)
       when "--screenshot" then @screenshot = value
@@ -338,6 +353,24 @@ module Badline
       end
     end
 
+    # The PET's frame rate, ROMs and board jumpers, its own until named.
+    def initialize_pet
+      @refresh_hz = nil
+      @basic = nil
+      @editor = nil
+      @characters = nil
+      @jumpers = []
+    end
+
+    def pet_option(name, value)
+      case name
+      when "--basic" then @basic = value
+      when "--editor" then @editor = value
+      when "--characters" then @characters = value
+      else @jumpers = value.split(",")
+      end
+    end
+
     def switch(name)
       case name
       when "--no-autostart" then @autostart = false

data/lib/badline/pet/bus/expansion.rb

@@ -3,10 +3,11 @@
 module Badline
   class PET
     class Bus
-      # The 8096's 64K board: four 16K banks, which a write-only control
-      # register at $FFF0 lays over $8000-$FFFF, two at a time:
+      # The 64K board of the 8096 and the 8296: four 16K banks, which a
+      # write-only control register at $FFF0 lays over $8000-$FFFF, two at
+      # a time:
       #
-      #   bit 7  the board on; when clear, a plain 8032 and the rest ignored
+      #   bit 7  the board on; when clear, the rest ignored
       #   bit 6  I/O shows through at $E800-$EFFF
       #   bit 5  the screen shows through at $8000-$8FFF
       #   bit 3  bank 3 at $C000-$FFFF, else bank 1
@@ -16,6 +17,26 @@ module Badline
       #
       # A write to $FFF0 lands where $FFF0 was before it, too. The RES line
       # clears the register, so the 8096 starts as an 8032.
+      #
+      # The 8296 decodes its memory in a PLA, after the logic equations
+      # André Fachat read out of it (8296desc.txt on zimmers.net), with 32K
+      # of RAM from $8000 (Bus#screen) besides the board:
+      #
+      # - With bit 7 clear, every write from $8000 up but to $E8xx goes to
+      #   that RAM, under the ROMs too. Reads find the screen at $8000,
+      #   the empty sockets at $9000 and $A000, BASIC, the editor at
+      #   $E000-$E7FF and again at $E900-$EFFF, and the KERNAL, unless the
+      #   lines /RAMSEL9, /RAMSELA and /RAMON put RAM there (#ram_lines).
+      #   RAMSEL9 puts it at $9000, RAMSELA at $A000, RAMON at
+      #   $8000-$DFFF, RAMON with either of the others at $E000-$EFFF but
+      #   $E8xx, and RAMON with RAMSELA at $F000 as well.
+      # - With bit 7 set, I/O showing through brings back the editor at
+      #   $E900-$EFFF, which an 8096 leaves empty.
+      #
+      # Jumpers tie the lines: JU2 RAMSEL9 low and JU1 RAMSELA low
+      # (:ram9, :rama), or JU4, JU3 and JU5 RAMSEL9, RAMSELA and RAMON to
+      # the user port's PA1, PA0 and PA2 (:userport), each active low.
+      # With none fitted, as on xpet's 8296, the lines stay high.
       class Expansion
         # A 16K bank of the board, seen from +start+.
         class Window
@@ -50,9 +71,16 @@ module Badline
           end
         end
 
+        # The user port lines that RAMSELA, RAMSEL9 and RAMON follow.
+        USER_PORT_LINES = 0x07
+
         attr_reader :cells, :control
 
-        def initialize(bus)
+        # The user port's PA0-PA2 as the board last saw them.
+        attr_reader :lines
+
+        # +jumpers+ are the 8296's (ROMSets::JUMPERS) when +board8296+ is.
+        def initialize(bus, board8296: false, jumpers: [])
           @bus = bus
           @cells = Array.new(0x10000, 0)
           @banks = [0x8000, 0xc000, 0x8000, 0xc000].each_with_index.map do |start, bank|
@@ -60,13 +88,32 @@ module Badline
           end
           @port = ControlPort.new(self, @banks[1])
           @control = 0
+          @board8296 = board8296
+          @ram9 = jumpers.include?("ram9")
+          @rama = jumpers.include?("rama")
+          @user_port = jumpers.include?("userport")
+          @lines = USER_PORT_LINES
         end
 
+        def board8296? = @board8296
+
+        # Whether the board follows the user port's lines.
+        def user_port? = @user_port
+
         def control=(value)
           @control = value
           @bus.map_pages
         end
 
+        # Follows the user port's lines, +port_a+ as the VIA drives them.
+        def lines=(port_a)
+          lines = port_a & USER_PORT_LINES
+          return if lines == @lines
+
+          @lines = lines
+          @bus.map_pages
+        end
+
         def reset!
           self.control = 0
         end
@@ -75,16 +122,33 @@ module Badline
           @cells.fill(0)
         end
 
+        # Whether the CPU reads the KERNAL at $F000-$FFFF.
+        def kernal_mapped?
+          return false if @control.anybits?(0x80)
+
+          !(@board8296 && ram_on? && ram_a?)
+        end
+
         # Lays the banks the register picks over the pages, and the
         # control register over page $FF's writes.
         def map(reads, writes)
-          map_banks(reads, writes) if @control.anybits?(0x80)
+          if @control.anybits?(0x80)
+            map_banks(reads, writes)
+          elsif @board8296
+            map_ram8296(reads, writes)
+          end
           @port.under = writes[0xff]
           writes[0xff] = @port
         end
 
         private
 
+        def ram_on? = @user_port && @lines.nobits?(0x04)
+
+        def ram9? = @ram9 || (@user_port && @lines.nobits?(0x02))
+
+        def ram_a? = @rama || (@user_port && @lines.nobits?(0x01))
+
         def map_banks(reads, writes)
           low = @banks[@control.anybits?(0x04) ? 2 : 0]
           high = @banks[@control.anybits?(0x08) ? 3 : 1]
@@ -99,6 +163,36 @@ module Badline
             reads.fill(high, page, count)
             writes.fill(high, page, count)
           end
+          map_editor_through(reads, writes) if @board8296
+        end
+
+        # I/O showing through on the 8296 leaves $E900-$EFFF to the editor,
+        # and its writes to nothing.
+        def map_editor_through(reads, writes)
+          return unless @control.anybits?(0x40)
+
+          reads.fill(@bus.editor_rom, 0xe9, 0x07)
+          writes.fill(@bus.open_bus, 0xe9, 0x07)
+        end
+
+        def map_ram8296(reads, writes)
+          ram = @bus.screen
+          writes.fill(ram, 0x90, 0x58)
+          writes.fill(ram, 0xe9, 0x17)
+          reads.fill(@bus.editor_rom, 0xe9, 0x07)
+          ram_on = ram_on?
+          ram9 = ram9?
+          ram_a = ram_a?
+          reads.fill(ram, 0x90, 0x10) if ram9 || ram_on
+          reads.fill(ram, 0xa0, 0x10) if ram_a || ram_on
+          return unless ram_on
+
+          reads.fill(ram, 0xb0, 0x30)
+          return unless ram9 || ram_a
+
+          reads.fill(ram, 0xe0, 0x08)
+          reads.fill(ram, 0xe9, 0x07)
+          reads.fill(ram, 0xf0, 0x10) if ram_a
         end
       end
     end

data/lib/badline/pet/bus.rb

@@ -19,7 +19,8 @@ module Badline
     # empty spot finds it, mostly the high byte of the address just
     # fetched, as PET/unconnected shows on a real 3016. Writes to ROM and
     # to empty spots go nowhere. An 8096 banks its 64K board over
-    # $8000-$FFFF (Expansion).
+    # $8000-$FFFF (Expansion), and an 8296 its board and the RAM under its
+    # ROMs.
     class Bus
       include Addressable
 
@@ -33,7 +34,8 @@ module Badline
         def poke(_addr, _value); end
       end
 
-      # Screen RAM, repeated over the pages it answers in.
+      # Screen RAM, repeated over the pages it answers in. On the 8296 it is
+      # all 32K of RAM from $8000, which the board lays under the ROMs.
       class ScreenRAM
         attr_reader :cells
 
@@ -107,29 +109,31 @@ module Badline
         end
       end
 
-      attr_reader :ram, :screen, :expansion
+      attr_reader :ram, :screen, :expansion, :editor_rom, :open_bus
 
       # The last byte the CPU read or wrote.
       attr_reader :data
 
       # +model+ is a Model::Profile, +ram_kb+ the RAM below $8000 and
       # +editor+ the editor ROM's file. The CRTC answers only on a board
-      # the model fits one on.
-      def initialize(model:, ram_kb:, editor:, pia1:, pia2:, via:, crtc:)
+      # the model fits one on. +jumpers+ are the 8296's (ROMSets::JUMPERS).
+      def initialize(model:, ram_kb:, editor:, pia1:, pia2:, via:, crtc:, jumpers: [])
         addressable_at(0, length: 2**16)
         @ram = Memory.new([], length: ram_kb * 1024, start: 0)
         @screen = ScreenRAM.new(model.screen_bytes)
         @screen_pages = model.screen_pages
         basic = ROM.read(model.basic)
         @basic_rom = ROM.new(basic, length: basic.length, start: 0xe000 - basic.length)
-        @editor_rom = ROM.load(editor, 0xe000)
+        @editor_rom = model.cbm8296? ? editor_socket(editor) : ROM.load(editor, 0xe000)
         @kernal_rom = ROM.load(model.kernal, 0xf000)
         @io = IO.new(self, pia1:, pia2:, via:, crtc:, crtc_fitted: model.crtc?)
         @open_bus = OpenBus.new(self)
         @data = 0
         @read_pages = Array.new(256, @open_bus)
         @write_pages = Array.new(256, @open_bus)
-        @expansion = model.expansion ? Expansion.new(self) : nil
+        @expansion = model.expansion ? Expansion.new(self, board8296: model.cbm8296?, jumpers:) : nil
+        @via = via
+        @user_port = !@expansion.nil? && @expansion.user_port?
         @debug_register = nil
         @io_write_handler = nil
         map_pages
@@ -143,11 +147,16 @@ module Badline
 
       def io_written
         @io_write_handler&.call
+        @expansion.lines = @via.port_a_output if @user_port
       end
 
-      # The RES line reaches the 8096's control register.
+      # The RES line reaches the board's control register, and the user
+      # port's lines float high with the VIA's.
       def reset!
-        @expansion&.reset!
+        return if @expansion.nil?
+
+        @expansion.reset!
+        @expansion.lines = @via.port_a_output if @user_port
       end
 
       def power_on!
@@ -166,8 +175,9 @@ module Badline
       end
 
       # Whether the CPU reads the KERNAL ROM at $F000-$FFFF, which an 8096's
-      # board covers while its control register turns it on.
-      def kernal_mapped? = @expansion.nil? || @expansion.control.nobits?(0x80)
+      # board covers while its control register turns it on, and an 8296's
+      # RAM too.
+      def kernal_mapped? = @expansion.nil? || @expansion.kernal_mapped?
 
       # Calls the block with each byte written to $8BFF (DebugRegister).
       def install_debug_register(&)
@@ -175,7 +185,7 @@ module Badline
         map_pages
       end
 
-      # Lays the pages out again, for the 8096's control register.
+      # Lays the pages out again, for the board's control register.
       def map_pages
         map(@open_bus, 0x00, 0x100)
         map(@ram, 0x00, @ram.length >> 8)
@@ -190,6 +200,14 @@ module Badline
 
       private
 
+      # The 8296's editor socket, which answers at $E000-$E7FF and
+      # $E900-$EFFF: a 4K ROM's halves there, or a 2K one twice over.
+      def editor_socket(file)
+        bytes = ROM.read(file)
+        bytes += bytes if bytes.length == 0x800
+        ROM.new(bytes, length: 0x1000, start: 0xe000)
+      end
+
       def map_debug_register
         @debug_register.under = @write_pages[0x8b]
         @write_pages[0x8b] = @debug_register

data/lib/badline/pet/cassettes.rb

@@ -11,7 +11,8 @@ module Badline
     # Both record from VIA PB3. The KERNAL reads each tape as the falling
     # edges its read line makes, as the C64 and VIC-20 do. The machine
     # passes the motor and write lines on after each write to the I/O
-    # chips (#lines_written).
+    # chips (#lines_written), and clocks the decks only while a tape runs
+    # (#running?).
     class Cassettes
       attr_reader :datasette1, :datasette2
 
@@ -22,6 +23,18 @@ module Badline
         @datasette2 = Drives::Datasette.new
         @datasette1.on_flag { pulse1 }
         @datasette2.on_flag { pulse2 }
+        @running = false
+        @running_handler = nil
+        @datasette1.on_running_change { update_running }
+        @datasette2.on_running_change { update_running }
+      end
+
+      # Whether either deck's tape runs.
+      def running? = @running
+
+      # Whether either deck's tape runs, each time that changes.
+      def on_running_change(&handler)
+        @running_handler = handler
       end
 
       def cycle!
@@ -48,6 +61,14 @@ module Badline
 
       private
 
+      def update_running
+        running = @datasette1.running? || @datasette2.running?
+        return if running == @running
+
+        @running = running
+        @running_handler&.call
+      end
+
       # A falling edge on a read line, and the line back up.
       def pulse1
         @pia1.ca1 = false

data/lib/badline/pet/characters.rb

@@ -6,21 +6,27 @@ module Badline
     # (upper case and graphics) from $000 and text (lower and upper case)
     # from $400, 128 characters of 8 rows each. Bit 7 of a screen code
     # inverts the character's rows, as the hardware does, so #rows holds
-    # 256 codes a set, each row at (set << 11) | (code << 3) | row.
+    # 256 codes a set, each row at (set << 11) | (code << 3) | row. A 4K
+    # ROM, the 8296's, holds two such halves, the second at HALF.
     class Characters
       TEXT = 0x800
 
+      HALF = 0x1000
+
       attr_reader :rows
 
       def initialize(file)
         rom = ROM.read(file)
-        @rows = Array.new(0x1000) do |index|
+        @rows = Array.new(rom.length << 1) do |index|
           set = index >> 11
           code = (index >> 3) & 0xff
           bits = rom[(set << 10) | ((code & 0x7f) << 3) | (index & 0x07)]
           code >= 0x80 ? bits ^ 0xff : bits
         end
       end
+
+      # Whether the ROM holds two halves.
+      def halves? = @rows.length > HALF
     end
   end
 end