badline 0.14.0 → 0.15.1

data/lib/badline/frontend/menu/menu_media.rb

@@ -10,17 +10,29 @@ module Badline
     # wrong for the page to show.
     class MenuMedia
       attr_reader :problem
-      attr_writer :computer
 
       # Takes the disk set from the command line's `media_path` when it's a
-      # list.
-      def initialize(media_path, writable)
+      # list, and the names of the cartridges it and `cartridges`, the
+      # Plus/4's ROM images by slot (Options#cartridges), put in the first
+      # machine.
+      def initialize(media_path, writable, cartridges)
         @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
         @set = []
         @problem = ""
         @computer = nil
+        @command_line = cartridges.map { |slot, path| [slot, path] } + [["", media_path]]
+        @names = {}
+        @named = nil
+      end
+
+      def computer=(computer)
+        @computer = computer
+        return unless @named.nil?
+
+        @command_line.each { |slot, path| note_cartridge(computer, path.dup, slot) }
+        @named = computer
       end
 
       def writable? = @writable
@@ -87,18 +99,28 @@ module Badline
         insert(:disk, set[index + step])
       end
 
+      # The extensions of the cartridges the machine takes: .crt, and on
+      # the Plus/4 raw .bin ROM images too.
+      def cartridge_extensions
+        extensions = Media::Extensions.of(%i[cartridge])
+        @computer.family == :plus4 ? extensions + [Media::Plus4Media::ROM_IMAGE] : extensions
+      end
+
       # Swaps the cartridge for the one at `path`, which power cycles the
       # machine, and says whether it went in.
       def attach_cartridge(path)
-        succeeds? { Media.attach(@computer, path) }
+        attached = cartridge_succeeds? { Media.attach(@computer, path) }
+        note_cartridge(@computer, path, "") if attached
+        attached
       end
 
       # What a save of the machine is named after: the cartridge, the disk,
       # the tape, or BASIC, without the bracketed parts of a file's name. A
-      # VIC-20's are named after its disk, or else the machine.
+      # VIC-20's are named after its disk, or else the machine, and a
+      # Plus/4's after its disk or tape.
       def game_name
         vic20 = @computer.family == :vic20
-        name = vic20 ? "" : cartridge_name
+        name = vic20 || @computer.family == :plus4 ? "" : cartridge_name
         disk = disk_path
         name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
         name = tape_name if name.empty? && !vic20
@@ -114,24 +136,36 @@ module Badline
       end
 
       # The name the cartridge in the expansion port gives itself, or an
-      # empty one.
+      # empty one. A VIC-20's or a Plus/4's is the name of the file it came
+      # from: a .crt's own, or else the file's. A Plus/4 names each of its
+      # cartridges with a ROM in, and a slot filled from elsewhere, such as
+      # a snapshot, by the slot.
       def cartridge_name
-        cartridge = @computer.address_bus.cartridge
-        cartridge.nil? ? "" : cartridge.name
+        case @computer.family
+        when :plus4 then @computer.cartridge_slots.map { |slot| slot_name(slot) }.uniq.join(", ")
+        when :vic20 then named? ? @names.fetch("", "") : ""
+        else
+          cartridge = @computer.address_bus.cartridge
+          cartridge.nil? ? "" : cartridge.name
+        end
       end
 
       # Takes the cartridge out with the power off.
-      def remove_cartridge = MediaSlots.remove_cartridge(@computer)
+      def remove_cartridge
+        @names = {}
+        MediaSlots.remove_cartridge(@computer)
+      end
 
       # A new machine started on `path`, as the command line would, or nil
       # when it won't start.
       def start(options, path)
         computer = nil
-        started = succeeds? do
-          computer = Frontend.start(options, path, @writable)
-          list(path)
+        if Media.kind(@computer, path) == :cartridge
+          cartridge_succeeds? { computer = started(options, path) }
+        else
+          succeeds? { computer = started(options, path) }
         end
-        started ? computer : nil
+        @problem.empty? ? computer : nil
       end
 
       private
@@ -143,6 +177,60 @@ module Badline
         @problem.empty?
       end
 
