badline 0.10.0 → 0.11.0

data/lib/badline/model.rb

@@ -8,39 +8,56 @@ module Badline
   # a datasette. The names are x64sc's.
   module Model
     # Each field but the name is a keyword Computer.new takes.
-    Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :kernal, :datasette)
+    Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :kernal, :datasette, :board)
 
     # The breadbin PAL C64: the 6569 VIC-II, 6526 CIAs and the 6581 SID.
     C64 = Profile.new(name: "c64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                      region: Region::PAL, kernal: :c64, datasette: true)
+                      region: Region::PAL, kernal: :c64, datasette: true, board: :c64)
 
     # The PAL C64C: the HMOS 8565 VIC-II, 6526A CIAs and the 8580 SID.
     C64C = Profile.new(name: "c64c", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
-                       region: Region::PAL, kernal: :c64, datasette: true)
+                       region: Region::PAL, kernal: :c64, datasette: true, board: :c64)
 
     # The NTSC C64 with the 6567R8 VIC-II.
     NTSC = Profile.new(name: "ntsc", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                       region: Region::NTSC, kernal: :c64, datasette: true)
+                       region: Region::NTSC, kernal: :c64, datasette: true, board: :c64)
 
     # The NTSC C64C: the 8562, the 6567R8's HMOS successor, with the
     # C64C's CIAs and SID.
     NEW_NTSC = Profile.new(name: "newntsc", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
-                           region: Region::NTSC, kernal: :c64, datasette: true)
+                           region: Region::NTSC, kernal: :c64, datasette: true, board: :c64)
 
     # The first NTSC C64s, with the 6567R56A VIC-II.
     OLD_NTSC = Profile.new(name: "oldntsc", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                           region: Region::NTSC_OLD, kernal: :c64, datasette: true)
+                           region: Region::NTSC_OLD, kernal: :c64, datasette: true, board: :c64)
 
     # The Drean C64 of Argentina, on PAL-N with the 6572 VIC-II.
     DREAN = Profile.new(name: "drean", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                        region: Region::DREAN, kernal: :c64, datasette: true)
+                        region: Region::DREAN, kernal: :c64, datasette: true, board: :c64)
 
     # The portable SX-64: a PAL C64's chips with its own KERNAL, a 1541
     # built in as device 8 and no cassette port.
     SX64 = Profile.new(name: "sx64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                       region: Region::PAL, kernal: :sx64, datasette: false)
+                       region: Region::PAL, kernal: :sx64, datasette: false, board: :c64)
 
