badline 0.14.0 → 0.15.0

data/lib/badline/chips/tia.rb

@@ -44,6 +44,18 @@ module Badline
           @ports[register] = value
         end
       end
+
+      # The ports, their directions and what the other side drives, in a
+      # keyed snapshot module (Snapshot::Keyed, BL-TIA1 and BL-TIA2).
+      def save_fields(out)
+        out.ints("ports", @ports).ints("directions", @directions).ints("inputs", @inputs)
+      end
+
+      def load_fields(input)
+        input.ints_into("ports", @ports)
+        input.ints_into("directions", @directions)
+        input.ints_into("inputs", @inputs)
+      end
     end
   end
 end

data/lib/badline/drives/datasette/keyed_state.rb

@@ -6,11 +6,14 @@ module Badline
       # The datasette's fields in a keyed snapshot module (Snapshot::Keyed,
       # BL-TAPE): the keys, the motor, the countdown to the next pulse, and
       # a tape in it under tape.*: its path, its bytes and how far it has
-      # played. A tape that isn't in leaves tape.* out. The sense and flag
-      # handlers don't fire on load.
+      # played. A tape that isn't in leaves tape.* out. A datasette that
+      # times the read line's level adds when in the countdown the line
+      # rises, and whether a recording's low half wave is on the tape. The
+      # sense and flag handlers don't fire on load.
       module KeyedState
         def save_fields(out)
           out.bool("playing", @playing).bool("motor", @motor).int("countdown", @countdown)
+          out.int("rise_at", @rise_at).bool("low_recorded", @low_recorded) if @level
           tape = @tape
           return out unless tape
 
@@ -23,6 +26,8 @@ module Badline
           @playing = input.bool("playing", @playing)
           @motor = input.bool("motor", @motor)
           @countdown = input.int("countdown", @countdown)
+          @rise_at = input.int("rise_at", @rise_at)
+          @low_recorded = input.bool("low_recorded", @low_recorded)
           bytes = input.bytes("tape.bytes", "".b).bytes
           return @tape = nil if bytes.empty?
 

data/lib/badline/drives/datasette.rb

@@ -27,6 +27,7 @@ module Badline
         @motor = false
         @countdown = 0
         @rise_at = 0
+        @low_recorded = false
         @flag_handler = nil
         @sense_handler = nil
       end
@@ -78,6 +79,7 @@ module Badline
         press(true)
         @recording = true
         @since = 0
+        @low_recorded = false
       end
 
       def recording? = @recording
@@ -85,14 +87,21 @@ module Badline
       # The machine's tape write line. While the deck records with its motor
       # running, each rising edge ends a pulse on the tape, as long as the
       # time since the edge before, and plays back as a falling edge on the
-      # read line.
+      # read line. A datasette built with +level: true+ records a version 2
+      # tape's half waves instead: a rising edge ends the low half and a
+      # falling edge the high half after it, so the tape plays back the
+      # levels it recorded (#read_high?).
       def write_line=(high)
-        rose = high && !@write_high
+        edge = high != @write_high
         @write_high = high
-        return unless rose && @recording && running?
+        return unless edge && @recording && running?
 
-        @tape.record_pulse(@since)
-        @since = 0
+        if @level && @tape.half_waves?
+          record_half_wave(high)
+        elsif high
+          @tape.record_pulse(@since)
+          @since = 0
+        end
       end
 
       # Sets the write line's level without recording an edge, as a
@@ -153,6 +162,14 @@ module Badline
         @countdown = first + @rise_at
       end
 
+      # A high half wave goes on the tape only after the low half before it,
+      # so the tape starts with a whole pulse.
+      def record_half_wave(rose)
+        @tape.record_half_wave(@since) if rose || @low_recorded
+        @low_recorded = rose
+        @since = 0
+      end
+
       def press(down)
         return if down == @playing || !@connected
 

data/lib/badline/frontend/boot.rb

@@ -55,11 +55,13 @@ module Badline
 
     # A new machine built from the options (Machine.for_options), with
     # `media`, if not nil, attached and started as the command line does,
-    # its disk writable if `writable`. The VIC-20 raises
+    # its disk writable if `writable`, after the Plus/4's cartridges the
+    # options put in its slots. The VIC-20 and the Plus/4 raise
     # Machine::Unsupported for a .sid tune.
     def self.start(options, media, writable)
       computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
+      options.cartridges.each { |slot, path| puts Media.attach(computer, path, cartridge: { slot: }) }
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
                                            disk: { read_only: !writable })

data/lib/badline/frontend/controls.rb

@@ -117,7 +117,11 @@ module Badline
       end
 
       def host_key(scancode)