+      # Runs the block as #succeeds? does, keeping a cartridge's chip in a
+      # bank or slot the machine doesn't map as the problem too.
+      def cartridge_succeeds?(&)
+        @problem = Frontend.cartridge_problem(&)
+        @problem.empty?
+      end
+
+      # The machine Frontend.start started on `path`, with the names of
+      # the cartridges in it noted.
+      def started(options, path)
+        computer = Frontend.start(options, path, @writable)
+        list(path)
+        @names = {}
+        options.cartridges.each { |slot, image| note_cartridge(computer, image.dup, slot) }
+        note_cartridge(computer, path, "")
+        @named = computer
+        computer
+      end
+
+      def named? = @computer.equal?(@named)
+
+      def slot_name(slot) = named? ? @names.fetch(slot, slot.upcase) : slot.upcase
+
+      # Keeps the name of the cartridge at `path` in `computer` by the
+      # slots it fills: a Plus/4's by xplus4's names, a raw image's in
+      # `slot` if it names one, and a VIC-20's in the one slot "". Other
+      # media, and other machines' cartridges, leave the names alone.
+      def note_cartridge(computer, path, slot)
+        case computer.family
+        when :plus4
+          return unless Media.kind(computer, path) == :cartridge
+
+          name = file_name(path)
+          Media::Plus4Media.cartridge_chips(path, slot: slot.empty? ? nil : slot).each do |chip|
+            @names["c#{chip.bank + 1}#{chip.address < 0xc000 ? 'lo' : 'hi'}"] = name
+          end
+        when :vic20 then @names[""] = file_name(path) if vic20_cartridge?(path)
+        end
+      end
+
+      def vic20_cartridge?(path)
+        case Media::Extensions.kind(path)
+        when :cartridge then true
+        when :program then File.file?(path) && !Media::Vic20Cartridge.chips(path, Media.program_bytes(path)).nil?
+        else false
+        end
+      end
+
+      # A .crt's own name, or else the file's, without its extension.
+      def file_name(path)
+        name = Media::Extensions.kind(path) == :cartridge ? Storage::CRTFile.new(path, machine: nil).name : ""
+        name.empty? ? File.basename(path, File.extname(path)) : name
+      end
+
       # Keeps `path` as the list the set comes from, if it's a list.
       def list(path)
         return unless Media::DiskList.list?(path)

data/lib/badline/frontend/menu/menu_pages.rb

@@ -29,7 +29,7 @@ module Badline
         @recent = []
         @painter = painter
         @buttons = buttons
-        @media = MenuMedia.new(media_path, options.writable?)
+        @media = MenuMedia.new(media_path, options.writable?, options.cartridges)
         @reu_kb = options.reu
         @computer = nil
         @controls = nil
@@ -89,11 +89,7 @@ module Badline
 
       def vic20? = @computer.family == :vic20
 
-      # Says in the dim colour that the VIC-20 hasn't got what the page
-      # shows.
-      def note
-        @painter.text(@left, @top, "NOT ON THE VIC-20 YET", MenuTheme::DIM)
-      end
+      def plus4? = @computer.family == :plus4
 
       def draw_drive
         media = @media
@@ -126,12 +122,14 @@ module Badline
       end
 
       def draw_expansion
+        info("CARTRIDGE", @media.cartridge_name)
         return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
 
-        cartridge = @computer.address_bus.cartridge
-        info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
         row("INSERT...", :insert_cartridge)
         row("REMOVE", :remove_cartridge)
+        return if plus4?
+
+        cartridge = @computer.address_bus.cartridge
         row("FREEZE", :freeze) if !cartridge.nil? && cartridge.freezer? && @computer.family == :c64
         return if @reu_kb.nil?
 
@@ -139,7 +137,8 @@ module Badline
         info("RAM EXPANSION", "REU, #{@reu_kb} KB")
       end
 
-      # The SID's model is a setting, and other sound chips have none.
+      # The SID's model is a setting, the C64's SID's or a Plus/4's SID
+      # card's, and other sound chips have none.
       def draw_sound
         if @sound.on?
           toggle("OUTPUT", :output, [%w[ON MUTED], %i[sound_on mute], @sound.muted? ? 1 : 0])
@@ -149,7 +148,7 @@ module Badline
         model = @computer.sound_source.model
         return unless SID_MODELS.include?(model)
 