-    ALL = [C64, C64C, NTSC, NEW_NTSC, OLD_NTSC, DREAN, SX64].freeze
+    # The PET 64, or Educator 64: a PAL C64's board in a PET's case, with
+    # its own KERNAL and a green monochrome monitor built in.
+    PET64 = Profile.new(name: "pet64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                        region: Region::PAL, kernal: :pet64, datasette: true, board: :pet64)
+
+    # The C64GS games console: a PAL C64C's board with its own BASIC and
+    # KERNAL, which show an animation asking for a cartridge when it has
+    # none, in a case with no keyboard and no cassette port.
+    C64GS = Profile.new(name: "c64gs", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
+                        region: Region::PAL, kernal: :gs, datasette: false, board: :gs)
+
+    # The MAX Machine, or Ultimax, of Japan: the 6566, an NTSC VIC-II
+    # for static RAM, which runs here as the first NTSC C64s' 6567R56A,
+    # one CIA, 2K of RAM and no ROMs, so it runs only a cartridge's.
+    ULTIMAX = Profile.new(name: "ultimax", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                          region: Region::NTSC_OLD, kernal: :c64, datasette: true, board: :max)
+
+    ALL = [C64, C64C, NTSC, NEW_NTSC, OLD_NTSC, DREAN, SX64, PET64, C64GS, ULTIMAX].freeze
 
     def self.named(name)
       model = ALL.find { |candidate| candidate.name == name }
@@ -49,13 +66,13 @@ module Badline
       model
     end
 
-    # The model whose chips, region, KERNAL and datasette `machine` has, or
-    # nil for none.
+    # The model whose chips, region, KERNAL, datasette and board `machine`
+    # has, or nil for none.
     def self.of(machine)
       ALL.find do |model|
         model.vic_model == machine.vic_model && model.cia_model == machine.cia_model &&
           model.sid_model == machine.sid_model && model.region == machine.region &&
-          model.kernal == machine.kernal && model.datasette == machine.datasette
+          model.kernal == machine.kernal && model.datasette == machine.datasette && model.board == machine.board
       end
     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

data/lib/badline/options/help.rb

@@ -39,6 +39,7 @@ module Badline
       <<~BANNER
         Usage: #{@program} [c64] [options] [media]
                #{@program} vic20 [options] [media]
+               #{@program} c128 [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
@@ -46,6 +47,7 @@ module Badline
         Commands:
             c64                              Run a C64, the one --model names (the default)
             vic20                            Run a PAL VIC-20, with the RAM --ram names
+            c128                             Run a C128 in C128 mode, the one --model names
             sid                              Play .sid tunes and directories of them
 
         Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
@@ -89,7 +91,9 @@ module Badline
         the frame as a .bmp, with the frame's number in place of %d. menu
         opens the pause menu, and menu=PAGE opens it on snapshots, drive,
         datasette, expansion, ports, sound or power. Its frames still count,
-        and resume closes it. reset, freeze and quit take no argument.
+        and resume closes it. display=vdc or display=vic shows the C128's
+        80 or 40 column screen, as F8 switches them. reset, freeze and quit
+        take no argument.
       BANNER
     end
 

data/lib/badline/options/table.rb

@@ -5,12 +5,15 @@ module Badline
     DEFAULT_RATE = 44_100
 
     # The names Badline::Model builds, in the order the help lists them.
-    MODELS = %w[c64 c64c ntsc newntsc oldntsc drean sx64].freeze
+    MODELS = %w[c64 c64c ntsc newntsc oldntsc drean sx64 pet64 c64gs ultimax].freeze
 
     # The VIC-20's models, as xvic names its video standards. Only PAL is
     # emulated.
     VIC20_MODELS = %w[pal ntsc].freeze
 
+    # The C128's models, as C128::Model names them.
+    C128_MODELS = %w[c128 c128ntsc c128dcr c128dcrntsc].freeze
+
     # The VIC-20 RAM expansions --ram takes, in the order the help lists
     # them.
     RAM_NAMES = %w[unexpanded 3k 8k 16k 24k 32k all].freeze
@@ -36,9 +39,12 @@ module Badline
                  section: "Window options", needs: :window),
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),
-      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal",
+      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal; " \
+                                 "C128: #{C128_MODELS.join(', ')}",
                  section: "Window options", needs: :window),
       Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
