badline 0.16.0 → 0.16.1

data/lib/badline/machine.rb

@@ -153,13 +153,14 @@ module Badline
 
     # A PET with the RAM --ram names (PET::Model::RAM_SIZES), or with the
     # model's own without it, the editor at the frame rate --60hz or
-    # --editor asks for, and the ROMs --basic and --editor fit it with.
+    # --editor asks for, the ROMs --basic, --editor and --characters fit it
+    # with, and the 8296 board's jumpers --jumpers names.
     def self.pet_for(media, options)
       unsupported = !media.nil? && Media::PETMedia::UNSUPPORTED.include?(File.extname(media).downcase)
       raise Unsupported, "doesn't go in a PET" if unsupported
 
       PET.new(model: options.model, ram_kb: options.ram_kb, refresh_hz: options.refresh_hz, basic: options.basic,
-              editor: options.editor)
+              editor: options.editor, characters: options.characters, jumpers: options.jumpers)
     end
     private_class_method :pet_for
 

data/lib/badline/media/pet_media.rb

@@ -10,7 +10,7 @@ module Badline
     # is no cartridge port and no SID, and the true drives are serial ones.
     module PETMedia
       # What a PET doesn't take.
-      UNSUPPORTED = Extensions.of(%i[tune cartridge gcr])
+      UNSUPPORTED = Extensions.of(%i[tune cartridge])
 
       # What loads and runs the first program on the disk in device 8.
       AUTOSTART = %(load"*",8\rrun\r)
@@ -26,12 +26,12 @@ module Badline
 
         # BASIC 2 and 4 load the first program off the disk and run it.
         # BASIC 1's LOAD finds no device on the IEEE-488 bus, so the first
-        # program goes in as a program file does, once the KERNAL has
-        # booted.
-        def disk_autostart(machine, storage)
+        # program, which the block gives, goes in as a program file does,
+        # once the KERNAL has booted.
+        def disk_autostart(machine)
           return machine.type_text(AUTOSTART) unless machine.model.basic1?
 
-          data = storage.read_file("*")
+          data = yield
           machine.on_init { Program.load(machine, data, autostart: true) } if data
         end
       end

data/lib/badline/media/true_drive.rb

@@ -4,15 +4,16 @@ module Badline
   module Media
     # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
     # the C128 its 1571, or on the Plus/4 a 1551 if it asks for one, or a
-    # 1581. Once a true drive is plugged in as device 8, disk media go into
+    # 1581, or on the PET a 2031 on the IEEE-488 bus. Once a true drive is plugged in as device 8, disk media go into
     # it rather than into the traps, so a LOAD runs the DOS and every byte
     # crosses the serial bus or TCBM. A .g64 holds the
     # disk's raw GCR, which only a true drive reads, so it plugs one in
     # when there's none yet. The 1541 reads only .d64 and .g64 images, the
     # 1571 .d71 and .g71 as well, and the 1581 only .d81, so a .d81 swaps
     # the drive on device 8 for a 1581 (Drives::Model1581::Slot), and another disk
-    # image swaps a 1581 back for the machine's own drive. The traps' other
-    # disk media, a .t64 or a host directory, raise Error.
+    # image swaps a 1581 back for the machine's own drive. The PET has no
+    # 1581, and its 2031 reads .d64 and .g64 images only. The traps' other
+    # disk media, a .t64, a host directory, or a .d80 or .d82, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
@@ -36,7 +37,7 @@ module Badline
           kind = Extensions.kind(path)
           return true if kind == :gcr
 
-          !drive(computer).nil? && (File.directory?(path) || %i[disk archive].include?(kind))
+          !drive(computer).nil? && (File.directory?(path) || %i[disk archive ieee_disk].include?(kind))
         end
 
         # Puts the image in the drive on device 8, plugging one in that
@@ -44,12 +45,15 @@ module Badline
         # mounted through the traps, so LOAD and SAVE reach the drive too.
         # `read_only` puts it in write-protected.
         def insert(computer, path, read_only: false)
