badline 0.13.0 → 0.15.0

data/lib/badline/machine.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 require "badline/machine/clocking"
+require "badline/machine/keyboard_buffer"
+require "badline/machine/settling"
 
 module Badline
   # = Machine
   #
   # The machines badline builds by family, as the command line's
   # subcommand names them: the C64, Badline::C64, the VIC-20, Vic20, and the
-  # C128 in C64 mode, C128.
+  # C128 in C64 mode, C128, and the 264 series, Plus4.
   #
   # A machine answers what the front end, Media, the runners and the
   # snapshots call on it:
@@ -47,21 +49,31 @@ module Badline
   # +release_display_key+, and +attach_drive1571+ and +drive1571+ for the
   # C128D's 1571, its true drive.
   #
+  # The Plus/4 answers the identity, clocking, lifecycle, video, sound and
+  # input parts, with nil for +control_ports+ and no RESTORE, and of the
+  # rest +ram+, +load_prg+, +type_text+, +mount+, +unmount+, +mounted?+,
+  # +datasette+, +attach_cartridge+, +attach_drive1541+, +drive1541+,
+  # +true_drive+, +plug_true_drive+, the 1581's, +install_debug_register+
+  # and +capture_output+, and besides +model_label+, +cartridge_slots+ and
+  # +detach_cartridges+ for its two cartridges.
+  #
   # Each machine includes Machine::Clocking for the clocking part.
   module Machine
     # Media the machine named doesn't take.
     class Unsupported < ArgumentError; end
 
-    # A new machine of `family`, :c64, :vic20 or :c128, the model of it
-    # `model` names. A C64's model is one of Model::ALL, with its SID
+    # A new machine of `family`, :c64, :vic20, :c128 or :plus4, the model
+    # of it `model` names. A C64's model is one of Model::ALL, with its SID
     # `sid_model` when not nil and an REU of `reu` K when not nil. A
     # VIC-20's is "pal", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
     # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
-    # for C64 mode.
+    # for C64 mode. A Plus/4's is one of Plus4::Model::ALL or c116, with
+    # the model's own RAM.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
       return c128(model, sid_model, :c64) if family == :c128
+      return Plus4.new(model:) if family == :plus4
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -77,10 +89,11 @@ module Badline
     # only C64 mode runs: a .sid tune or a program that loads at the C64's
     # BASIC start. A VIC-20 without RAM named gets the expansion the media
     # needs (Media::Vic20Media.ram_for) and yields a line saying so. Raises
-    # Unsupported for media a VIC-20 doesn't take.
+    # Unsupported for media a VIC-20 or a Plus/4 doesn't take.
     def self.for_options(options, media, &)
       family = options.family
       return vic20_for(media, options.model, options.ram, &) if family == :vic20
+      return plus4_for(media, options.model, options.ram_kb) if family == :plus4
 
       sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
       return build(:c64, model: options.model, sid_model:, reu: options.reu) unless family == :c128
@@ -114,12 +127,22 @@ module Badline
     end
     private_class_method :vic20_for
 
+    # A Plus/4 with `ram_kb` K of RAM (Plus4::Model::RAM_SIZES), or with
+    # the model's own when nil.
+    def self.plus4_for(media, model, ram_kb)
+      unsupported = !media.nil? && Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+      raise Unsupported, "doesn't go in a Plus/4" if unsupported
+
+      Plus4.new(model:, ram: ram_kb)
+    end
+    private_class_method :plus4_for
+
     def self.c64_media?(media)
       return false if media.nil? || !File.file?(media)
 
       extension = File.extname(media).downcase
       return true if extension == ".sid"