+      Option.new("--c64", "Start the C128 in C64 mode, holding C= at power-on",
+                 section: "Window options", needs: :window),
       Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded)",
                  section: "Window options", needs: :window),
       Option.new("--no-vsync", "Pace frames by the timer or the sound instead of the display",

data/lib/badline/options/validation.rb

@@ -64,6 +64,19 @@ module Badline
         elsif !@ram.nil?
           raise Error, "--ram needs vic20"
         end
+        if @family == :c128
+          validate_c128
+        elsif @c64_mode
+          raise Error, "--c64 needs c128"
+        end
+      end
+
+      # The C128 runs in the window, without an REU, and its NTSC models
+      # have names of their own.
+      def validate_c128
+        raise Error, "--ntsc needs the C64; the NTSC C128 is --model c128ntsc" if @models.include?("ntsc")
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the C128 needs the window" if headless?
       end
 
       # The VIC-20 is a PAL one, in the window, without the C64's SID and
@@ -87,7 +100,7 @@ module Badline
       # --model and --ntsc may be given more than once, but only for one
       # model.
       def validate_models
-        names = @family == :vic20 ? VIC20_MODELS : MODELS
+        names = family_models
         unknown = @models.find { |name| !names.include?(name) }
         raise Error, "invalid argument: --model #{unknown}" unless unknown.nil?
         raise Error, "conflicting models: #{@models.uniq.join(' and ')}" unless @models.uniq.size <= 1

data/lib/badline/options.rb

@@ -5,16 +5,17 @@ require "badline/options/event"
 require "badline/options/table"
 require "badline/options/help"
 require "badline/options/validation"
+require "badline/options/family"
 
 module Badline
   # The command line of both builds, badline-ruby and the native badline.
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
   # first, plays .sid tunes and directories of them in the terminal.
-  # `c64` or `vic20`, given first, names the machine family, and without
-  # either the family is the C64. The
-  # native build adds --no-sound and --version, and badline-ruby adds
-  # --disable-jit.
+  # `c64`, `vic20` or `c128`, given first, names the machine family, and
+  # without one the family is the C64, or the C128 for a program that loads
+  # where C128 BASIC starts. The native build adds --no-sound and
+  # --version, and badline-ruby adds --disable-jit.
   #
   # TABLE lists the options, and both the parser and the help read it. It
   # parses by hand, inside the subset of Ruby Spinel compiles. Values come
@@ -23,6 +24,7 @@ module Badline
   # arguments before paying for the emulator.
   class Options
     include Validation
+    include Family
 
     class Error < StandardError; end
 
@@ -55,7 +57,8 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
-    # The machine family to build (Badline::Machine), :c64 or :vic20.
+    # The machine family to build (Badline::Machine), :c64, :vic20 or
+    # :c128.
     attr_reader :family
 
     # The VIC-20's RAM expansion --ram names, a key of
@@ -72,6 +75,8 @@ module Badline
       @program = native ? "badline" : "badline-ruby"
       @media_path = nil
       @family = :c64
+      @family_named = false
+      @c64_mode = false
       @sid_command = false
       @tune_paths = []
       @subtune = nil
@@ -110,6 +115,7 @@ module Badline
       args = argv.dup
       subcommand(args)
       argument(args.shift, args) until args.empty?
+      pick_family
       play_lone_tune
       validate unless help? || version?
       self
@@ -167,9 +173,14 @@ module Badline
 
     def jit? = @jit
 
-    # The name of the model to build: a C64 Badline::Model names, or a
-    # VIC-20 of VIC20_MODELS. --ntsc is short for --model ntsc.
-    def model = @models.first || (@family == :vic20 ? VIC20_MODELS.first : MODELS.first)
+    # The name of the model to build: a C64 Badline::Model names, a VIC-20
+    # of VIC20_MODELS or a C128 of C128_MODELS. --ntsc is short for --model
+    # ntsc.
+    def model = @models.first || family_models.first
+
+    # Whether --c64 asks the C128 to start in C64 mode, holding C= at
+    # power-on.
+    def c64_mode? = @c64_mode
 
     def help? = @help
 
@@ -183,17 +194,6 @@ module Badline
       [:both, @native ? :native : :ruby].include?(option.build)
     end
 
-    # Takes `sid`, `c64` or `vic20` 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
-      else return
-      end
-      args.shift
-    end
-
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
@@ -273,6 +273,7 @@ module Badline
       when "--verbose" then @verbose = true
       when "--true-drive" then @true_drive = true
       when "--ntsc" then @models << "ntsc"
+      when "--c64" then @c64_mode = true
       when "--unpaced" then @paced = false
       when "--disable-jit" then @jit = false
       when "--help" then @help = true

data/lib/badline/roms/README

@@ -27,6 +27,30 @@ Downloaded from
 https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/c64/kernal.sx.251104-04.bin
 SHA-1 aa136e91ecf3c5ac64f696b3dbcbfc5ba0871c98.
 
+kernal-pet64.rom
+----------------
+The KERNAL of the PET 64, 4064 and Educator 64, 901246-01. It boots
+with the "**** COMMODORE 4064  BASIC V2.0 ****" banner and a white
+cursor, and its interrupt routine keeps the border, background and
+sprite colours black unless bit 7 of $0286 is set. Computer.new(kernal:
+:pet64) fits it, as --model pet64 does.
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/c64/kernal.4064.901246-01.bin
+MD5 da92801e3a03b005b746a4dd0b639c7c.
+
+c64gs.rom
+---------
+The C64GS's BASIC and KERNAL, 390852-01, 16 KB: BASIC for $A000-$BFFF
+followed by the KERNAL for $E000-$FFFF. Its BASIC is 901226-01's but
+for 30 unused bytes. Its KERNAL is 901227-03's with most changes in
+$F72C-$FC92, the cassette routines' place, and many jumps redirected to
+I/O error 5. Computer.new(kernal: :gs) fits both, as --model c64gs does.
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/c64/64gs.390852-01.bin
+MD5 049e657afafbdd802e8c6a4f88f3d730.
+
 dos1541.rom
 -----------
 The 1541 disk drive's DOS 2.6, 16 KB for $C000-$FFFF: 325302-01
@@ -63,3 +87,30 @@ vic20/character.rom
 -------------------
 The character generator ROM, 901460-03, for $8000-$8FFF.
 SHA-1 4fd85ab6647ee2ac7ba40f729323f2472d35b9b4.
+
+Commodore 128 ROMs
+==================
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/c128/
+C128::Bus maps them in C128 mode. C64 mode runs basic.rom, kernal.rom
+and character.rom above.
+
+c128/basic.rom
+--------------
+BASIC 7.0, 318022-02 (basic.318022-02.bin), 32 KB: the low half for
+$4000-$7FFF followed by the high half for $8000-$BFFF.
+SHA-1 953dcdf5784a6b39ef84dd6fd968c7a03d8d6816.
+
+c128/kernal.rom
+---------------
+318020-05 (kernal.318020-05.bin), 16 KB: the screen editor for
+$C000-$CFFF, the Z80 BIOS for $D000-$DFFF and the KERNAL for
+$E000-$FFFF.
+SHA-1 ceb6e1a1bf7e08eb9cbc651afa29e26adccf38ab.
+
+c128/character.rom
+------------------
+The character generator ROM, 390059-01 (characters.390059-01.bin),
+8 KB: the C64's set, the same as character.rom, followed by the C128's.
+SHA-1 29ed066d513f2d5c09ff26d9166ba23c2afb2b3f.

data/lib/badline/snapshot/container.rb

@@ -28,6 +28,8 @@ module Badline
       MACHINE = "C64SC"
       # xvic names its machine VIC20.
       VIC20 = "VIC20"
+      # x128 names its machine C128.
+      C128 = "C128"
       GZIP_MAGIC = "\x1f\x8b".b
 
       # The VICE version block, when VICE wrote the file: four version

data/lib/badline/snapshot/image.rb

@@ -29,6 +29,7 @@ module Badline
       # warns it without a block.
       def load(&)
         return load_vic20(&) if vic20?
+        return load_c128(&) if c128?
 
         computer = badline? ? opening { Computer.restored(state) } : Vice.setup(@container).build
         tell(badline? ? state_report(computer) : Vice::Restore.apply(@container, computer), &)
@@ -38,6 +39,9 @@ module Badline
       # Whether the machine is a VIC-20, as the container names it.
       def vic20? = @container.machine == Container::VIC20
 
+      # Whether the machine is a C128, as the container names it.
+      def c128? = @container.machine == Container::C128
+
       # Restores `computer` from the snapshot, and returns the Report. A
       # snapshot that fails leaves the machine as it was.
       def restore(computer, &)
@@ -60,6 +64,16 @@ module Badline
         machine
       end
 
+      # A C128 restores from its BADLINE module alone. x128's own modules
+      # aren't read.
+      def load_c128(&)
+        raise FormatError, "badline reads only its own C128 snapshots, not x128's" unless badline?
+
+        machine = C128.restored(state)
+        tell(state_report(machine), &)
+        machine
+      end
+
       def tell(report)
         report.ignored.each { |line| block_given? ? yield(line) : warn("badline: #{line}") }
       end

data/lib/badline/snapshot/setup.rb

@@ -3,32 +3,36 @@
 module Badline
   module Snapshot
     # How a machine was built: its VIC, CIA and SID models, its region, its
-    # RAM expansion, the size of its REU, its KERNAL and whether it has a
-    # datasette, the arguments Computer.new takes. A State starts with them, so a machine to restore it into can
-    # be built first.
-    Setup = Data.define(:vic_model, :cia_model, :sid_model, :region, :ram_expansion, :reu, :kernal, :datasette)
+    # RAM expansion, the size of its REU, its KERNAL, whether it has a
+    # datasette and its board, the arguments Computer.new takes. A State
+    # starts with them, so a machine to restore it into can be built first.
+    Setup = Data.define(:vic_model, :cia_model, :sid_model, :region, :ram_expansion, :reu, :kernal, :datasette,
+                        :board)
 
     class Setup
       SID_MODELS = %i[mos6581 mos8580].freeze
       REGIONS = [Region::PAL, Region::NTSC, Region::NTSC_OLD, Region::DREAN].freeze
       RAM_EXPANSIONS = [:none, *RAMExpansion::TYPES.keys].freeze
       KERNALS = AddressBus::ROMs::KERNALS.keys.freeze
+      BOARDS = AddressBus::Fittings::BOARDS
 
       def self.of(address_bus)
         new(vic_model: address_bus.vic.model, cia_model: address_bus.cia1.model, sid_model: address_bus.sid.model,
             region: address_bus.region, ram_expansion: address_bus.ram_expansion.type, reu: address_bus.reu&.size_kb,
-            kernal: address_bus.kernal, datasette: address_bus.datasette.connected?)
+            kernal: address_bus.kernal, datasette: address_bus.datasette.connected?, board: address_bus.board)
       end
 