-          return insert_d81(computer, path, read_only) if File.extname(path).casecmp?(".d81")
+          pet = computer.family == :pet
+          return insert_d81(computer, path, read_only) if !pet && File.extname(path).casecmp?(".d81")
 
           drive = own_drive(computer)
-          name = drive&.model_name || (computer.family == :c128 ? "1571" : "1541")
+          name = drive&.model_name || default_model(computer)
           types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
           unless types.include?(File.extname(path).downcase)
+            raise Error, "#{path} is not a #{types.join(' or ')} image, which the #{name} reads" if pet
+
             raise Error, "#{path} is not a #{types.join(', ')} or .d81 image, which the #{name} and the 1581 read"
           end
 
@@ -61,6 +65,15 @@ module Badline
 
         private
 
+        # The model plug_true_drive plugs in.
+        def default_model(computer)
+          case computer.family
+          when :c128 then "1571"
+          when :pet then "2031"
+          else "1541"
+          end
+        end
+
         # The drive on device 8 unless it's a 1581.
         def own_drive(computer)
           drive = drive(computer)

data/lib/badline/media.rb

@@ -159,7 +159,11 @@ module Badline
 
       def attach_true_drive(computer, path, disk, autostart:)
         message = TrueDrive.insert(computer, path, read_only: disk.fetch(:read_only, false))
-        computer.type_text(disk_autostart(computer) { Vic20Media.first_program(path) }) if autostart
+        if autostart && computer.family == :pet
+          PETMedia.disk_autostart(computer) { Vic20Media.first_program(path) }
+        elsif autostart
+          computer.type_text(disk_autostart(computer) { Vic20Media.first_program(path) })
+        end
         message
       end
 
@@ -167,7 +171,7 @@ module Badline
         storage = open_storage(path, disk)
         computer.mount(storage)
         if autostart && computer.family == :pet
-          PETMedia.disk_autostart(computer, storage)
+          PETMedia.disk_autostart(computer) { storage.read_file("*") }
         elsif autostart
           computer.type_text(disk_autostart(computer) { storage.read_file("*") })
         end

data/lib/badline/options/help.rb

@@ -126,10 +126,14 @@ module Badline
         and the pause menu's KEYBOARD page says where the rest are. --basic
         and --editor fit the upgrades Commodore sold, as in --model 2001
         --basic 2. BASIC 1 can't LOAD from a disk drive, though a disk still
-        starts its first program, and BASIC 2 can. The 8032 and the 8096
-        have two 50 Hz editors: 4-80-b-50hz, the default, and
-        4-80-b-50hz-0283, another chip's, with 64-cycle lines and 313 lines
-        a frame.
+        starts its first program, and BASIC 2 can. Their --true-drive makes
+        device 8 an emulated 2031 on the IEEE-488 bus, which reads .d64 and
+        .g64 images. The 8032 and the 8096 have two 50 Hz editors:
+        4-80-b-50hz, the default, and 4-80-b-50hz-0283, another chip's,
+        with 64-cycle lines and 313 lines a frame. The 8296 runs its own,
+        4-80-b-50hz-8296, and takes the 8032's too. --characters din fits
+        it with the DIN character ROM, and --jumpers ram9,rama puts RAM at
+        $9000 and $A000, as xpet's -petram9 and -petramA do.
 
         --headless plays a .sid tune on the host's audio device without the
         window, and --audio-out renders it to 16-bit PCM instead. The

data/lib/badline/options/table.rb

@@ -20,7 +20,7 @@ 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 true drives --drive-type names for the Plus/4.
     PLUS4_DRIVE_TYPES = %w[1541 1551].freeze
@@ -47,7 +47,7 @@ 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",
                  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),
@@ -70,6 +70,12 @@ module Badline
       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 +118,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 or PET snapshot, for x64sc or xpet",
                  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

