badline 0.10.1 → 0.11.1

data/lib/badline/frontend/menu_pages.rb

@@ -85,6 +85,9 @@ module Badline
         end
       end
 
+      # Whether the machine is a C128, whose F8 switches its screens.
+      def c128? = @computer.family == :c128
+
       private
 
       def vic20? = @computer.family == :vic20
@@ -109,7 +112,8 @@ module Badline
         end
         toggle("WRITABLE", :writable, [%w[OFF ON], %i[protect unprotect], media.writable? ? 1 : 0])
         skip
-        info("DEVICE", @computer.drive1541.nil? ? "FAST LOADING" : "1541, TRUE DRIVE")
+        drive = @computer.true_drive
+        info("DEVICE", drive.nil? ? "FAST LOADING" : "#{drive.model_name}, TRUE DRIVE")
       end
 
       def draw_datasette
@@ -131,7 +135,7 @@ module Badline
         info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
         row("INSERT...", :insert_cartridge)
         row("REMOVE", :remove_cartridge)
-        row("FREEZE", :freeze) if !cartridge.nil? && cartridge.freezer?
+        row("FREEZE", :freeze) if !cartridge.nil? && cartridge.freezer? && @computer.family == :c64
         return if @reu_kb.nil?
 
         skip
@@ -166,7 +170,9 @@ module Badline
         end
       end
 
+      # The C128 names its model and the mode it runs in first.
       def draw_power
+        info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
         row("RESET", :reset)
         row("POWER CYCLE", :power_cycle)
         skip

data/lib/badline/frontend/menu_ports.rb

@@ -19,7 +19,7 @@ module Badline
 
         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))])
-        return unless draw_keys("C64")
+        return unless draw_keys(@computer.family == :c128 ? "C128" : "C64")
 
         row("SWAP JOYSTICKS", :swap)
         skip

data/lib/badline/frontend/pause_menu.rb

@@ -145,6 +145,7 @@ module Badline
         draw_sections
         @buttons.plain(@left + 6, @top + HEIGHT - 28, "QUICK OPEN...", :quick_open)
         painter.text(@left + 8, @top + HEIGHT - 12, "F9/ESC: RESUME", DIM)
+        painter.text(@left + BODY, @top + HEIGHT - 12, "F6: 40/80 KEY  F8: SCREEN", DIM) if @pages.c128?
         @pages.draw(PAGES[@section], @left + BODY, @top + 34)
       end
 

data/lib/badline/frontend/screen.rb

@@ -8,30 +8,44 @@ module Badline
     # words, as badline/ffi does on CRuby, so each word carries two
     # neighbouring pixels, the left one in the low half.
     #
-    # The texture is as wide as the crop 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 sits in the middle of the texture,
-    # between black bands. The VIC-20's 284 by 284 crop fills its own.
+    # 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
+    # texture is as wide as the crop, an even number of pixels, and at
+    # 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.
     class Screen
+      MIN_WIDTH = Region::PAL.crop[2]
       MIN_HEIGHT = Region::PAL.crop[3]
 
       attr_reader :pixels, :width, :height
 
-      def initialize(video, crop)
+      def initialize(video, crop, pixel_width: 1, dots: 1)
         @video = video
         @col_offset = crop[0]
         @row_offset = crop[1]
         @lines = crop[3]
-        @width = crop[2]
+        @columns = crop[2] & ~1
+        @pixel_width = pixel_width
+        @dots = dots
         @stride = video.width.to_i
+        @width = [@columns, ((MIN_WIDTH * dots / pixel_width) + 1) & ~1].max
         @height = [@lines, MIN_HEIGHT].max
         @row_words = @width / 2
+        @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) }
         @pixels = Array.new(@height * @row_words, 0)
+        pack_all
       end
 
+      # The width in the window's square pixels.
+      def window_width = @width * @pixel_width / @dots
+
       # The bytes of one row of the texture.
       def row_bytes = @width * 4
 
@@ -50,12 +64,23 @@ module Badline
 
       private
 
