badline 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd764dccd3b8af3f8e0dcbb7d17debc3fceb24a9899f80871ebbf184ffefd65b
-  data.tar.gz: 46a62d801813476242a407c09ab3ff4fec1126d10bfee134047f18e90fd86955
+  metadata.gz: e82b9f5bb012d15fd7744f164b82420c3b71c00b14b43843093e1a2b3722beeb
+  data.tar.gz: cf94f9a74e8c9d5d6b9d3a94a5404d29376a4c57da7f18b78c9dd87da4a7c880
 SHA512:
-  metadata.gz: 82a62fb4a3de3ef65e123bacf22ba300efe628f1bde38815dc950a39034d8c2b9423de79b3805fce84e19bcbaa8100a3e67488d5ef0a3ecb2de6434689886883
-  data.tar.gz: 595b19f034d708db60089e707507e74281059d271527fe61e0a205d9e8e0853a4f6b4d077aeed648f59a86d06bf31d3ee6e5902345fdb52d5fb36ded8de94da3
+  metadata.gz: 14986d25fea5add5cecf4c10001b4f9cf9e087023f07bf8a8fc27d950f799ff41ae086518165ca67b840c440e5f56cf661d335ac5d4f5de347260c0bd44864bb
+  data.tar.gz: 12ba3fa5d2276efb1003edaa884e8f1c58ee7d2e2ac5e05b0f7d927e6d8b5a37869893f012d92560772b3adf18ea2d886c058737bf9e10aac25aec54e36afe6b

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.10.1](https://github.com/elektronaut/badline/compare/v0.10.0...v0.10.1) (2026-10-08)
+
+
+### Features
+
+* add the C64GS as --model c64gs ([ea04c0d](https://github.com/elektronaut/badline/commit/ea04c0d03b3a8c34426ff68a80ae0fc36db8123b))
+* add the C64GS as --model c64gs ([e533932](https://github.com/elektronaut/badline/commit/e533932360befa88d05cf1369cc417f40cababa7))
+* add the MAX Machine as --model ultimax ([fc48c40](https://github.com/elektronaut/badline/commit/fc48c40035892409175bf3d8fd08add6af0bbac9))
+* add the MAX Machine as --model ultimax ([22aca64](https://github.com/elektronaut/badline/commit/22aca643abc0746e362209fb48977cee94c2b985))
+* add the PET 64 as --model pet64 ([e17c0bd](https://github.com/elektronaut/badline/commit/e17c0bd0d13d15caf6d0b5377a5ac0a5756847cf))
+* add the PET 64 as --model pet64 ([2320ac7](https://github.com/elektronaut/badline/commit/2320ac7cd41ef6a4865e56d433585ddebb7ef01f))
+* bundle the C64GS's ROM, 390852-01 ([e31b280](https://github.com/elektronaut/badline/commit/e31b280044c18e639cc65df62a8b39d97dd874be))
+* bundle the PET 64's KERNAL, 901246-01 ([9a029ec](https://github.com/elektronaut/badline/commit/9a029ecfe25c0d9a806d8858253c4c172e175b7f))
+
+
+### Miscellaneous Chores
+
+* release 0.10.1 ([9d6f6ba](https://github.com/elektronaut/badline/commit/9d6f6ba71a647f24f00a830fbc772531fbcb4d92))
+
 ## [0.10.0](https://github.com/elektronaut/badline/compare/v0.9.0...v0.10.0) (2026-10-08)
 
 

data/README.md

@@ -85,7 +85,7 @@ differences noted in the table. `--help` lists the options for either.
 | `--sid 6581`, `--sid 8580` | Fit the older or newer SID. `--sid auto`, the default, takes a `.sid` tune's own |
 | `--ram SIZE` | Give a VIC-20 the RAM expansion `SIZE`: `unexpanded`, `3k`, `8k`, `16k`, `24k`, `32k` or `all`. Without it, the VIC-20 gets the expansion its media needs. See [The VIC-20](#the-vic-20) |
 | `--reu SIZE` | Plug in a RAM Expansion Unit of `SIZE` K: 128, 256, 512 (a 1750) or up to 16384 |
-| `--model NAME` | Run another model of the machine, named as in VICE. For the C64: `c64` (the default, a PAL C64 with the 6569 VIC-II, 6526 CIAs and the 6581 SID), `c64c` (the PAL C64C, with the 8565, 6526As and the 8580), `ntsc` (the 6567R8), `newntsc` (the NTSC C64C, with the 8562, 6526As and the 8580), `oldntsc` (the first NTSC C64s' 6567R56A), `drean` (the Drean C64 of Argentina, PAL-N with the 6572) or `sx64` (the portable SX-64, with its own KERNAL and no datasette). `--sid` or a `.sid` tune's own SID takes the model's place |
+| `--model NAME` | Run another model of the machine, named as in VICE. For the C64: `c64` (the default, a PAL C64 with the 6569 VIC-II, 6526 CIAs and the 6581 SID), `c64c` (the PAL C64C, with the 8565, 6526As and the 8580), `ntsc` (the 6567R8), `newntsc` (the NTSC C64C, with the 8562, 6526As and the 8580), `oldntsc` (the first NTSC C64s' 6567R56A), `drean` (the Drean C64 of Argentina, PAL-N with the 6572), `sx64` (the portable SX-64, with its own KERNAL and no datasette), `pet64` (the PET 64 or Educator 64, a PAL C64 in a PET's case with its own KERNAL and a green monochrome monitor) `c64gs` (the C64GS games console, a PAL C64C with its own BASIC and KERNAL, and no keyboard or datasette) or `ultimax` (the MAX Machine of Japan, NTSC with 2K of RAM, one CIA and no ROMs, which runs only a cartridge). `--sid` or a `.sid` tune's own SID takes the model's place |
 | `--ntsc` | Run an NTSC C64, as `--model ntsc` does |
 | `--no-sound` | Don't play the SID (`badline` only, where sound is on by default) |
 | `--sound` | Play the SID (`badline-ruby`, where sound is off by default) |

data/doc/library.md

@@ -42,6 +42,19 @@ model (`Badline::Model::ALL`):
 - `kernal: :sx64` fits the SX-64's KERNAL, and `datasette: false`
   leaves the cassette port empty, so inserting a tape raises
   `Badline::Datasette::Missing`. The SX-64 has both.
+- `kernal: :pet64` fits the PET 64's KERNAL, and `board: :pet64` its
+  green monochrome monitor: the VIC's `palette` is
+  `Badline::VIC::GREEN_PALETTE`, each colour's luminance in green. The
+  PET 64 has both.
+- `kernal: :gs` fits the C64GS's BASIC and KERNAL, and `board: :gs` its
+  case, which has no keyboard: `computer.keyboard` takes no keys. The
+  C64GS has both, and no datasette.
+- `board: :max` builds the MAX Machine's board: 2K of RAM at
+  `$0000-$07FF`, no ROMs mapped, CIA 1 alone, answering all through
+  `$DC00-$DFFF` but for the I/O 1 page a cartridge takes, and Ultimax
+  mode with or without a cartridge. CIA 2 is never on the bus, so the
+  VIC stays in bank 0. `Badline::Model::ULTIMAX` runs it on
+  `Badline::Region::NTSC_OLD`.
 
 ## Cartridges
 
@@ -63,7 +76,8 @@ Its contents are lost when the emulator quits.
 The KERNAL, BASIC and character ROMs come with the gem. To run other
 images, such as a patched KERNAL, point `BADLINE_ROM_PATH` at a
 directory that holds `kernal.rom`, `basic.rom` and `character.rom`, plus
-`kernal-sx64.rom` for the SX-64 and `eapi/eapi-am29f040-14` if you
+`kernal-sx64.rom` for the SX-64, `kernal-pet64.rom` for the PET 64,
+`c64gs.rom` for the C64GS and `eapi/eapi-am29f040-14` if you
 attach EasyFlash cartridges.
 `Badline.rom_path = dir` does the same before a `Badline::Computer` is
 built, and `nil` restores the bundled set.

data/doc/snapshots.md

@@ -62,9 +62,10 @@ Every model saves this way, PAL, NTSC, old NTSC and Drean alike, and so
 does a machine with an REU, with its RAM, its registers and a transfer
 part way through. A snapshot only restores in the badline version that
 wrote it, into a machine with the same chip models, region, RAM
-expansion, REU, KERNAL and datasette. One saved before badline recorded
-the KERNAL and the datasette restores as a machine with the C64's KERNAL
-and a datasette.
+expansion, REU, KERNAL, datasette and board. One saved before badline
+recorded the KERNAL and the datasette restores as a machine with the
+C64's KERNAL and a datasette, and one saved before it recorded the board
+restores on a C64's.
 
 ## The VIC-20
 

data/lib/badline/address_bus/fittings.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Badline
+  class AddressBus
+    # What a model fits around the chips: its KERNAL, a datasette or none,
+    # and the board and case they sit in.
+    module Fittings
+      # The keywords #fit takes.
+      NAMES = %i[kernal datasette board].freeze
+
+      # The C64's board and case, the PET 64's, whose built-in monitor
+      # shows the VIC's output in shades of green, the C64GS's, which has
+      # no keyboard, or the MAX Machine's (:max): 2K of RAM, no ROMs, CIA 1
+      # alone at $DC00-$DFFF and the cartridge port in Ultimax mode.
+      BOARDS = %i[c64 pet64 gs max].freeze
+
+      attr_reader :board
+
+      # Fits the KERNAL ROM ROMs::KERNALS names, leaves the cassette port
+      # empty unless `datasette`, and puts the chips in the board BOARDS
+      # names.
+      def fit(kernal: :c64, datasette: true, board: :c64)
+        self.kernal = kernal unless kernal == :c64
+        @datasette.disconnect! unless datasette
+        self.board = board unless board == :c64
+      end
+
+      def board=(name)
+        raise ArgumentError, "no board named #{name}" unless BOARDS.include?(name)
+
+        @board = name
+        vic.palette = name == :pet64 ? VIC::GREEN_PALETTE : VIC::PALETTE
+        keyboard.connected = name != :gs
+        update_overlays!
+      end
+    end
+  end
+end

data/lib/badline/address_bus/pla.rb

@@ -8,6 +8,18 @@ module Badline
     # ROMs, the chips, and #map_ram_pages, which lays out the RAM that the
     # ROMs, the cartridge and I/O map over.
     module PLA
+      # A chip's registers seen at another page, which reads and writes
+      # them as at the page the chip starts at.
+      class Mirror
+        def initialize(chip, start)
+          @chip = chip
+          @start = start
+        end
+
+        def peek(addr) = @chip.peek(@start | (addr & 0xff))
+        def poke(addr, value) = @chip.poke(@start | (addr & 0xff), value)
+      end
+
       private
 
       def map_pla_pages
@@ -27,19 +39,26 @@ module Badline
         end
       end
 
-      # Ultimax cartridges ignore the $01 lines: 4K of RAM, ROML/ROMH windows,
+      # Ultimax mode ignores the $01 lines: 4K of RAM, ROML/ROMH windows,
       # I/O always visible and open address space everywhere else. The ROML
       # and ROMH selects fire on writes as well, so cartridge RAM or flash in
-      # either window takes the writes there.
+      # either window takes the writes there. The MAX has 2K of RAM, and is
+      # in Ultimax mode with no cartridge too.
       def map_ultimax_pages
-        @read_pages.fill(@open_bus, 0x10, 0xf0)
-        @write_pages.fill(@open_bus, 0x10, 0xf0)
+        first = @board == :max ? 0x08 : 0x10
+        @read_pages.fill(@open_bus, first, 0x100 - first)
+        @write_pages.fill(@open_bus, first, 0x100 - first)
+        map_ultimax_cartridge if @cartridge
+        map_io_pages
+        map_max_io if @board == :max
+      end
+
+      def map_ultimax_cartridge
         @read_pages.fill(@cartridge.roml, 0x80, 0x20) if @cartridge.roml
         map_ultimax_writes(@cartridge.roml, 0x80)
         @read_pages.fill(@cartridge.romh, 0xe0, 0x20) if @cartridge.romh
         map_ultimax_writes(@cartridge.romh, 0xe0)
         map_ultimax_a000
-        map_io_pages
       end
 
       def map_ultimax_writes(bank, first_page)
@@ -53,6 +72,17 @@ module Badline
         @write_pages.fill(window, 0xa0, 0x20)
       end
 
+      # The MAX has no CIA 2 and no I/O 2: CIA 1 answers all through
+      # $DC00-$DFFF, but for the I/O 1 page a cartridge takes.
+      def map_max_io
+        @cia1_mirror ||= Mirror.new(cia1, 0xdc00)
+        (0xdd..0xdf).each { |page| @read_pages[page] = @write_pages[page] = @cia1_mirror }
+        return unless @cartridge
+
+        @write_pages[0xde] = @cartridge
+        @read_pages[0xde] = @cartridge if @cartridge.readable_io_pages.include?(0xde)
+      end
+
       # EXROM and GAME select the cartridge whether or not it has a chip
       # there, and an empty socket leaves the bus floating.
       def map_rom_overlays

data/lib/badline/address_bus/roms.rb

@@ -4,18 +4,25 @@ module Badline
   class AddressBus
     # The BASIC, character and KERNAL ROMs, and which KERNAL is fitted.
     module ROMs
-      # The KERNAL ROMs a machine can be fitted with, by name: the C64's
-      # and the SX-64's.
-      KERNALS = { c64: "kernal.rom", sx64: "kernal-sx64.rom" }.freeze
+      # The KERNAL ROMs a machine can be fitted with, by name: the C64's,
+      # the SX-64's, the PET 64's and the C64GS's. The C64GS's is a 16K
+      # image of its BASIC and its KERNAL, and fits both.
+      KERNALS = {
+        c64: "kernal.rom", sx64: "kernal-sx64.rom", pet64: "kernal-pet64.rom", gs: "c64gs.rom"
+      }.freeze
 
       attr_reader :basic_rom, :character_rom, :kernal_rom, :kernal
 
-      # Fits the KERNAL ROM KERNALS names `name`, in place of the one before.
+      # Fits the KERNAL ROM KERNALS names `name`, in place of the one before,
+      # with the BASIC of a 16K image or else the C64's.
       def kernal=(name)
         raise ArgumentError, "no KERNAL named #{name}" unless KERNALS.key?(name)
 
         @kernal = name
-        @kernal_rom = ROM.load(KERNALS[name], 0xe000)
+        data = ROM.read(KERNALS[name])
+        basic = data.length == 0x4000 ? data[0, 0x2000] : ROM.read("basic.rom")
+        @basic_rom = ROM.new(basic, length: 0x2000, start: 0xa000)
+        @kernal_rom = ROM.new(data[-0x2000, 0x2000], length: 0x2000, start: 0xe000)
         update_overlays!
       end
 

data/lib/badline/address_bus.rb

@@ -5,6 +5,7 @@ require "badline/address_bus/sid_slots"
 require "badline/address_bus/extra_sids"
 require "badline/address_bus/pla"
 require "badline/address_bus/roms"
+require "badline/address_bus/fittings"
 
 module Badline
   # Memory layout:
@@ -37,6 +38,7 @@ module Badline
     include PLA
     include ExtraSIDs
     include ROMs
+    include Fittings
 
     # I/O 1 and 2, and the Ultimax holes, with nothing on the bus. A read
     # picks up the byte the VIC fetched in the preceding phi1 half-cycle,
@@ -68,6 +70,7 @@ module Badline
     def initialize(sid_model: :mos6581, cia_model: :mos6526, vic_model: :mos6569, region: Region::PAL,
                    ram_expansion: nil)
       @region = region
+      @board = :c64
       @ram = Memory.new(RAM_POWER_ON, length: 2**16, start: 0)
       @ram_expansion = RAMExpansion.build(ram_expansion, @ram) { update_overlays! }
       @cartridge = @reu = nil
@@ -201,8 +204,9 @@ module Badline
     # so reads and writes dispatch through per-page handler tables instead
     # of range checks.
     def update_overlays!
-      @ultimax = @cartridge ? @cartridge.ultimax? : false
-      @phi1_ultimax = @cartridge ? @cartridge.phi1_ultimax? : false
+      max = @board == :max
+      @ultimax = max || (@cartridge ? @cartridge.ultimax? : false)
+      @phi1_ultimax = max || (@cartridge ? @cartridge.phi1_ultimax? : false)
       @video_ram = @ram_expansion.video_ram
       @vic.vic_bank.map(@video_ram, phi1_ultimax: @phi1_ultimax, ultimax: @ultimax, romh: @cartridge&.romh)
 

data/lib/badline/computer.rb

@@ -48,13 +48,12 @@ module Badline
     # TOD clocks count. The KERNAL tells PAL from NTSC by the raster, so
     # every region boots the same ROMs. reu plugs an REU of that many K
     # into the expansion port, where it drives the IRQ line and takes the
-    # bus for its transfers. kernal: names the KERNAL ROM
-    # (AddressBus::ROMs::KERNALS), and datasette: false leaves the cassette port
-    # empty, as on the SX-64.
-    def initialize(debug: false, reu: nil, kernal: :c64, datasette: true, **machine)
-      @address_bus = AddressBus.new(**machine)
-      @address_bus.kernal = kernal unless kernal == :c64
-      @address_bus.datasette.disconnect! unless datasette
+    # bus for its transfers. kernal:, datasette: and board: fit the bus
+    # afterwards (AddressBus::Fittings): the KERNAL ROM, the cassette port,
+    # which is empty on the SX-64, and the board and case.
+    def initialize(debug: false, reu: nil, **machine)
+      @address_bus = AddressBus.new(**machine.except(*AddressBus::Fittings::NAMES))
+      @address_bus.fit(**machine.slice(*AddressBus::Fittings::NAMES))
       @cpu = CPU.new(@address_bus, debug:)
       @vic = @address_bus.vic
       @vic.open_bus = -> { @address_bus.ram.peek(@cpu.program_counter) }
@@ -195,8 +194,9 @@ module Badline
 
     # RESTORE isn't in the key matrix. It fires a one-shot that pulses the
     # NMI line however long the key is held, modelled here as one cycle.
+    # A machine without a keyboard has no RESTORE key either.
     def press_restore
-      @restore_pulse = true
+      @restore_pulse = true if keyboard.connected?
     end
 
     # The one-shot has pulsed already, so letting go does nothing.

data/lib/badline/keyboard.rb

@@ -38,10 +38,21 @@ module Badline
       @keys = []
       @row_masks = nil
       @matrix = matrix
+      @connected = true
+    end
+
+    # Whether the machine has a keyboard. The C64GS has none: no key goes
+    # down on it.
+    def connected? = @connected
+
+    def connected=(connected)
+      @connected = connected
+      @keys.clear unless connected
+      @row_masks = nil
     end
 
     def press(key)
-      return unless valid_key?(key)
+      return unless @connected && valid_key?(key)
 
       @keys << key
       @row_masks = nil

data/lib/badline/machine.rb

@@ -47,7 +47,7 @@ module Badline
       profile = Model.named(model)
       Computer.new(vic_model: profile.vic_model, cia_model: profile.cia_model,
                    sid_model: sid_model || profile.sid_model, region: profile.region, reu:,
-                   kernal: profile.kernal, datasette: profile.datasette)
+                   kernal: profile.kernal, datasette: profile.datasette, board: profile.board)
     end
 
     def self.vic20(model, ram)

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/table.rb

@@ -5,7 +5,7 @@ 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.

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

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.10.0"
+  VERSION = "0.10.1"
 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.rb

@@ -24,9 +24,24 @@ module Badline
       0x8a8a8a, 0xb3ec91, 0x867ade, 0xb3b3b3
     ].freeze
 
+    # The sixteen colours' luminances, out of 32, as Philip Timmermann
+    # (Pepto) measured them on the 6569.
+    LUMINANCES = [0, 32, 10, 20, 12, 16, 8, 24, 12, 8, 16, 10, 15, 24, 15, 20].freeze
+
+    # The sixteen colours on a green monochrome monitor, which shows only
+    # their luminance, as the PET 64's does.
+    GREEN_PALETTE = LUMINANCES.map do |luminance|
+      green = luminance * 255 / 32
+      ((green / 4) << 16) | (green << 8) | (green / 4)
+    end.freeze
+
     attr_reader :display, :width, :height, :vic_bank, :column,
                 :rasterline, :dirty_lines, :model, :region
 
+    # The RGB colours #display's palette indices stand for: PALETTE, or
+    # GREEN_PALETTE on a monochrome monitor.
+    attr_accessor :palette
+
     # The parts a VICE snapshot reads and sets.
     attr_reader :registers, :display_state, :sequencer, :sprites, :character_buffer, :color_buffer,
                 :fetch_d011
@@ -94,6 +109,7 @@ module Badline
       @iie = %i[mos8566 mos8564].include?(model)
       @core = model == :mos6569 ? :mos6569 : :mos8565
       @region = region
+      @palette = PALETTE
       @lightpen_extra = @core == :mos8565 ? 1 : 2
       @grey_dots = @core == :mos8565
       @delayed_fetch = @core == :mos8565
@@ -380,8 +396,6 @@ module Badline
       @dirty_lines.fill(false)
     end
 
-    def palette = PALETTE
-
     private
 
     def load_beam(input)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: badline
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -50,6 +50,7 @@ files:
 - lib/badline.rb
 - lib/badline/address_bus.rb
 - lib/badline/address_bus/extra_sids.rb
+- lib/badline/address_bus/fittings.rb
 - lib/badline/address_bus/pla.rb
 - lib/badline/address_bus/roms.rb
 - lib/badline/address_bus/saved_state.rb
@@ -247,11 +248,13 @@ files:
 - lib/badline/rom.rb
 - lib/badline/roms/README
 - lib/badline/roms/basic.rom
+- lib/badline/roms/c64gs.rom
 - lib/badline/roms/character.rom
 - lib/badline/roms/dos1541.rom
 - lib/badline/roms/eapi/LICENSE.md
 - lib/badline/roms/eapi/README
 - lib/badline/roms/eapi/eapi-am29f040-14
+- lib/badline/roms/kernal-pet64.rom
 - lib/badline/roms/kernal-sx64.rom
 - lib/badline/roms/kernal.rom
 - lib/badline/roms/vic20/basic.rom