@@ -176,18 +176,34 @@ module Badline
         raise Error, "--60hz needs pet" unless @refresh_hz.nil?
         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

data/lib/badline/options.rb

@@ -80,9 +80,13 @@ module Badline
     # :plus4 or :pet.
     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 +136,7 @@ module Badline
       @ram = nil
       @ram_kb = nil
       @ram_name = nil
-      @refresh_hz = nil
-      @basic = nil
-      @editor = nil
+      initialize_pet
       @cartridges = {}
       @autostart = true
       @writable = false
@@ -322,8 +324,7 @@ 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 "--c1lo", "--c1hi", "--c2lo", "--c2hi" then @cartridges[CARTRIDGE_SLOTS.fetch(name)] = value
       when "--frames" then @frames = number(flag, value)
@@ -338,6 +339,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/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

data/lib/badline/pet/crtc_video.rb

@@ -7,7 +7,15 @@ module Badline
     # and the character ROM's row RA0-RA2 from the half VIA CA2 selects.
     # On the 80-column boards each character reads two bytes, at twice the
     # address and the one after, and shows them side by side, 16 dots to a
-    # cycle. MA12 low inverts the picture, and RA3 high blanks the line.
+    # cycle. MA12 low inverts the picture, and RA3 or RA4 high blanks the
+    # line (NO ROW on the 8032029 and 8032087 schematics' sheet 10), so a
+    # row taller than eight lines shows its first eight alone.
+    #
+    # The 8296's board (+board8296+) reads the screen from the 32K of RAM
+    # from $8000 on: MA0-MA11 count two bytes each from $8000, RA3 alone
+    # blanks the line, and RA4 adds $4000, so lines 16 to 23 of a row
+    # taller than 16 show the RAM under BASIC at $C000. MA13 picks the half
+    # of a 4K character ROM.
     #
     # The picture is a Canvas 273 lines high, 704 dots wide on 80 columns
     # and 384 on 40, framed as xpet frames it. Across, R1's characters sit
@@ -31,9 +39,13 @@ module Badline
       # The screen RAM's bytes.
       attr_writer :cells
 
-      def initialize(characters, via, crtc_registers, columns80:)
+      def initialize(characters, via, crtc_registers, columns80:, board8296: false)
         @cells = []
         @rows = characters.rows
+        @cell_mask = board8296 ? 0xfff : 0x3ff
+        @ra4 = board8296 ? 0x10 : 0
+        @no_row = board8296 ? 0x08 : 0x18
+        @half = characters.halves? ? 0x2000 : 0
         @via = via
         @registers = crtc_registers
         @wide = columns80
@@ -61,7 +73,7 @@ module Badline
         x = @origin + (since_hsync << @char_shift)
         @from = x if x < @from
         @to = x if x > @to
-        bits = raster.anybits?(0x08) ? 0 : row_bits(address, raster)
+        bits = raster.anybits?(@no_row) ? 0 : row_bits(address, raster)
         if @wide
           @canvas.paint(x, @y, bits >> 8)
           @canvas.paint(x + 8, @y, bits & 0xff)
@@ -109,11 +121,12 @@ module Badline
       def row_bits(address, raster)
         set = @via.ca2_output ? Characters::TEXT : 0
         invert = address.anybits?(0x1000) ? 0 : 0xffff
-        line = set | (raster & 0x07)
-        cell = address & 0x3ff
+        line = set | (raster & 0x07) | ((address & @half) >> 1)
+        cell = address & @cell_mask
         if @wide
-          left = @rows[line | (@cells[cell << 1] << 3)]
-          right = @rows[line | (@cells[(cell << 1) | 1] << 3)]
+          base = (cell << 1) | ((raster & @ra4) << 10)
+          left = @rows[line | (@cells[base] << 3)]
+          right = @rows[line | (@cells[base | 1] << 3)]
           ((left << 8) | right) ^ invert
         else
           (@rows[line | (@cells[cell] << 3)] ^ invert) & 0xff