+      # Repacks every line, as a screen built for a display the chip has
+      # already drawn starts with all of it.
+      def pack_all
+        display = @video.display
+        row = 0
+        while row < @lines
+          pack_row(display, row)
+          row += 1
+        end
+      end
+
       def pack_row(display, row)
         pixels = @pixels
         pairs = @pairs
         from = ((row + @row_offset) * @stride) + @col_offset
-        to = (row + @band) * @row_words
-        last = to + @row_words
+        to = ((row + @band) * @row_words) + @margin
+        last = to + @pair_count
         while to < last
           pixels[to] = pairs[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
           from += 2

data/lib/badline/frontend/screens.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The Screen the window shows: the machine's video chip's, or on the
+    # C128 the VDC's, two of its dots to a window pixel, once #show_vdc
+    # switches to it. Only the chip shown renders. The VDC's display changes
+    # size with its registers, and the screen follows it.
+    #
+    # On the C128, #follow switches to the screen the machine prints to
+    # (C128#active_screen) each time it moves there, and #show_vdc's choice
+    # holds until the next move.
+    class Screens
+      # The frames a move holds before #follow takes it. The C128 KERNAL's
+      # reset clears the 80 column screen with the editor on it for over a
+      # frame.
+      FOLLOW_FRAMES = 3
+
+      attr_reader :screen
+
+      def initialize(computer)
+        @computer = computer
+        @vdc_shown = false
+        @vdc_shape = []
+        forget_screen
+        build
+      end
+
+      def vdc_shown? = @vdc_shown
+
+      # Shows another machine's video chip, once #build builds its screen.
+      def computer=(computer)
+        @computer = computer
+        @vdc_shown = false
+        forget_screen
+      end
+
+      # Shows the screen a C128 has moved its output to once the move has
+      # held for FOLLOW_FRAMES calls, one a frame. #build then builds it.
+      def follow
+        return unless @computer.family == :c128
+
+        vdc = @computer.active_screen == :vdc
+        @held = vdc == @seen ? @held + 1 : 1
+        @seen = vdc
+        return if @held < FOLLOW_FRAMES || vdc == @followed
+
+        @followed = vdc
+        show_vdc(vdc)
+      end
+
+      # Shows the C128's VDC, or with false its VIC-IIe, once #build builds
+      # its screen. Other machines have the one screen.
+      def show_vdc(shown)
+        return unless @computer.family == :c128
+
+        @vdc_shown = shown
+        @computer.vdc_shown = shown
+      end
+
+      # Whether the screen was built for the other chip, or the VDC's
+      # display has changed size or crop since the screen was built for it.
+      def stale? = @built_vdc != @vdc_shown || (@vdc_shown && vdc_shape(@computer.vdc) != @vdc_shape)
+
+      def build
+        @built_vdc = @vdc_shown
+        if @vdc_shown
+          vdc = @computer.vdc
+          @vdc_shape = vdc_shape(vdc)
+          @screen = Screen.new(vdc, vdc.crop, dots: 2)
+        else
+          timing = @computer.timing
+          @screen = Screen.new(@computer.video, timing.crop, pixel_width: timing.pixel_width)
+        end
+      end
+
+      private
+
+      # The machine's output counts as on the VIC-IIe's screen, the one
+      # shown.
+      def forget_screen
+        @followed = false
+        @seen = false
+        @held = 0
+      end
+
+      def vdc_shape(vdc) = [vdc.width, vdc.height] + vdc.crop
+    end
+  end
+end

data/lib/badline/frontend/timeline.rb

@@ -87,6 +87,17 @@ module Badline
         section
       end
 
+      # Whether the frame has a display event.
+      def display?(frame) = @events.any? { |event| event.frame == frame && event.action == "display" }
+
+      # The C128 screen the frame's display event shows, vic or vdc, or an
+      # empty string without one.
+      def display_at(frame)
+        chip = ""
+        @events.each { |event| chip = event.argument if event.frame == frame && event.action == "display" }
+        chip
+      end
+
       # Whether the pause menu closes at the frame.
       def resume?(frame) = @events.any? { |event| event.frame == frame && event.action == "resume" }
 
@@ -133,9 +144,9 @@ module Badline
         hold(event)
       end
 
-      # The VIC-20 has no cartridge with a button yet.
+      # The VIC-20 and the C128 have no cartridge with a button yet.
       def freeze(computer, event)
-        return if computer.family == :vic20
+        return unless computer.family == :c64
 
         computer.press_cartridge_button
         hold(event)
@@ -146,7 +157,7 @@ module Badline
       end
 
       def release(computer, event)
-        return computer.release_cartridge_button if event.action == "freeze"
+        return computer.release_cartridge_button if event.action == "freeze" && computer.family == :c64
 
         name = event.argument
         return computer.release_restore if name == "restore"
@@ -183,7 +194,7 @@ module Badline
       end
 
       # Whether there's one in to eject. A VIC-20 has no cartridge to take out yet.
-      def ejectable?(computer, what) = (computer.family == :c64 || what != "cartridge") && inserted?(computer, what)
+      def ejectable?(computer, what) = (computer.family != :vic20 || what != "cartridge") && inserted?(computer, what)
 
       def inserted?(computer, what)
         return !computer.datasette.tape.nil? if what == "tape"

data/lib/badline/frontend.rb

@@ -4,6 +4,7 @@ require "badline/sdl"
 require "badline/frontend/boot"
 require "badline/frontend/frame_rate"
 require "badline/frontend/screen"
+require "badline/frontend/screens"
 require "badline/frontend/drive_led"
 require "badline/frontend/keys"
 require "badline/frontend/snapshots"

data/lib/badline/iec_bus.rb

@@ -16,6 +16,14 @@ module Badline
   # also pulls DATA while ATN IN differs from its ATN acknowledge on PB4
   # (an XOR gate), which answers ATN in hardware before the DOS gets to it.
   # SerialPort reads the lines back into VIA 1.
+  #
+  # Fast serial adds SRQ, which the C64 leaves alone. A C128 and a 1571
+  # clock bytes over it from a CIA's CNT, with the bits on DATA from its
+  # SP, through buffers each side turns towards the bus to send. A pin low
+  # pulls its line low. Each side pushes the lines it pulls when they
+  # move: the host through host_fast_lines=, which tells the drives
+  # (fast_lines_moved), and a drive through drives_fast_moved!, which
+  # tells the host (on_fast_change).
   class IECBus
     # CIA 2 port A
     HOST_ATN_OUT = 0x08
@@ -29,16 +37,56 @@ module Badline
     DRIVE_CLK_OUT = 0x08
     DRIVE_ATNA = 0x10
 
-    # The lines pulled low, as ATN, CLK and DATA bits
+    # The lines pulled low, as ATN, CLK, DATA and SRQ bits
     ATN = 0x01
     CLK = 0x02
     DATA = 0x04
+    SRQ = 0x08
+
+    # A drive's serial_output bits above VIA 1's port B: its fast serial
+    # pins pulling DATA and SRQ.
+    DRIVE_FAST_DATA = 0x100
+    DRIVE_FAST_SRQ = 0x200
 
     attr_reader :drives, :host_lines
 
+    # The lines the host's fast serial pins pull, as DATA and SRQ bits.
+    attr_reader :host_fast_lines
+
     def initialize
       @drives = []
       @host_lines = 0
+      @host_fast_lines = 0
+      @drive_fast_lines = 0
+      @on_fast_change = nil
+    end
+
+    # The host's fast serial pins moved: +low+ is the lines they pull, as
+    # DATA and SRQ bits.
+    def host_fast_lines=(low)
+      return if low == @host_fast_lines
+
+      @host_fast_lines = low
+      @drives.each(&:fast_lines_moved)
+    end
+
+    # A drive's fast serial pins moved (serial_output's fast bits).
+    def drives_fast_moved!
+      low = 0
+      @drives.each do |drive|
+        output = drive.serial_output
+        low |= DATA if output.anybits?(DRIVE_FAST_DATA)
+        low |= SRQ if output.anybits?(DRIVE_FAST_SRQ)
+      end
+      return if low == @drive_fast_lines
+
+      @drive_fast_lines = low
+      @on_fast_change&.call
+    end
+
+    # Calls the block whenever the drives move their fast serial pins.
+    def on_fast_change(&block)
+      @on_fast_change = block
     end
 
     # The machine pushes the lines it pulls, as port A bits, whenever they
@@ -58,11 +106,13 @@ module Badline
     end
 
     # One pass over everything on the bus, for a reader that wants more
-    # than one line. +host+ is the C64's port A lines as the reader sees
-    # them, which a drive takes a cycle late (see Drive1541::SerialPort).
+    # than one line, SRQ included. +host+ is the C64's port A lines as the
+    # reader sees them, which a drive takes a cycle late (see
+    # Drive::SerialLines).
     def low_lines(host = @host_lines)
       atn = host.anybits?(HOST_ATN_OUT)
-      low = atn ? ATN : 0
+      low = @host_fast_lines | @drive_fast_lines
+      low |= ATN if atn
       low |= CLK if host.anybits?(HOST_CLK_OUT)
       low |= DATA if host.anybits?(HOST_DATA_OUT)
       i = 0

data/lib/badline/kernal_trap/file.rb

@@ -17,7 +17,7 @@ module Badline
       def full_filename
         pointer = uint16(@bus.peek(0xbb), @bus.peek(0xbc))
         bytes = Array.new(@bus.peek(0xb7)) do |i|
-          @bus.peek((pointer + i) & 0xffff)
+          @layout.filename_byte(@bus, (pointer + i) & 0xffff)
         end
         Storage.ascii(bytes)
       end

data/lib/badline/kernal_trap/layout.rb

@@ -18,37 +18,59 @@ module Badline
     # primitives' entry points.
     #
     # +banked+ says whether the 6510 port can bank the KERNAL out, and so
-    # whether RAM lies under every ROM and the I/O. Each
+    # whether RAM lies under every ROM and the I/O. +mmu+ says the C128's
+    # MMU maps the KERNAL instead, and that the file name and the file's
+    # bytes lie in the banks the KERNAL keeps at FNBANK and BA. Each
     # serial byte starts a one-shot timer by writing the high byte of its
     # count to +serial_timer+, and the control value TIMER_ONE_SHOT_START
     # to +serial_timer_start+ where the timer has a control register to
     # start it (a CIA's), or nil where the write to the high byte starts it
-    # (a VIA's timer 2). The ROM lets go of each serial line by reading a
+    # (a VIA's timer 2). A KERNAL that times its bytes with a loop has no
+    # +serial_timer+. The ROM lets go of each serial line by reading a
     # port, masking the line's bit off and writing it back: ATN at
     # +atn_port+ with +atn_mask+, then the clock and the data line.
     Layout = Data.define(:load, :save, :searching_message, :loading_message, :load_byte_loop, :load_done,
                          :file_not_found_exit, :missing_file_name_exit, :saving_message, :clock_release,
                          :data_release, :save_done, :talk, :listen, :second, :tksa, :ciout, :untalk,
                          :unlisten, :acptr, :banked, :serial_timer, :serial_timer_start, :atn_port, :atn_mask,
-                         :clock_port, :clock_mask, :data_port, :data_mask) do
+                         :clock_port, :clock_mask, :data_port, :data_mask, :mmu) do
       # Whether the CPU reads the KERNAL ROM at the trapped addresses: on a
