badline 0.10.1 → 0.11.0

data/lib/badline/frontend/machine_window.rb

@@ -3,10 +3,10 @@
 module Badline
   module Frontend
     # The emulator's SDL window, its renderer and the streaming texture a
-    # Screen's pixels go into. The renderer's logical size is the screen's,
-    # with each of its pixels `pixel_width` square pixels wide, so the
-    # picture keeps the machine's aspect while the menu and the drive LED
-    # draw in square pixels over it. The window opens at SCALE times that.
+    # Screen's pixels go into. The renderer's logical size is the screen's
+    # in square pixels (Screen#window_width), so the picture keeps the
+    # machine's aspect while the menu and the drive LED draw in square
+    # pixels over it. The window opens at SCALE times that.
     class MachineWindow
       SCALE = 2
       TITLE = "Badline"
@@ -18,12 +18,12 @@ module Badline
 
       # Opens the window for `screen`, presenting in step with the display
       # when `vsync`.
-      def initialize(screen, pixel_width, vsync:)
+      def initialize(screen, vsync:)
         abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
 
         SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
         SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
-        measure(screen, pixel_width)
+        measure(screen)
         @window = SDL.SDL_CreateWindow(
           TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
           SDL::WINDOW_RESIZABLE
@@ -42,9 +42,9 @@ module Badline
 
       # Fits the texture, the logical size and the window to another
       # machine's screen, unless it measures the same.
-      def fit(screen, pixel_width)
+      def fit(screen)
         before = [@width, @height, @texture_width]
-        measure(screen, pixel_width)
+        measure(screen)
         return if before == [@width, @height, @texture_width]
 
         SDL.SDL_DestroyTexture(@texture)
@@ -56,9 +56,12 @@ module Badline
         SDL.SDL_UpdateTexture(@texture, nil, screen.pixels, screen.row_bytes)
       end
 
-      # Titles the window, TITLE followed by `tags` in brackets.
-      def title(tags)
-        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |tag| "[#{tag}]" }).join(" "))
+      # Titles the window, TITLE followed by the controls' `tag`, unless it's
+      # empty, and MUTED when `muted`, each in brackets.
+      def title(tag, muted)
+        tags = tag.empty? ? [] : [tag]
+        tags << "MUTED" if muted
+        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |name| "[#{name}]" }).join(" "))
       end
 
       def close
@@ -70,9 +73,9 @@ module Badline
 
       private
 
-      def measure(screen, pixel_width)
+      def measure(screen)
         @texture_width = screen.width
-        @width = screen.width * pixel_width
+        @width = screen.window_width
         @height = screen.height
       end
 

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
@@ -131,7 +134,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 +169,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/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:
@@ -34,14 +35,22 @@ module Badline
   # +type_text+, +mount+, +unmount+, +mounted?+, +datasette+, +attach_cartridge+,
   # +attach_drive1541+, +drive1541+, +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+ and
+  # +release_display_key+.
   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)

data/lib/badline/media.rb

@@ -33,11 +33,11 @@ module Badline
       # autostart then loads through it.
       #
       # An .m3u or .vfl list of disks attaches the first disk it lists
-      # (DiskList). A machine other than the C64 takes its own media
-      # (Vic20Media).
+      # (DiskList). The VIC-20 takes its own media (Vic20Media), and the
+      # C128 in C64 mode a C64's.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        return Vic20Media.attach(computer, path, autostart:, **) unless computer.is_a?(Computer)
+        return Vic20Media.attach(computer, path, autostart:, **) if computer.family == :vic20
 
         attach_c64(computer, path, autostart:, subtune:, **)
       end
@@ -160,13 +160,15 @@ module Badline
       def start_prg(computer, data, autostart:)
         load_addr = computer.load_prg(data)
         # Run only makes sense for programs at BASIC start, or a byte ahead
-        # of it, where BASIC keeps the zero before its first line.
-        return unless autostart && (load_addr == BASIC_START || load_addr == BASIC_START - 1)
+        # 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]
+        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
-        [0x2d, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+        [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
         computer.type_text("run\r")
       end
     end

data/lib/badline/options/event.rb

@@ -10,7 +10,7 @@ module Badline
       # left out.
       ACTIONS = {
         "key" => true, "type" => true, "insert" => true, "eject" => true, "screenshot" => true, "menu" => true,
-        "reset" => false, "freeze" => false, "resume" => false, "quit" => false
+        "display" => true, "reset" => false, "freeze" => false, "resume" => false, "quit" => false
       }.freeze
 
       # The frames a key or the freeze button is held for.
@@ -18,6 +18,9 @@ module Badline
 
       EJECTABLE = %w[disk tape cartridge].freeze
 
+      # The C128's screens display shows: the VIC-IIe's or the VDC's.
+      DISPLAYS = %w[vic vdc].freeze
+
       # What insert takes: disk images, tapes and cartridges, or an .m3u
       # or .vfl list of disks or a directory to mount as device 8.
       INSERTABLE = %w[.d64 .d71 .d81 .g64 .t64 .tap .crt].freeze
@@ -83,6 +86,7 @@ module Badline
         return true if action == "menu"
         return argument.empty? unless ACTIONS[action]
         return EJECTABLE.include?(argument) if action == "eject"
+        return DISPLAYS.include?(argument) if action == "display"
         return insertable?(argument) if action == "insert"
 
         !argument.empty?

data/lib/badline/options/family.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  class Options
+    # The machine family: the subcommand that names it, or else the media,
+    # and the models of each.
+    module Family
+      # Where C128 BASIC starts, which a program for the C128 loads at.
+      C128_BASIC_START = 0x1c01
+
+      private
+
+      # Takes `sid`, `c64`, `vic20` or `c128` 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
+        else return
+        end
+        @family_named = !@sid_command
+        args.shift
+      end
+
+      def family_models
+        case @family
+        when :vic20 then VIC20_MODELS
+        when :c128 then C128_MODELS
+        else MODELS
+        end
+      end
+
+      # Without a family named, a program that loads at C128_BASIC_START is
+      # 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)
+
+        @family = :c128 if load_address(@media_path) == C128_BASIC_START
+      end
+
+      # The load address of a .prg, or of the program a .p00 wraps after its
+      # 26-byte header.
+      def load_address(path)
+        offset = File.extname(path).casecmp?(".p00") ? 26 : 0
+        bytes = File.binread(path).bytes
+        bytes.size >= offset + 2 ? bytes[offset] | (bytes[offset + 1] << 8) : -1
+      end
+    end
+  end
+end