-        @computer.family == :c128 ? Keys.c128_key(scancode, @computer.mode) : Keys.c64_key(scancode)
+        case @computer.family
+        when :c128 then Keys.c128_key(scancode, @computer.mode)
+        when :plus4 then Keys.plus4_key(scancode)
+        else Keys.c64_key(scancode)
+        end
       end
 
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
@@ -196,8 +200,8 @@ module Badline
       end
 
       def release_all
-        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
-        Keys::WASD.each_key { |scancode| @computer.keyboard.release(Keys.c64_key(scancode)) }
+        Keys::ARROWS.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
+        Keys::WASD.each_key { |scancode| @computer.keyboard.release(host_key(scancode)) }
         Keys::ARROWS.each_value do |direction|
           @computer.joystick1.release(direction)
           @computer.joystick2.release(direction)

data/lib/badline/frontend/keys.rb

@@ -3,8 +3,8 @@
 module Badline
   module Frontend
     # SDL scancodes follow key positions on a US layout. They map onto the C64
-    # keys, the C128's own keys and, in joystick mode, the joystick
-    # directions.
+    # keys, the C128's and the 264's own keys and, in joystick mode, the
+    # joystick directions.
     module Keys
       RETURN = 40
       ESCAPE = 41
@@ -56,6 +56,15 @@ module Badline
         63 => :forty_eighty, 72 => :forty_eighty, 78 => :run_stop
       }.freeze
 
+      # The 264's keys where they differ from the C64's: ESC on Esc, with
+      # RUN/STOP on Page Down as on the C128, F1-F3 on F1-F3, HELP on F4,
+      # Insert or Help, a cursor key on each arrow, and either SHIFT on the
+      # one SHIFT. Page Up, RESTORE on the C64, presses nothing.
+      PLUS4_OTHERS = {
+        41 => :esc, 78 => :run_stop, 58 => :f1, 59 => :f2, 60 => :f3, 61 => :help, 73 => :help, 117 => :help,
+        79 => :crsr_right, 80 => :crsr_left, 81 => :crsr_down, 82 => :crsr_up, 229 => :lshift, 75 => :none
+      }.freeze
+
       ARROWS = { 44 => :fire, 228 => :fire, 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
       WASD = { 225 => :fire, 7 => :right, 4 => :left, 22 => :down, 26 => :up }.freeze
 
@@ -77,6 +86,9 @@ module Badline
         C128_OTHERS[scancode] || c64_key(scancode)
       end
 
+      # The 264's key for the scancode: one of PLUS4_OTHERS or the C64's.
+      def self.plus4_key(scancode) = PLUS4_OTHERS[scancode] || c64_key(scancode)
+
       # The character the key types on a US layout: a letter, a capital
       # with `shift`, or a digit, and "" for any other key.
       def self.character(scancode, shift)

data/lib/badline/frontend/media_slots.rb

@@ -31,8 +31,18 @@ module Badline
           drive.nil? ? computer.unmount : drive.insert(nil)
         end
 
-        # Takes the cartridge out with the power off.
+        # Whether the expansion port has a cartridge in, on the Plus/4 in
+        # either cartridge's slots.
+        def cartridge?(computer)
+          return !computer.cartridge_slots.empty? if computer.family == :plus4
+
+          !computer.address_bus.cartridge.nil?
+        end
+
+        # Takes the cartridge out with the power off, on the Plus/4 both.
         def remove_cartridge(computer)
+          return computer.detach_cartridges if computer.family == :plus4
+
           computer.address_bus.detach_cartridge
           computer.power_cycle!
         end

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

@@ -37,7 +37,8 @@ module Badline
       # :program, or :snapshot, which starts in the saves folder.
       def browse(kind)
         @browsing = kind
-        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, EXTENSIONS.fetch(kind))
+        extensions = kind == :cartridge ? @media.cartridge_extensions : EXTENSIONS.fetch(kind)
+        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, extensions)
       end
 
       # Asks for a save's name, starting from `name`.

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

@@ -87,6 +87,13 @@ 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)
@@ -95,10 +102,11 @@ module Badline
 
       # 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,8 +122,10 @@ module Badline
       end
 
       # The name the cartridge in the expansion port gives itself, or an
-      # empty one.
+      # empty one. A Plus/4's names the slots with a ROM in them.
       def cartridge_name
+        return @computer.cartridge_slots.map(&:upcase).join(", ") if @computer.family == :plus4
+
         cartridge = @computer.address_bus.cartridge
         cartridge.nil? ? "" : cartridge.name
       end

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

@@ -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
@@ -128,10 +124,12 @@ module Badline
       def draw_expansion
         return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
 
-        cartridge = @computer.address_bus.cartridge
-        info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
+        info("CARTRIDGE", @media.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?
 
@@ -167,9 +165,11 @@ 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.
       def draw_power
         info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
+        info("MACHINE", @computer.model_label) if plus4?
         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/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.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
@@ -117,6 +127,16 @@ 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)
 

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