-      # banked machine, the 6510 port's banking bits select it.
+      # banked machine, the 6510 port's banking bits select it, and on the
+      # C128 the MMU.
       def kernal_mapped?(bus)
+        return bus.system_rom_mapped? if mmu
+
         !banked || bus.io_port.kernal?
       end
 
       # Stores a loaded file's bytes from +address+ on: on a banked machine
-      # into the RAM under whatever is banked in, and otherwise where the
-      # ROM's byte loop would store them, through the bus.
+      # into the RAM under whatever is banked in, on the C128 into the RAM
+      # of the bank at BA, and otherwise where the ROM's byte loop would
+      # store them, through the bus.
       def store_file(bus, address, bytes)
+        return bus.write_bank(bus.peek(BANK), address, bytes) if mmu
         return bus.ram.write(address, bytes) if banked
 
         bytes.each_with_index { |byte, i| bus.poke(address + i, byte) }
       end
 
+      # The file name's byte at +address+, in the bank at FNBANK on the
+      # C128.
+      def filename_byte(bus, address)
+        mmu ? bus.peek_bank(bus.peek(FILENAME_BANK), address) : bus.peek(address)
+      end
+
+      # The byte at +address+ a SAVE writes or a VERIFY compares, in the bank
+      # at BA on the C128.
+      def file_byte(bus, address)
+        mmu ? bus.peek_bank(bus.peek(BANK), address) : bus.peek(address)
+      end
+
       # Starts the timer the ROM times a serial byte with, its count's high
       # byte +timer_high+.
       def time_serial_byte(bus, timer_high)