-        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
+        toggle(plus4? ? "SID CARD" : "SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
       end
 
       # Saving now and by name, loading a named save, and the quicksaves
@@ -167,9 +166,15 @@ module Badline
         end
       end
 
-      # The C128 names its model and the mode it runs in first.
+      # The C128 names its model and the mode it runs in first, and the
+      # Plus/4 its model and RAM, and its RAM expansion if it has one.
       def draw_power
         info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
+        if plus4?
+          info("MACHINE", @computer.model_label)
+          expansion = @computer.ram_expansion_label
+          info("RAM EXPANSION", expansion) if expansion
+        end
         row("RESET", :reset)
         row("POWER CYCLE", :power_cycle)
         skip

data/lib/badline/frontend/menu/menu_ports.rb

@@ -5,7 +5,7 @@ module Badline
     # The pause menu's PORTS page, which MenuPages draws: what each C64
     # control port has plugged in, a joystick or a pot device, and whether
     # the keys type or drive the joysticks. The VIC-20 has one port, a
-    # joystick's.
+    # joystick's, and the Plus/4 two joysticks and no pot devices.
     module MenuPorts
       PORT_DEVICES = %i[joystick mouse paddles].freeze
       PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
@@ -16,6 +16,7 @@ module Badline
 
       def draw_ports
         return draw_vic20_port if @computer.family == :vic20
+        return draw_plus4_ports if @computer.family == :plus4
 
         toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
         toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
@@ -37,6 +38,17 @@ module Badline
         info("WASD, LEFT SHIFT", "JOYSTICK")
       end
 
+      # The Plus/4's two joysticks, one for each set of keys.
+      def draw_plus4_ports
+        return unless draw_keys("PLUS/4")
+
+        row("SWAP JOYSTICKS", :swap)
+        skip
+        arrows = @controls.arrows_port
+        info("ARROWS, SPACE", "JOYSTICK #{arrows}")
+        info("WASD, LEFT SHIFT", "JOYSTICK #{3 - arrows}")
+      end
+
       # The toggle between the keyboard named and the joysticks, and
       # whether the keys drive the joysticks.
       def draw_keys(keyboard)

data/lib/badline/frontend/player/player_controller.rb

@@ -15,7 +15,8 @@ module Badline
     # way: #wait handles the window's clicks, keys and drops between frames
     # and redraws it at the display's pace. The SID model buttons switch
     # the chips playing on the spot, and each tune after it starts on the
-    # same choice. AUTO gives each of a tune's SIDs its own model.
+    # same choice. AUTO gives each of a tune's SIDs its own model. It
+    # quits once it has drawn `frames` frames (--frames), unless that's 0.
     class PlayerController < Audio::Terminal
       FRAME = 1.0 / 50
 
@@ -30,8 +31,10 @@ module Badline
         Keys::TAB => :view, 6 => :chip
       }.freeze
 
-      def initialize(input:, output:)
-        super
+      def initialize(input:, output:, frames: 0)
+        super(input:, output:)
+        @frame_limit = frames
+        @frames = 0
         @screen = PlayerScreen.new
         @player = nil
         @tune_file = nil
@@ -73,7 +76,10 @@ module Badline
         actions = poll
         deadline = now + seconds
         loop do
-          draw if now >= @next_draw
+          if now >= @next_draw
+            draw
+            actions << :quit if @frames == @frame_limit
+          end
           left = deadline - now
           break if left <= 0 || !actions.empty?
 
@@ -211,6 +217,7 @@ module Badline
 
       def draw
         @next_draw = now + FRAME
+        @frames += 1
         @screen.draw(@state, @player, @history, @tune_file, SIDTune::STIL::Credit.at(@credits, @state.played))
       end
 

data/lib/badline/frontend/screen.rb

@@ -4,9 +4,10 @@ module Badline
   module Frontend
     # The visible part of the video chip's display, the crop of the
     # machine's timing, repacked for an SDL texture in XRGB8888 in the
-    # chip's palette. Spinel hands an Array of Integers to C as 64-bit
-    # words, as badline/ffi does on CRuby, so each word carries two
-    # neighbouring pixels, the left one in the low half.
+    # chip's palette, of 16 colours or the TED's 128. Spinel hands an Array
+    # of Integers to C as 64-bit words, as badline/ffi does on CRuby, so
+    # each word carries two neighbouring pixels, the left one in the low
+    # half.
     #
     # Each pixel shows `pixel_width` of the window's square pixels wide,
     # or with `dots`, that many pixels share one, as the VDC's dots do. The
