badline 0.14.0 → 0.15.0

data/lib/badline/media/program.rb

@@ -2,26 +2,40 @@
 
 module Badline
   module Media
-    # A program loading into a C64 or a C128 once it has booted
-    # (Media.attach). The VIC-20 has its own (Vic20Basic).
+    # A program loading into a C64, a C128 or a 264 series machine once it
+    # has booted (Media.attach). The VIC-20 has its own (Vic20Basic).
     module Program
+      # Where BASIC 3.5 starts on the 264 series.
+      PLUS4_BASIC_START = 0x1001
+
       class << self
         # Loads the program where it says, and RUNs one that loads at the
         # start of BASIC.
         def load(computer, data, autostart:)
           load_addr = computer.load_prg(data)
+          start, text_end, load_end = basic(computer)
           # Run only makes sense for programs at BASIC start, or a byte ahead
-          # of it, where BASIC keeps the zero before its first line. BASIC 7.0
-          # starts at $1C01 and keeps the end of its text at $1210.
-          start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
+          # of it, where BASIC keeps the zero before its first line.
           return unless autostart && (load_addr == start || load_addr == start - 1)
 
           # The end of the program, where BASIC's variables start, and where
           # the KERNAL's LOAD leaves its end address.
           end_addr = load_addr + data.length - 2