+        return unless serial_timer
+
         bus.poke(serial_timer, timer_high)
         start = serial_timer_start
         bus.poke(start, TIMER_ONE_SHOT_START) if start
@@ -77,6 +99,11 @@ module Badline
     # start.
     TIMER_ONE_SHOT_START = 0x19
 
+    # Where the C128 KERNAL keeps the bank a LOAD or SAVE goes to (BA) and
+    # the bank of the file name (FNBANK).
+    BANK = 0xc6
+    FILENAME_BANK = 0xc7
+
     # The C64 KERNAL, revision 3. The SX-64's, 251104-04, differs from it
     # only in bytes none of these addresses reach. It times serial bytes
     # with CIA 1's timer B, and drives the lines from CIA 2's port A
@@ -89,7 +116,8 @@ module Badline
       talk: 0xed09, listen: 0xed0c, second: 0xedb9, tksa: 0xedc7,
       ciout: 0xeddd, untalk: 0xedef, unlisten: 0xedfe, acptr: 0xee13,
       banked: true, serial_timer: 0xdc07, serial_timer_start: 0xdc0f,
-      atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf
+      atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf,
+      mmu: false
     )
 
     # The VIC-20 KERNAL, 901486-07 (PAL). The NTSC one, 901486-06, differs
@@ -106,7 +134,29 @@ module Badline
       talk: 0xee14, listen: 0xee17, second: 0xeec0, tksa: 0xeece,
       ciout: 0xeee4, untalk: 0xeef6, unlisten: 0xef04, acptr: 0xef19,
       banked: false, serial_timer: 0x9129, serial_timer_start: nil,