-      # Layout 3 has no KERNAL or datasette, and stands for the C64's.
+      # Layout 3 has no KERNAL or datasette, and stands for the C64's, and
+      # layouts before 6 have no board, and stand for the C64's.
       def self.read(input)
         new(vic_model: VIC::MODELS.fetch(input.int), cia_model: CIA::MODELS.fetch(input.int),
             sid_model: SID_MODELS.fetch(input.int), region: REGIONS.fetch(input.int),
             ram_expansion: ram_expansion(RAM_EXPANSIONS.fetch(input.int)), reu: reu(input.int),
             kernal: input.schema > 3 ? KERNALS.fetch(input.int) : :c64,
-            datasette: input.schema > 3 ? input.boolean? : true)
+            datasette: input.schema > 3 ? input.boolean? : true,
+            board: input.schema > 5 ? BOARDS.fetch(input.int) : :c64)
       rescue IndexError
-        raise FormatError, "the state names a chip model, region, RAM expansion or KERNAL badline doesn't know"
+        raise FormatError, "the state names a chip model, region, RAM expansion, KERNAL or board badline doesn't know"
       end
 
       def self.ram_expansion(name) = name == :none ? nil : name
@@ -45,12 +49,12 @@ module Badline
         out.int(VIC::MODELS.index(vic_model)).int(CIA::MODELS.index(cia_model))
         out.int(SID_MODELS.index(sid_model)).int(REGIONS.index(region))
         out.int(RAM_EXPANSIONS.index(ram_expansion || :none)).int(reu || 0)