-          [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+          [text_end, load_end].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
           computer.type_text("run\r")
         end
+
+        private
+
+        # Where BASIC starts, the pointer to the end of its text and the
+        # KERNAL's end address (EAL). BASIC 7.0 starts at $1C01 and keeps
+        # the end of its text at $1210, and the 264 KERNAL keeps EAL at $9D.
+        def basic(computer)
+          return [PLUS4_BASIC_START, 0x2d, KernalTrap::PLUS4_ZERO_PAGE.end_address] if computer.family == :plus4
+          return [0x1c01, 0x1210, 0xae] if computer.family == :c128 && computer.mode == :c128
+
+          [BASIC_START, 0x2d, 0xae]
+        end
       end
     end
   end

data/lib/badline/media.rb

@@ -10,6 +10,7 @@ require "badline/media/disk_list"
 require "badline/media/vic20_basic"
 require "badline/media/vic20_cartridge"
 require "badline/media/vic20_media"
+require "badline/media/plus4_media"
 require "badline/media/tune"
 require "badline/media/program"
 
@@ -44,13 +45,14 @@ module Badline
       # An .m3u or .vfl list of disks attaches the first disk it lists
       # (DiskList). Every machine takes each kind of medium the same way,
       # except that the VIC-20 (Vic20Media) has cartridges, programs and a
-      # disk autostart of its own, and takes no .sid tunes. The C128 in C64
-      # mode takes a C64's.
+      # disk autostart of its own, and takes no .sid tunes, and the 264
+      # series loads programs at the start of its BASIC (Program), takes
+      # .crt cartridges and raw .bin ROM images in its two cartridges'
+      # slots (Plus4Media), and no .sid tunes either. The
+      # C128 in C64 mode takes a C64's.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        if computer.family == :vic20 && Vic20Media::UNSUPPORTED.include?(File.extname(path).downcase)
-          raise ArgumentError, "#{path} doesn't go in a VIC-20"
-        end
+        refuse_unsupported(computer, path)
 
         BootDisk.attach(computer, path, **) || attach_kind(computer, path, autostart:, subtune:, **)
       end
@@ -89,10 +91,12 @@ module Badline
       # What the medium at `path` is to `computer`, which attach goes by:
       # :true_drive for a disk that goes in a true drive (TrueDrive),
       # :directory, :storage for a disk image or a .t64 that the traps
-      # mount, and otherwise its kind by its extension (Extensions).
+      # mount, :cartridge for a raw ROM image on the 264 series
+      # (Plus4Media), and otherwise its kind by its extension (Extensions).
       def kind(computer, path)
         return :true_drive if TrueDrive.takes?(computer, path)
         return :directory if File.directory?(path)
+        return :cartridge if computer.family == :plus4 && Plus4Media.rom_image?(path)
 
         kind = Extensions.kind(path)
         %i[disk archive].include?(kind) ? :storage : kind
@@ -116,6 +120,16 @@ module Badline
 
       private
 
+      # The VIC-20 and the 264 series have no SID to play a .sid tune on.
+      def refuse_unsupported(computer, path)
+        return unless Vic20Media::UNSUPPORTED.include?(File.extname(path).downcase)
+
+        case computer.family
+        when :vic20 then raise ArgumentError, "#{path} doesn't go in a VIC-20"
+        when :plus4 then raise ArgumentError, "#{path} doesn't go in a Plus/4"
+        end
+      end
+
       def attach_kind(computer, path, autostart:, subtune:, **options)
         disk = options.fetch(:disk, {})
         case kind(computer, path)
@@ -151,25 +165,32 @@ module Badline
         computer.family == :vic20 ? Vic20Media.disk_autostart(yield) : AUTOSTART
       end
 
-      # A VIC-20 cartridge is its ROM chips.
+      # A VIC-20 or 264 series cartridge is its ROM chips. On the 264, the
+      # options' `slot` names the slot a raw ROM image goes in
+      # (Plus4Media.cartridge_chips).
       def attach_cartridge(computer, path, options)
-        if computer.family == :vic20
-          computer.attach_cartridge(Storage::CRTFile.new(path, machine: :vic20).chips)
+        case computer.family
+        when :vic20 then computer.attach_cartridge(Storage::CRTFile.new(path, machine: :vic20).chips)
+        when :plus4 then computer.attach_cartridge(Plus4Media.cartridge_chips(path, slot: options.fetch(:slot, nil)))
         else
           computer.attach_cartridge(C64::Cartridge.from_file(path, **options))
         end
         "Attached cartridge #{path}"
       end
 
-      # A VIC-20 says when the tape was made for another machine
-      # (Vic20Media.tape_message).
+      # A VIC-20 or a 264 says when the tape was made for another machine
+      # (Vic20Media.tape_message, Plus4Media.tape_message).
       def attach_tape(computer, path, autostart:)
         tape = Storage::TAP.new(path)
         computer.datasette.insert(tape)
         computer.datasette.play!
         computer.type_text(TAPE_AUTOSTART) if autostart
         message = "Inserted #{path} in the datasette"
-        computer.family == :vic20 ? Vic20Media.tape_message(tape, message) : message
+        case computer.family
+        when :vic20 then Vic20Media.tape_message(tape, message)
+        when :plus4 then Plus4Media.tape_message(tape, message)
+        else message
+        end
       end
 
       # A VIC-20 has programs of its own (Vic20Media.attach_program).

data/lib/badline/options/family.rb

@@ -30,6 +30,7 @@ module Badline
         case @family
         when :vic20 then VIC20_MODELS
         when :c128 then C128_MODELS
+        when :plus4 then PLUS4_MODELS
         else MODELS
         end
       end

data/lib/badline/options/help.rb

@@ -16,6 +16,16 @@ module Badline
       filter cycle by cycle, which is exact but takes about twice as long.
     TEXT
 
+    # The article for +name+: "an" where it starts with a vowel sound. A
+    # name of letters with a vowel among them is read as a word, and any
+    # other letter by letter, so .sid and .tap take "a", and .m3u and .lnx
+    # "an".
+    def self.article(name)
+      word = name.delete_prefix(".").downcase
+      vowels = word.match?(/\A[a-z]*[aeiou][a-z]*\z/) ? "aeiou" : "aefhilmnorsx8"
+      vowels.include?(word[0]) ? "an" : "a"
+    end
+
     # What --help prints: the usage, then the options this build takes,
     # section by section, laid out as OptionParser did.
     def help
@@ -38,14 +48,19 @@ module Badline
     # The media the window opens, by their extensions (Media::Extensions),
     # wrapped as the banner is.
     def media_kinds
-      text = "Media can be a #{Media::Extensions::PROGRAMS.join('/')} program, a #{listed(%i[disk])} disk image, " \
-             "a #{listed(%i[gcr])} disk image for a true drive, an #{listed(%i[disk_list])} list of disk images, " \
-             "a #{listed(%i[archive])} tape archive, a #{listed(%i[tape])} tape, a #{listed(%i[cartridge])} " \
-             "cartridge, a #{listed(%i[tune])} tune, a .vsf snapshot, or a directory to mount as device 8."
+      text = "Media can be #{listed(Media::Extensions::PROGRAMS)} program, #{listed(%i[disk])} disk image, " \
+             "#{listed(%i[gcr])} disk image for a true drive, #{listed(%i[disk_list])} list of disk images, " \
+             "#{listed(%i[archive])} tape archive, #{listed(%i[tape])} tape, #{listed(%i[cartridge])} " \
+             "cartridge, #{listed(%i[tune])} tune, #{listed(%w[.vsf])} snapshot, or a directory to mount as device 8."
       wrap(text)
     end
 
-    def listed(kinds) = Media::Extensions.of(kinds).join("/")
+    # The extensions of the kinds, or the extensions themselves, after the
+    # article the first takes.
+    def listed(kinds)
+      extensions = kinds.first.is_a?(Symbol) ? Media::Extensions.of(kinds) : kinds
+      "#{Options.article(extensions.first)} #{extensions.join('/')}"
+    end
 
     # The words of `text` in lines of at most 70 characters.
     def wrap(text)
@@ -68,6 +83,7 @@ module Badline
         Usage: #{@program} [c64] [options] [media]
                #{@program} vic20 [options] [media]
                #{@program} c128 [options] [media]
+               #{@program} plus4 [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
@@ -76,6 +92,7 @@ module Badline
             c64                              Run a C64, the one --model names (the default)
             vic20                            Run a PAL VIC-20, with the RAM --ram names
             c128                             Run a C128 in C128 mode, the one --model names
+            plus4                            Run a Plus/4 or a C16, the one --model names
             sid                              Play .sid tunes and directories of them
 
         #{media_kinds}
@@ -91,6 +108,12 @@ module Badline
         tune opens in the SID player, as `sid` plays it, unless an option
         of the emulator's window asks for the machine.
 
+        The Plus/4 and the C16 take programs, disks, tapes, and cartridges as
+        .crt files or raw .bin ROM images. A .bin goes in cartridge 1, its
+        low slot for up to 16K and both slots for 32K, and --c1lo, --c1hi,
+        --c2lo and --c2hi put one in the slot they name. There Escape is ESC,
+        Page Down RUN/STOP and F4 HELP.
+
         --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
         container follows the file's extension, .wav or .aiff. Played on a
@@ -111,7 +134,8 @@ module Badline
         --at and --script run events once a number of frames has run, as
         in --at 3500:key=space or --at 250,500:screenshot=shot%05d.bmp.
         key=NAME presses a key (space, return, a, f1, run_stop, restore, and
-        on the C128 esc, help, keypad1 and the rest) or a joystick's
+        on the C128 esc, help, keypad1 and the rest, and on the Plus/4
+        esc, help and f1 to f3) or a joystick's
         direction or fire (joy1-up, joy2-fire) for #{Event::HOLD} frames, and
         pushes the C128's caps_lock or forty_eighty, which lock. type=TEXT
         types it, with \\n for RETURN. insert=FILE swaps in a disk, a list's