-      return false unless %w[.prg .p00].include?(extension)
+      return false unless Media::Extensions::PROGRAMS.include?(extension)
 
       [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
     end

data/lib/badline/media/boot_disk.rb

@@ -4,7 +4,8 @@ module Badline
   module Media
     # A C128 boot disk. At power-on the C128 KERNAL reads track 1, sector 0
     # of the disk in device 8 and runs it when it starts with "CBM", as boot
-    # games have it. The 1581's DOS first loads and runs a USR file named
+    # games have it, from a sector image or from the raw GCR of a .g64 or
+    # .g71. The 1581's DOS first loads and runs a USR file named
     # COPYRIGHT CBM 86 when the disk has one, which is how CP/M's 1581 disks
     # hand the KERNAL their boot sector, so a .d81 with that file boots too.
     #
@@ -15,7 +16,7 @@ module Badline
     module BootDisk
       SIGNATURE = "CBM".bytes.freeze
       AUTO_BOOT = "copyright cbm 86"
-      TYPES = Extensions.of(%i[disk])
+      TYPES = Extensions.of(%i[disk gcr])
 
       class << self
         def takes?(computer, path)
@@ -37,6 +38,7 @@ module Badline
         def boot?(path)
           type = File.extname(path).downcase
           return false unless TYPES.include?(type) && File.file?(path)
+          return gcr_signature(path) == SIGNATURE if Extensions.kind(path) == :gcr
 
           image = Media.open_storage(path, { read_only: true })
           block = image.read_block(1, 0)
@@ -44,6 +46,16 @@ module Badline
 
           type == ".d81" && !image.read_file(AUTO_BOOT, type: :usr).nil?
         end
+
+        private
+
+        # The first three bytes of track 1, sector 0 as the drive reads them
+        # off the GCR of a .g64 or .g71, or nil when the sector isn't there.
+        def gcr_signature(path)
+          track = Drives::Model1541::Disk.open(path, read_only: true).track(2)
+          data = track && Drives::Model1541::SectorReader.read(track.bytes, 1)[0]&.data
+          data && data[1, 3]
+        end
       end
     end
   end

data/lib/badline/media/extensions.rb

@@ -28,6 +28,16 @@ module Badline
 
       # What goes in device 8 through the traps.
       MOUNTABLE = of(%i[disk archive])
+
+      # What goes in device 8, a true drive's or the traps', and the lists
+      # of disks to put there.
+      DEVICE8 = of(%i[disk gcr archive disk_list])
+
+      # Programs, which load on their own.
+      PROGRAMS = %w[.prg .p00].freeze
+
+      # Every medium Media.attach takes by its extension.
+      ALL = (KINDS.keys + PROGRAMS).freeze
     end
   end
 end

data/lib/badline/media/plus4_media.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What the 264 series does with media of its own (Media.attach). A
+    # cartridge is a PLUS4 CARTRIDGE .crt, or a raw ROM image (.bin) that
+    # goes in the slot it's given, or by its size in cartridge 1's.
+    module Plus4Media
+      # The platform byte of a C16 or Plus/4 tape (Storage::TAP#platform).
+      TAPE_PLATFORM = 2
+
+      # The extension of a raw cartridge ROM image.
+      ROM_IMAGE = ".bin"
+
+      # The cartridge slots by xplus4's names, each as the bank and address
+      # a .crt's CHIP packet gives it (Plus4::Bus#attach_cartridge).
+      SLOTS = { "c1lo" => [0, 0x8000], "c1hi" => [0, 0xc000], "c2lo" => [1, 0x8000], "c2hi" => [1, 0xc000] }.freeze
+
+      SLOT_SIZE = 0x4000
+
+      class << self
+        # A tape made for another machine plays all the same, and says so.
+        def tape_message(tape, message)
+          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the Plus/4"
+        end
+
+        # Whether the file at `path` is a raw cartridge ROM image.
+        def rom_image?(path) = File.extname(path).downcase == ROM_IMAGE
+
+        # The ROM chips, as Storage::CRTFile::Chips, of the cartridge at
+        # `path`: a .crt's, or a raw image's (#rom_chips).
+        def cartridge_chips(path, slot: nil)
+          return rom_chips(File.binread(path).bytes, slot:) if rom_image?(path)
+
+          Storage::CRTFile.new(path, machine: :plus4).chips
+        end
+
+        # A raw ROM image's chips: one in `slot`, one of SLOTS, when it's
+        # named. Otherwise up to 16K goes in cartridge 1's low slot, and
+        # up to 32K fills its high slot too.
+        def rom_chips(bytes, slot: nil)
+          return [slot_chip(bytes, slot)] if slot
+
+          size = bytes.length
+          unless size.between?(1, 2 * SLOT_SIZE)
+            raise Machine::Unsupported, "a #{size}-byte image is no Plus/4 cartridge"
+          end
+
+          chips = [chip(0, 0x8000, bytes[0, SLOT_SIZE])]
+          chips << chip(0, 0xc000, bytes[SLOT_SIZE..]) if size > SLOT_SIZE
+          chips
+        end
+
+        private
+
+        def slot_chip(bytes, slot)
+          bank, address = SLOTS.fetch(slot) { raise ArgumentError, "no Plus/4 cartridge slot named #{slot}" }
+          size = bytes.length
+          raise Machine::Unsupported, "a #{size}-byte image doesn't fit a 16K slot" unless size.between?(1, SLOT_SIZE)
+
+          chip(bank, address, bytes)
+        end
+
+        def chip(bank, address, data) = Storage::CRTFile::Chip.new(chip_type: 0, bank:, address:, data:)
+      end
+    end
+  end
+end

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

@@ -29,13 +29,10 @@ module Badline
       Array(bytes).each_with_index { |b, i| poke(addr + i, b) }
     end
 
-    def save_state(out)
-      out.blob(@storage)
-    end
+    # Every byte as one record of a keyed snapshot module, under `key`.
+    def save_fields(out, key) = out.bytes(key, @storage)
 
-    def load_state(input)
-      input.blob_into(@storage)
-    end
+    def load_fields(input, key) = input.bytes_into(key, @storage)
 
     # Refills the whole memory as if newly built with `initial`
     def clear!(initial = [])

data/lib/badline/options/family.rb

@@ -12,13 +12,14 @@ module Badline
 
       private
 
-      # Takes `sid`, `c64`, `vic20` or `c128` when given first.
+      # Takes `sid`, `c64`, `vic20`, `c128` or `plus4` when given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
         when "c64" then @family = :c64
         when "vic20" then @family = :vic20
         when "c128" then @family = :c128
+        when "plus4" then @family = :plus4
         else return
         end
         @family_named = !@sid_command
@@ -29,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
@@ -37,7 +39,9 @@ module Badline
       # the C128's.
       def pick_family
         return if @family_named || @sid_command || @media_path.nil?
-        return unless %w[.prg .p00].include?(File.extname(@media_path).downcase) && File.file?(@media_path)
+
+        program = Media::Extensions::PROGRAMS.include?(File.extname(@media_path).downcase)
+        return unless program && File.file?(@media_path)
 
         @family = :c128 if Storage::P00.load_address(@media_path) == C128_BASIC_START
       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
@@ -35,11 +45,45 @@ module Badline
 
     def describe(option) = @native && option.name == "--sound" ? "#{option.text} (default)" : option.text
 
+    # The media the window opens, by their extensions (Media::Extensions),
+    # wrapped as the banner is.
+    def media_kinds
+      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
+
+    # 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)
+      lines = [""]
+      text.split.each do |word|
+        line = lines.last
+        if line.empty?
+          lines[-1] = word
+        elsif line.size + word.size < 70
+          lines[-1] = "#{line} #{word}"
+        else
+          lines << word
+        end
+      end
+      lines.join("\n")
+    end
+
     def banner
       <<~BANNER
         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...
@@ -48,13 +92,11 @@ 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 can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
-        .g64 disk image for the true 1541, an .m3u or .vfl list of disk
-        images, a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid
-        tune, a .vsf snapshot, or a directory to mount as device 8. It
-        opens in the emulator window. There F11 quicksaves the machine to
+        #{media_kinds}
+        It opens in the emulator window. There F11 quicksaves the machine to
         the next of five slots in badline's data folder, replacing the
         oldest, and F12 restores the newest quicksave or named save. The
         window also autosaves every two minutes of play, which only the
@@ -66,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
@@ -85,17 +133,19 @@ 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 C64 key (space, return, a, f1, run_stop, restore)
-        or a joystick's direction or fire (joy1-up, joy2-fire) for #{Event::HOLD}
-        frames. type=TEXT types it, with \\n for RETURN. insert=FILE swaps
-        in a disk, a list's first disk, a tape or a cartridge, and
-        eject=disk, tape or cartridge takes one out. screenshot=FILE saves
-        the frame as a .bmp, with the frame's number in place of %d. menu
-        opens the pause menu, and menu=PAGE opens it on snapshots, drive,
-        datasette, expansion, ports, sound or power. Its frames still count,
-        and resume closes it. display=vdc or display=vic shows the C128's
-        80 or 40 column screen, as F8 switches them. reset, freeze and quit
-        take no argument.
+        key=NAME presses a key (space, return, a, f1, run_stop, restore, and
+        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
+        first disk, a tape or a cartridge, and eject=disk, tape or
+        cartridge takes one out. screenshot=FILE saves the frame as a .bmp,
+        with the frame's number in place of %d. menu opens the pause menu,
+        and menu=PAGE opens it on snapshots, drive, datasette, expansion,
+        ports, sound or power. Its frames still count, and resume closes
+        it. display=vdc or display=vic shows the C128's 80 or 40 column
+        screen, as F8 switches them. reset, freeze and quit take no argument.
       BANNER
     end
 

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),
@@ -75,6 +88,8 @@ 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",
+                 section: "Testing options", needs: :window),
       Option.new("--at FRAME:EVENT", "Run EVENT once FRAME frames have run (see above)",
                  section: "Testing options", needs: :window),
       Option.new("--script FILE", "Run the events in FILE, one FRAME:EVENT a line",

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)
 
@@ -62,7 +68,12 @@ module Badline
         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
@@ -89,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")
@@ -118,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