-        out.int(KERNALS.index(kernal)).boolean(datasette)
+        out.int(KERNALS.index(kernal)).boolean(datasette).int(BOARDS.index(board))
       end
 
       # A machine built this way, at power-on.
       def build
-        Computer.new(vic_model:, cia_model:, sid_model:, region:, ram_expansion:, reu:, kernal:, datasette:)
+        Computer.new(vic_model:, cia_model:, sid_model:, region:, ram_expansion:, reu:, kernal:, datasette:, board:)
       end
 
       # The chips, led by the model's name when they make one of
@@ -63,6 +67,7 @@ module Badline
         parts << "a #{reu}K REU" if reu
         parts << "the #{kernal} KERNAL" unless kernal == :c64
         parts << "no datasette" unless datasette
+        parts << "the #{board} board" unless board == :c64
         parts.join(", ")
       end
     end

data/lib/badline/snapshot/state.rb

@@ -14,10 +14,11 @@ module Badline
       # The layout the chips write their fields in. It goes up whenever a
       # save_state writes something else, so a State in another layout
       # fails before anything is read into a machine. Layout 3, without the
-      # KERNAL and datasette in the setup, and layout 4, without the VIA
-      # shift register's clock delay, still read.
-      SCHEMA = 5
-      READABLE = [3, 4, SCHEMA].freeze
+      # KERNAL and datasette in the setup, layout 4, without the VIA shift
+      # register's clock delay, and layout 5, without the board in the
+      # setup, still read.
+      SCHEMA = 6
+      READABLE = [3, 4, 5, SCHEMA].freeze
 
       attr_reader :values, :strings
 