-      atn_port: 0x911f, atn_mask: 0x7f, clock_port: 0x912c, clock_mask: 0xfd, data_port: 0x912c, data_mask: 0xdf
+      atn_port: 0x911f, atn_mask: 0x7f, clock_port: 0x912c, clock_mask: 0xfd, data_port: 0x912c, data_mask: 0xdf,
+      mmu: false
+    )
+
+    # The C128 KERNAL, 318020-05, in C128 mode: the jump table's targets
+    # for the serial primitives, ILOAD's and ISAVE's default targets, and
+    # the ROM's own tails. Its LOAD prints SEARCHING FOR at $F50F and
+    # LOADING or VERIFYING at $F533, retries a byte at $F2CF and returns at
+    # $F39B. FILE NOT FOUND leaves through $F685 and MISSING FILE NAME
+    # through $F691. SAVE prints SAVING at $F5BC and returns at $F5B3, after
+    # the UNLISTEN whose clock and data releases are $E545 and $E557. It
+    # drives the lines from CIA 2's port A, and times serial bytes with
+    # loops, not a timer.
+    C128_LAYOUT = Layout.new(
+      load: 0xf26c, save: 0xf54e,
+      searching_message: 0xf50f, loading_message: 0xf533, load_byte_loop: 0xf2cf, load_done: 0xf39b,
+      file_not_found_exit: 0xf685, missing_file_name_exit: 0xf691,
+      saving_message: 0xf5bc, clock_release: 0xe545, data_release: 0xe557, save_done: 0xf5b3,
+      talk: 0xe33b, listen: 0xe33e, second: 0xe4d2, tksa: 0xe4e0,
+      ciout: 0xe503, untalk: 0xe515, unlisten: 0xe526, acptr: 0xe43e,
+      banked: true, serial_timer: nil, serial_timer_start: nil,
+      atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf,
+      mmu: true
     )
   end
 end