@@ -14,18 +15,21 @@ module Badline
     # least MIN_WIDTH window pixels wide, and at least as high as PAL's C64
     # crop, 272 lines, so a C64 shows in the same window whatever its
     # region. A crop with fewer lines or pixels sits in the middle of the
-    # texture, between black bands. The VIC-20's 284 by 284 crop fills its
-    # own.
+    # texture, between black bands. The VIC-20's 284 by 284 crop and the
+    # TED's 384 by 288 fill their own.
+    #
+    # With `frame_lines`, the crop's lines run on past the frame's last
+    # line to its first, as the TED's do: its top border is the end of
+    # the frame.
     class Screen
       MIN_WIDTH = Region::PAL.crop[2]
       MIN_HEIGHT = Region::PAL.crop[3]
 
       attr_reader :pixels, :width, :height
 
-      def initialize(video, crop, pixel_width: 1, dots: 1)
+      def initialize(video, crop, pixel_width: 1, dots: 1, frame_lines: 0)
         @video = video
         @col_offset = crop[0]
-        @row_offset = crop[1]
         @lines = crop[3]
         @columns = crop[2] & ~1
         @pixel_width = pixel_width
@@ -37,8 +41,10 @@ module Badline
         @pair_count = @columns / 2
         @margin = (@row_words - @pair_count) / 2
         @band = (@height - @lines) / 2
-        palette = video.palette
-        @pairs = Array.new(256) { |pair| palette[pair & 0x0f] | (palette[pair >> 4] << 32) }
+        top = crop[1]
+        wrap = frame_lines.zero? ? top + @lines : frame_lines
+        @sources = Array.new(@lines) { |row| (row + top) % wrap }
+        pair_up(video.palette)
         @pixels = Array.new(@height * @row_words, 0)
         pack_all
       end
@@ -54,9 +60,10 @@ module Badline
         video = @video
         dirty = video.dirty_lines
         display = video.display
+        sources = @sources
         row = 0
         while row < @lines
-          pack_row(display, row) if dirty[row + @row_offset]
+          pack_row(display, row) if dirty[sources[row]]
           row += 1
         end
         video.clear_dirty_lines!
@@ -64,6 +71,18 @@ module Badline
 
       private
 
+      # The packed word for each pair of palette indices, the left one in
+      # the low bits.
+      def pair_up(palette)
+        colors = palette.size
+        shift = 4
+        shift += 1 while (1 << shift) < colors
+        mask = colors - 1
+        @shift = shift
+        @mask = mask
+        @pairs = Array.new(colors << shift) { |pair| palette[pair & mask] | (palette[(pair >> shift) & mask] << 32) }
+      end
+
       # Repacks every line, as a screen built for a display the chip has
       # already drawn starts with all of it.
       def pack_all
@@ -78,11 +97,13 @@ module Badline
       def pack_row(display, row)
         pixels = @pixels
         pairs = @pairs
-        from = ((row + @row_offset) * @stride) + @col_offset
+        mask = @mask
+        shift = @shift
+        from = (@sources[row] * @stride) + @col_offset
         to = ((row + @band) * @row_words) + @margin
         last = to + @pair_count
         while to < last