data/lib/badline/options/table.rb

@@ -14,6 +14,10 @@ module Badline
     # The C128's models, as C128::Model names them.
     C128_MODELS = %w[c128 c128ntsc c128dcr c128dcrntsc].freeze
 
+    # The 264 series' models, as Plus4::Model names them, with the C116 as
+    # another name for the C16.
+    PLUS4_MODELS = %w[plus4 plus4ntsc c16 c16ntsc c116].freeze
+
     # The VIC-20 RAM expansions --ram takes, in the order the help lists
     # them.
     RAM_NAMES = %w[unexpanded 3k 8k 16k 24k 32k all].freeze
@@ -40,12 +44,21 @@ module Badline
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),
       Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal; " \
-                                 "C128: #{C128_MODELS.join(', ')}",
+                                 "C128: #{C128_MODELS.join(', ')}; Plus/4: #{PLUS4_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",
                  section: "Window options", needs: :window),
-      Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded)",
+      Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded); " \
+                               "Plus/4 RAM: 16k, 32k or 64k (default: the model's own)",
+                 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)",
+                 section: "Window options", needs: :window),
+      Option.new("--c2lo FILE", "Put a .bin ROM image in cartridge 2's low slot ($8000)",
+                 section: "Window options", needs: :window),
+      Option.new("--c2hi FILE", "Put a .bin ROM image in cartridge 2's high slot ($C000)",
                  section: "Window options", needs: :window),
       Option.new("--no-vsync", "Pace frames by the timer or the sound instead of the display",
                  section: "Window options", needs: :window),