data/lib/badline/kernal_trap/load.rb

@@ -112,7 +112,7 @@ module Badline
       end
 
       def verify(addr, payload)
-        match = payload.each_with_index.all? { |byte, i| @bus.peek(addr + i) == byte }
+        match = payload.each_with_index.all? { |byte, i| @layout.file_byte(@bus, addr + i) == byte }
         @bus.poke(0x90, match ? EOI : EOI | VERIFY_MISMATCH)
       end
 

data/lib/badline/kernal_trap/save.rb

@@ -71,7 +71,7 @@ module Badline
         start = uint16(@bus.peek(0xc1), @bus.peek(0xc2))
         length = (uint16(@bus.peek(0xae), @bus.peek(0xaf)) - start) & 0xffff
         [low_byte(start), high_byte(start)] +
-          Array.new(length) { |i| @bus.peek((start + i) & 0xffff) }
+          Array.new(length) { |i| @layout.file_byte(@bus, (start + i) & 0xffff) }
       end
     end
   end

data/lib/badline/kernal_trap/serial.rb

@@ -58,6 +58,11 @@ module Badline
         self
       end
 
+      # Takes the traps out again, so the KERNAL's own routines run.
+      def uninstall
+        routines.each_key { |address| @cpu.remove_trap(address) }
+      end
+
       private
 
       def routines

data/lib/badline/machine.rb

@@ -4,7 +4,8 @@ module Badline
   # = Machine
   #
   # The machines badline builds by family, as the command line's
-  # subcommand names them: the C64, Computer, and the VIC-20, Vic20.
+  # subcommand names them: the C64, Computer, the VIC-20, Vic20, and the
+  # C128 in C64 mode, C128.
   #
   # A machine answers what the front end, Media, the runners and the
   # snapshots call on it:
@@ -23,7 +24,8 @@ module Badline
   # - Media: +ram+, +load_prg+, +type_text+, +mount+, +unmount+,
   #   +mounted?+, +datasette+, +attach_cartridge+,
   #   +press_cartridge_button+, +release_cartridge_button+,
-  #   +attach_drive1541+, +drive1541+, and +address_bus+ for its
+  #   +attach_drive1541+, +drive1541+, +true_drive+ and +plug_true_drive+
+  #   for the drive Media::TrueDrive plugs in, and +address_bus+ for its
   #   +cartridge+ and +detach_cartridge+.
   # - Snapshots and tests: +snapshot+, +restore+, +save_snapshot+,
   #   +install_debug_register+ and +capture_output+.
@@ -32,16 +34,25 @@ module Badline
   # input parts, with its one joystick as both +joystick1+ and +joystick2+
   # and nil for +control_ports+, and of the rest +ram+, +load_prg+,
   # +type_text+, +mount+, +unmount+, +mounted?+, +datasette+, +attach_cartridge+,
-  # +attach_drive1541+, +drive1541+, +install_debug_register+ and
-  # +capture_output+.
+  # +attach_drive1541+, +drive1541+, +true_drive+, +plug_true_drive+,
+  # +install_debug_register+ and +capture_output+.
+  #
+  # The C128 answers all but the cartridge button, and besides +mode+,
+  # :c64, as Machine.build builds it, or :c128, +vdc+, the VDC a front
+  # end can show in place of +video+ once +vdc_shown=+ renders it,
+  # +press_caps_lock+, +release_caps_lock+, +press_display_key+,
+  # +release_display_key+, and +attach_drive1571+ and +drive1571+ for the
+  # C128D's 1571, its true drive.
   module Machine
-    # A new machine of `family`, :c64 or :vic20, 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 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
+    # `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.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
+      return C128.new(model:, sid_model:) if family == :c128
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)