-          pixels[to] = pairs[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
+          pixels[to] = pairs[(display[from] & mask) | ((display[from + 1] & mask) << shift)]
           from += 2
           to += 1
         end

data/lib/badline/frontend/screens.rb

@@ -70,7 +70,8 @@ module Badline
           @screen = Screen.new(vdc, vdc.crop, dots: 2)
         else
           timing = @computer.timing
-          @screen = Screen.new(@computer.video, timing.crop, pixel_width: timing.pixel_width)
+          @screen = Screen.new(@computer.video, timing.crop,
+                               pixel_width: timing.pixel_width, frame_lines: timing.lines_per_frame)
         end
       end
 

data/lib/badline/frontend/sound.rb

@@ -2,9 +2,9 @@
 
 module Badline
   module Frontend
-    # The machine's sound source, the C64's SID or the VIC-20's VIC, on
-    # SDL's audio queue, as mono signed 16-bit samples. Both take
-    # #record(rate:, clock_hz:) and #drain_samples.
+    # The machine's sound source, the C64's SID, the VIC-20's VIC or the
+    # Plus/4's TED, on SDL's audio queue, as mono signed 16-bit samples.
+    # Each takes #record(rate:, clock_hz:) and #drain_samples.
     # Once the device plays, it is the clock: #wait holds each frame until
     # the queue is down to `AHEAD`, so the machine runs at the device's pace.
     #
@@ -16,7 +16,7 @@ module Badline
     #
     # Each frame's samples go to a mono AudioDevice. The chip's cycles are
     # converted at `clock_hz`, the machine's clock, so an NTSC or Drean
-    # machine plays at its own pitch.
+    # machine plays at its own pitch, and the TED's at its single clock.
     class Sound
       RATE = 44_100
       AHEAD = 0.08

data/lib/badline/frontend/timeline.rb

@@ -38,17 +38,30 @@ module Badline
       # sound. An empty one is its first.
       def self.page?(name) = name.empty? || PauseMenu::PAGES.any? { |page| page.to_s == name }
 
+      # Whether the family's machine has a key of the name. The Plus/4 has
+      # no RESTORE.
       def self.key?(name, family)
-        name == "restore" || (family == :c128 && LOCKS.include?(name)) ||
+        (name == "restore" && family != :plus4) || (family == :c128 && LOCKS.include?(name)) ||
           !keyboard_key(name, family).nil? || !joystick_direction(name).nil?
       end
 
       # The family's Keyboard key for a name such as space, return or a,
-      # or on the C128 esc or keypad1.
+      # on the C128 esc or keypad1, or on the Plus/4 help or crsr_up. The
+      # shifted cursor keys, such as cursor_up, are the C64's and the
+      # C128's.
       def self.keyboard_key(name, family)
-        matrix = family == :c128 ? C128::KEYBOARD_MATRIX : Input::Keyboard::C64_MATRIX
-        key = matrix.flatten.find { |candidate| candidate.to_s == name }
-        key.nil? ? Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name } : key
+        key = keyboard_matrix(family).flatten.find { |candidate| candidate.to_s == name }
+        return key unless key.nil? && family != :plus4
+
+        Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name }
+      end
+
+      def self.keyboard_matrix(family)
+        case family
+        when :c128 then C128::KEYBOARD_MATRIX
+        when :plus4 then Plus4::KeyboardPort::MATRIX
+        else Input::Keyboard::C64_MATRIX
+        end
       end
 
       # The direction of joy1-NAME or joy2-NAME, such as up or fire.
@@ -215,7 +228,7 @@ module Badline
 
       def inserted?(computer, what)
         return !computer.datasette.tape.nil? if what == "tape"
-        return !computer.address_bus.cartridge.nil? if what == "cartridge"
+        return MediaSlots.cartridge?(computer) if what == "cartridge"
 
         MediaSlots.disk?(computer)
       end

data/lib/badline/machine/settling.rb

@@ -4,7 +4,7 @@ module Badline
   module Machine
     # Brings the machine to the point a snapshot file is saved at: the main
     # CPU between instructions, or jammed, with no REU transfer holding the
-    # bus. C64, Vic20 and C128 each include it, and answer
+    # bus. C64, Vic20, C128 and Plus4 each include it, and answer
     # #settled_for_snapshot? and #settle_chips_for_snapshot, which brings
     # what each chip defers up to the cycle without running one.
     module Settling

data/lib/badline/machine.rb

@@ -9,7 +9,7 @@ module Badline
   #
   # 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:
@@ -49,22 +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. :plus4 is refused until the Plus/4 runs.
+    # 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
-      raise ArgumentError, "the Plus/4 isn't emulated yet" if family == :plus4
+      return Plus4.new(model:) if family == :plus4
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -80,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) 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
@@ -117,6 +127,20 @@ module Badline
     end
     private_class_method :vic20_for
 
+    # A Plus/4 with the RAM --ram names (Plus4::Model::RAM_SIZES), or with
+    # the model's own without it, the true drive --drive-type names, the
+    # SID card --sid-card names, where --sid-card-address puts it, and the
+    # RAM expansion --ram-expansion names.
+    def self.plus4_for(media, options)
+      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: options.model, ram: options.ram_kb, true_drive_model: options.drive_type,
+                sid_card: options.sid_card, sid_card_address: options.sid_card_address || 0xfd40,
+                ram_expansion: options.ram_expansion)
+    end
+    private_class_method :plus4_for
+
     def self.c64_media?(media)
       return false if media.nil? || !File.file?(media)
 

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