data/lib/badline/options/validation.rb

@@ -21,6 +21,12 @@ module Badline
         RAM_CONFIGURATIONS[value]
       end
 
+      def plus4_ram(value)
+        raise Error, "invalid argument: --ram #{value}" unless PLUS4_RAM.key?(value)
+
+        PLUS4_RAM[value]
+      end
+
       def reu_size(value)
         raise Error, "invalid argument: --reu #{value}" unless REU_SIZES.include?(value)
 
@@ -59,12 +65,15 @@ module Badline
       end
 
       def validate_family
-        raise Error, "the Plus/4 isn't emulated yet" if @family == :plus4
-
         if @family == :vic20
           validate_vic20
         elsif !@ram.nil?
-          raise Error, "--ram needs vic20"
+          raise Error, "--ram needs vic20 or plus4"
+        end
+        if @family == :plus4
+          validate_plus4
+        elsif !@cartridges.empty?
+          raise Error, "--#{@cartridges.keys.first} needs plus4"
         end
         if @family == :c128
           validate_c128
@@ -91,6 +100,19 @@ module Badline
         raise Error, "the VIC-20 needs the window" if headless?
       end
 
+      # The Plus/4 runs in the window, without the C64's SID and REU, its
+      # NTSC models have names of their own, and its cartridge slots take
+      # raw ROM images.
+      def validate_plus4
+        raise Error, "--ntsc needs the C64; the NTSC Plus/4 is --model plus4ntsc" 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 Plus/4 needs the window" if headless?
+
+        image = @cartridges.values.find { |path| !File.extname(path).casecmp?(".bin") }
+        raise Error, "not a .bin ROM image: #{image}" unless image.nil?
+      end
+
       # `sid` takes directories as well as tunes.
       def validate_tune(path)
         return if !File.exist?(path) || File.extname(path).casecmp?(".sid")
@@ -120,7 +142,7 @@ module Badline
       end
 
       def validate_paths
-        missing = tune_paths.find { |path| !File.exist?(path) }
+        missing = (tune_paths + @cartridges.values).find { |path| !File.exist?(path) }
         raise Error, "no such file or directory: #{missing}" unless missing.nil?
         raise Error, "no such file or directory: #{@songlengths}" unless @songlengths.nil? || File.exist?(@songlengths)
       end

data/lib/badline/options.rb