data/lib/badline/snapshot/vice.rb

@@ -69,7 +69,8 @@ module Badline
         reu = nil unless reu && REU1764.reads?(reu)
         Setup.new(vic_model: model, cia_model: model == :mos8565 ? :mos6526a : :mos6526, sid_model: sid,
                   region: vic ? VICII.region(vic) : Region::PAL, ram_expansion: nil,
-                  reu: reu ? REU1764.size_kb(reu) : nil, kernal: :c64, datasette: true)
+                  reu: reu ? REU1764.size_kb(reu) : nil, kernal: :c64, datasette: true,
+                  board: :c64)
       end
     end
   end

data/lib/badline/snapshot.rb

@@ -27,11 +27,12 @@ module Badline
       path
     end
 
-    # A VIC-20's snapshot holds the BADLINE module alone, in a container
-    # named as xvic names its machine.
+    # A VIC-20's or a C128's snapshot holds the BADLINE module alone, in a
+    # container named as xvic or x128 names its machine.
     def dump(computer)
       state = computer.snapshot
       return Container.new([MachineState.section(state)], machine: Container::VIC20).to_s if computer.family == :vic20
+      return Container.new([MachineState.section(state)], machine: Container::C128).to_s if computer.family == :c128
 
       Container.new(Vice.export(state) + [MachineState.section(state)]).to_s
     end
@@ -59,4 +60,10 @@ module Badline
 
     def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
   end
+
+  class C128
+    def save_snapshot(path) = Snapshot.save(self, path)
+
+    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+  end
 end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/badline/vic/bank.rb

@@ -110,7 +110,8 @@ module Badline
       private
 
       # In Ultimax mode the cartridge ROMH replaces the character ROM
-      # shadow, visible at $3000-$3FFF of the window.
+      # shadow, visible at $3000-$3FFF of the window. The MAX is in
+      # Ultimax mode with no cartridge too.
       def ultimax_peek(offset)
         romh = @romh
         if romh && offset.allbits?(0x3000)

data/lib/badline/vic/display_state.rb

@@ -68,6 +68,12 @@ module Badline
       # True once AEC has followed BA down and the VIC owns the bus.
       def bus_taken?(column) = @ba ? column >= @ba + BA_DELAY : false
 
+      # The CPU kept the bus through the cycle before +column+, so on a bad
+      # line AEC falls BA_DELAY cycles after it at the earliest.
+      def keep_bus(column)
+        @ba &&= column
+      end
+
       def fetching?(column)
         @matched && column >= FETCH_FIRST && column <= DMA_LAST
       end
@@ -98,6 +104,12 @@ module Badline
 
       def new_line(line)
         @ba = nil
+        raster_step(line)
+      end
+
+      # The raster counter moved on to +line+, at the line's start or, under
+      # the VIC-IIe's TEST bit, within it.
+      def raster_step(line)
         @line_bits = line & 0b111
         @den_line = line == FIRST_LINE
         @in_window = line.between?(FIRST_LINE, LAST_LINE)

data/lib/badline/vic/registers.rb

@@ -150,6 +150,9 @@ module Badline
       def fast? = @iie && @bytes[0x30].anybits?(0x01)
       def test? = @iie && @bytes[0x30].anybits?(0x02)
 
+      # FAST and TEST as bits 0 and 1.
+      def clock_bits = @iie ? @bytes[0x30] & 0x03 : 0
+
       def raster_target = uint16(@bytes[0x12], (@bytes[0x11] & 0x80) >> 7)
 
       def latch_irq!(bit)