@@ -12,9 +12,9 @@ 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` or `c128`, given first, names the machine family, and
-  # without one the family is the C64, or the C128 for a program that loads
-  # where C128 BASIC starts. `plus4` is refused until the Plus/4 runs. The native build adds --no-sound and
+  # `c64`, `vic20`, `c128` or `plus4`, given first, names the machine
+  # family, and without one the family is the C64, or the C128 for a program
+  # that loads where C128 BASIC starts. The native build adds --no-sound and
   # --version, and badline-ruby adds --disable-jit.
   #
   # TABLE lists the options, and both the parser and the help read it. It
@@ -48,6 +48,13 @@ module Badline
       "32k" => :"32k", "all" => :all
     }.freeze
 
+    # The Plus/4's RAM sizes as --ram names them, in K.
+    PLUS4_RAM = { "16k" => 16, "32k" => 32, "64k" => 64 }.freeze
+
+    # The Plus/4's cartridge slots, by the options that fill them and
+    # xplus4's names (Media::Plus4Media::SLOTS).
+    CARTRIDGE_SLOTS = { "--c1lo" => "c1lo", "--c1hi" => "c1hi", "--c2lo" => "c2lo", "--c2hi" => "c2hi" }.freeze
+
     # A Float as OptionParser took one: digits with an optional sign,
     # fraction and exponent.
     DECIMAL = /\A[-+]?(\d+(\.\d+)?|\.\d+)([eE][-+]?\d+)?\z/
@@ -57,14 +64,22 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
-    # The machine family to build (Badline::Machine), :c64, :vic20 or
-    # :c128.
+    # The machine family to build (Badline::Machine), :c64, :vic20, :c128
+    # or :plus4.
     attr_reader :family
 
     # The VIC-20's RAM expansion --ram names, a key of
     # Vic20::Bus::RAM_CONFIGURATIONS, or nil without --ram.
     attr_reader :ram
 
+    # The Plus/4's RAM in K --ram names, one of PLUS4_RAM's, or nil without
+    # --ram.
+    attr_reader :ram_kb
+
+    # The Plus/4's cartridge ROM images --c1lo, --c1hi, --c2lo and --c2hi
+    # name, by slot: { "c1lo" => path }.
+    attr_reader :cartridges
+
     def self.parse(argv, native: false) = new(native:).parse(argv)
 
     # The native build plays the SID in the window unless --no-sound says
@@ -84,6 +99,8 @@ module Badline
       @models = []
       @reu = nil
       @ram = nil
+      @ram_kb = nil
+      @cartridges = {}
       @autostart = true
       @writable = false
       @sound = native
@@ -178,8 +195,8 @@ module Badline
     def jit? = @jit
 
     # The name of the model to build: a C64 Badline::Model names, a VIC-20
-    # of VIC20_MODELS or a C128 of C128_MODELS. --ntsc is short for --model
-    # ntsc.
+    # of VIC20_MODELS, a C128 of C128_MODELS or a Plus/4 of PLUS4_MODELS.
+    # --ntsc is short for --model ntsc.
     def model = @models.first || family_models.first
 
     # Whether --c64 asks the C128 to start in C64 mode, holding C= at
@@ -201,7 +218,8 @@ 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 || @family == :vic20 || headless? || !@window_only.empty? || @media_path.nil?
+      return if @sid_command || %i[vic20 plus4].include?(@family) || headless? || !@window_only.empty?
+      return if @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
     end
@@ -254,7 +272,8 @@ module Badline
       when "--sid" then @sid_model = sid_model_for(value)
       when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
-      when "--ram" then @ram = ram_configuration(value)
+      when "--ram" then ram_option(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
       when "--save-snapshot" then @save_snapshot = value
@@ -267,6 +286,15 @@ module Badline
       end
     end
 
+    # --ram names the VIC-20's RAM expansion, or the Plus/4's RAM.
+    def ram_option(value)
+      if @family == :plus4
+        @ram_kb = plus4_ram(value)
+      else
+        @ram = ram_configuration(value)
+      end
+    end
+
     def switch(name)
       case name
       when "--no-autostart" then @autostart = false

data/lib/badline/plus4/bus.rb

@@ -28,6 +28,13 @@ module Badline
     # RAM smaller than 64K repeats through the 64K, as the C16's 16K does
     # without A14 and A15. Where nothing answers, a read finds the last byte
     # on the bus.
+    #
+    # The TED fetches through the same banks: the video matrix and the
+    # attributes from ROM or RAM at $8000-$FFFF as the CPU sees it, with no
+    # I/O in the way (#ted_fetch), and character and bitmap data from RAM,
+    # or from ROM with $FF12 bit 2 set, where below $8000 and in an empty
+    # bank it finds the last byte on the bus (#ted_pattern_fetch, Plus/4
+    # openmem). Each byte it fetches is left on the bus.
     class Bus
       include Addressable
 
@@ -75,12 +82,14 @@ module Badline
 
       # Page $FD: the ACIA, the user port, the keyboard port and the ROM
       # bank latch, by the address's bits 4-7. +acia+ and +user_port+ are
-      # nil where the machine has none.
+      # nil where the machine has none, and +cassette_sense+ answers in the
+      # user port's place on a machine without one (CassetteSense).
       class IOPage
-        def initialize(keyboard_port:, acia: nil, user_port: nil)
+        def initialize(keyboard_port:, acia: nil, user_port: nil, cassette_sense: nil)
           @bus = nil
           @acia = acia
           @user_port = user_port
+          @cassette_sense = cassette_sense
           @keyboard_port = keyboard_port
         end
 
@@ -93,7 +102,7 @@ module Badline
         def peek(addr)
           case addr & 0xf0
           when 0x00 then @acia ? @acia.peek(addr) : @bus.data
-          when 0x10 then @user_port ? @user_port.peek(addr) : @bus.data
+          when 0x10 then user_port_peek(addr)
           when 0x30 then @keyboard_port.peek(addr)
           else @bus.data
           end
@@ -107,6 +116,15 @@ module Badline
           when 0xd0 then @bus.select_banks(addr)
           end
         end
+
+        private
+
+        def user_port_peek(addr)
+          return @user_port.peek(addr) if @user_port
+          return @cassette_sense.read(@bus.data) if @cassette_sense
+
+          @bus.data
+        end
       end
 
       # VICE's debug cartridge register at $FDCF, a spot in the I/O page
@@ -211,6 +229,8 @@ module Badline
         @data = 0
         @read_pages = Array.new(256, @open_bus)
         @write_pages = Array.new(256, @ram_view)
+        @ted_pages = Array.new(256, @ram_view)
+        @ted_rom_pages = Array.new(256, @open_bus)
         @low_bank = @high_bank = 0
         @rom_selected = true
         @top_memory = @ram_view
@@ -259,21 +279,45 @@ module Badline
         map_reads
       end
 
-      # Puts a cartridge's ROM chips in the slots of cartridge 1: a chip at
-      # $8000 in low bank 2 and one at $C000 in high bank 2, each repeated
-      # through the bank's 16K.
+      # Puts a cartridge's ROM chips in their slots, as a PLUS4 CARTRIDGE
+      # .crt numbers them: a chip's bank picks cartridge 1 (0) or 2 (1), in
+      # ROM banks 2 and 3, and its address the low ($8000) or the high
+      # ($C000) slot. A chip shorter than 16K repeats through the slot.
+      # Slots the chips don't name keep what they held.
       def attach_cartridge(chips)
         chips.each do |chip|
-          data = chip.data * (0x4000 / chip.data.length)
+          raise ArgumentError, "no Plus/4 cartridge slot in bank #{chip.bank}" unless chip.bank.between?(0, 1)
+
+          rom = chip.data
+          length = rom.length
+          data = Array.new(0x4000) { |i| length.zero? ? 0xff : rom[i % length] }
           if chip.address < 0xc000
-            @low_roms[2] = ROM.new(data, length: 0x4000, start: 0x8000)
+            @low_roms[2 + chip.bank] = ROM.new(data, length: 0x4000, start: 0x8000)
           else
-            @high_roms[2] = ROM.new(data, length: 0x4000, start: 0xc000)
+            @high_roms[2 + chip.bank] = ROM.new(data, length: 0x4000, start: 0xc000)
           end
         end
         map_reads
       end
 
+      # Empties both cartridges' slots, ROM banks 2 and 3, which then read
+      # as the open bus.
+      def detach_cartridges
+        @low_roms[2] = @low_roms[3] = @high_roms[2] = @high_roms[3] = nil
+        map_reads
+      end
+
+      # The slots that hold a cartridge's ROM, by xplus4's names: c1lo,
+      # c1hi, c2lo and c2hi.
+      def cartridge_slots
+        slots = []
+        slots << "c1lo" unless @low_roms[2].nil?
+        slots << "c1hi" unless @high_roms[2].nil?
+        slots << "c2lo" unless @low_roms[3].nil?
+        slots << "c2hi" unless @high_roms[3].nil?
+        slots
+      end
+
       def peek(addr)
         @data = @read_pages[addr >> 8].peek(addr)
       end
@@ -283,6 +327,16 @@ module Badline
         @write_pages[addr >> 8].poke(addr, value)
       end
 
+      # A TED fetch of the video matrix or the attributes.
+      def ted_fetch(addr)
+        @data = @ted_pages[addr >> 8].peek(addr)
+      end
+
+      # A TED fetch of character or bitmap data, from ROM when +rom+.
+      def ted_pattern_fetch(addr, rom)
+        @data = rom ? @ted_rom_pages[addr >> 8].peek(addr) : @ram_view.peek(addr)
+      end
+
       private
 
       def map_writes
@@ -295,17 +349,26 @@ module Badline
       def map_reads
         @read_pages.fill(@ram_view, 0x00, 0xfd)
         @read_pages[0x00] = @zero_page
-        map_roms if @rom_selected
+        map_roms(@read_pages) if @rom_selected
         @top_memory = @rom_selected ? @high_roms[@high_bank] || @open_bus : @ram_view
         @read_pages[0xfd] = @io_page
         @read_pages[0xfe] = @tcbm_page
         @read_pages[0xff] = @top_page
+        map_ted_reads
+      end
+
+      def map_ted_reads
+        @ted_pages.fill(@ram_view, 0x80, 0x80)
+        map_roms(@ted_pages) if @rom_selected
+        map_roms(@ted_rom_pages)
+        @ted_pages.fill(@high_roms[@high_bank] || @open_bus, 0xfd, 3) if @rom_selected
+        @ted_rom_pages.fill(@high_roms[@high_bank] || @open_bus, 0xfd, 3)
       end
 
-      def map_roms
-        @read_pages.fill(@low_roms[@low_bank] || @open_bus, 0x80, 0x40)
-        @read_pages.fill(@high_roms[@high_bank] || @open_bus, 0xc0, 0x3c)
-        @read_pages[0xfc] = @high_roms[0]
+      def map_roms(pages)
+        pages.fill(@low_roms[@low_bank] || @open_bus, 0x80, 0x40)
+        pages.fill(@high_roms[@high_bank] || @open_bus, 0xc0, 0x3c)
+        pages[0xfc] = @high_roms[0]
       end
     end
   end

data/lib/badline/plus4/cassette_sense.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Badline
+  class Plus4
+    # The C16's and C116's cassette sense, which has no 6529 to go through:
+    # a read of $FD10-$FD1F enables a 74LS125 that drives the sense line
+    # onto data bit 2, low while a key is down on the deck (C16 schematic
+    # 251788, sheet 1, U11). Nothing drives the other bits, which keep the
+    # last byte on the bus, and a write goes nowhere.
+    class CassetteSense
+      TAPE_SENSE = 0x04
+
+      def initialize(datasette)
+        @datasette = datasette
+      end
+
+      # The byte a read finds, from +data+, the last byte on the bus.
+      def read(data) = @datasette.sense_low? ? data & ~TAPE_SENSE : data | TAPE_SENSE
+    end
+  end
+end