badline 0.14.0 → 0.15.0

data/lib/badline/snapshot/field_doc.rb

@@ -2,6 +2,7 @@
 
 require "badline"
 require "badline/c128"
+require "badline/plus4"
 
 module Badline
   module Snapshot
@@ -27,29 +28,45 @@ module Badline
       # each module the keys its records hold, with their tags, and the fields the load read.
       Load = Data.define(:family, :written, :fields)
 
-      # The machines the doc is made from: each family at power-on, and the
-      # C64 with each kind of expansion, cartridge and media.
+      # The cartridges by CRT hardware type: EasyFlash, then a mapper of
+      # each kind of register: Ocean's bank, Comal-80's bank for both
+      # windows, Zaxxon's ROMH bank, and the Action Replay's and the
+      # Pagefox's control registers.
+      CARTRIDGES = [32, 5, 21, 18, 1, 53].freeze
+
+      # The machines the doc is made from: each family at power-on, the C64
+      # with each kind of expansion, cartridge and media, and a second SID,
+      # and the 264 series' models, its TCBM interface, cartridge, tape and
+      # true drive.
       def self.machines
         {
-          "c64" => [C64.new, C64.new(ram_expansion: :plus256k), C64.new(reu: 512), with_cartridge, with_trap_dos,
-                    with_tape, with_drive(:d64), with_drive(:d81)],
+          "c64" => [C64.new, C64.new(ram_expansion: :plus256k), C64.new(reu: 512),
+                    *CARTRIDGES.map { |type| with_cartridge(type) }, with_trap_dos, with_tape, with_drive(:d64),
+                    with_drive(:d81), with_extra_sids],
           "vic20" => [Vic20.new, with_rom],
-          "c128" => [C128.new(mode: :c128), with_drive(:d71)]
+          "c128" => [C128.new(mode: :c128), with_drive(:d71)],
+          "plus4" => [Plus4.new, Plus4.new(model: "c16"), Plus4.new(tcbm: true), plus4_with_cartridge,
+                      plus4_with_tape, plus4_with_drive]
         }
       end
 
       def self.blank(length) = Array.new(length, 0)
 
-      def self.with_cartridge
+      def self.with_cartridge(type)
         chips = [0x8000, 0xa000].map do |address|
           Storage::CRTFile::Chip.new(chip_type: 2, bank: 0, address:, data: blank(0x2000))
         end
-        image = Storage::CRTFile::Image.new(hardware_type: 32, subtype: 0, exrom: 1, game: 0, name: "DOC", chips:)
+        image = Storage::CRTFile::Image.new(hardware_type: type, subtype: 0, exrom: 1, game: 0, name: "DOC", chips:)
         C64.new.tap do |machine|
           machine.attach_cartridge(C64::Cartridge.from_crt(Storage::CRTFile.new(bytes: Storage::CRTFile.encode(image))))
         end
       end
 
+      # The SID player's machine for a tune on two SIDs.
+      def self.with_extra_sids
+        C64.new.tap { |machine| machine.address_bus.add_sid(Chips::SID.new(at: 0xd420)) }
+      end
+
       def self.with_trap_dos
         C64.new.tap { |machine| machine.mount(Storage::D64Image.new("", read_only: true, bytes: blank(174_848))) }
       end
@@ -78,6 +95,28 @@ module Badline
         end
       end
 
+      # A Plus/4 with a cartridge in each of cartridge 1's slots.
+      def self.plus4_with_cartridge
+        chips = [0x8000, 0xc000].map do |address|
+          Storage::CRTFile::Chip.new(chip_type: 0, bank: 0, address:, data: blank(0x4000))
+        end
+        Plus4.new.tap { |machine| machine.attach_cartridge(chips) }
+      end
+
+      # A C16 with a version 2 tape in its datasette, which times the read
+      # line's level.
+      def self.plus4_with_tape
+        bytes = "C16-TAPE-RAW".bytes + [2, 2, 0, 0, 4, 0, 0, 0, 0x30, 0x30, 0x30, 0x30]
+        Plus4.new(model: "c16").tap { |machine| machine.datasette.insert(Storage::TAP.new("", bytes:)) }
+      end
+
+      def self.plus4_with_drive
+        Plus4.new.tap do |machine|
+          image = Storage::D64Image.new("", bytes: blank(174_848))
+          machine.plug_true_drive.insert(Drives::Model1541::Disk.decode(image))
+        end
+      end
+
       def self.with_rom
         Vic20.new.tap { |machine| machine.bus.map_rom(0xa000, blank(0x2000)) }
       end

data/lib/badline/snapshot/image.rb

@@ -34,7 +34,7 @@ module Badline
     # of a machine in memory (.of).
     class Image
       MACHINE = "BL-MACHINE"
-      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128" }.freeze
+      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4" }.freeze
 
       attr_reader :container
 
@@ -54,8 +54,11 @@ module Badline
       end
 
       # The snapshot with VICE's modules ahead of the BL-* ones for a C64,
-      # so x64sc opens it too.
+      # so x64sc opens it too. Raises FormatError for a Plus/4, whose
+      # snapshots badline doesn't write for xplus4.
       def self.exported(computer)
+        raise FormatError, "badline doesn't export a Plus/4's snapshot for VICE" if computer.family == :plus4
+
         computer.settle_for_snapshot!
         sections = computer.save_modules
         sections = Vice.export(computer) + sections if computer.family == :c64
@@ -67,6 +70,7 @@ module Badline
         case computer.family
         when :vic20 then Container::VIC20
         when :c128 then Container::C128
+        when :plus4 then Container::PLUS4
         else Container::MACHINE
         end
       end
@@ -77,6 +81,7 @@ module Badline
         case machine.choice("family", FAMILIES.keys, "c64")
         when "vic20" then Vic20Setup.read_fields(machine)
         when "c128" then C128Setup.read_fields(machine)
+        when "plus4" then Plus4Setup.read_fields(machine)
         else C64Setup.read_fields(machine)
         end
       end
@@ -92,7 +97,7 @@ module Badline
 
       # A new machine, built as the snapshot's was and restored from it. A
       # badline snapshot restores from its BL-* modules alone, and a VICE
-      # one through the modules badline reads. xvic's and x128's own
+      # one through the modules badline reads. xvic's, x128's and xplus4's own
       # modules aren't read. Yields a line for each thing left out, or
       # warns it without a block. `detached` restores it without the host's
       # files (Keyed::Modules).
@@ -100,6 +105,7 @@ module Badline
         refuse_old_layout
         raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" if vic20? && !badline?
         raise FormatError, "badline reads only its own C128 snapshots, not x128's" if c128? && !badline?
+        raise FormatError, "badline reads only its own Plus/4 snapshots, not xplus4's" if plus4? && !badline?
         return load_vice(&) unless badline?
 
         modules = Keyed::Modules.new(sections, detached:)
@@ -114,6 +120,9 @@ module Badline
       # Whether the machine is a C128, as the container names it.
       def c128? = @container.machine == Container::C128
 
+      # Whether the machine is of the 264 series, as the container names it.
+      def plus4? = @container.machine == Container::PLUS4
+
       # Restores `computer` from the snapshot, and returns the Report. The
       # snapshot goes into a new machine first, so one that fails, or is of
       # a machine built another way, leaves `computer` as it was.

data/lib/badline/snapshot/plus4_setup.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a 264 series machine was built: its model's name, one of
+    # Plus4::Model::ALL, which also says whether the Plus/4's function ROMs
+    # are fitted, its RAM in K, and whether a 1551's TCBM interface is
+    # plugged in, the arguments Plus4.new takes.
+    Plus4Setup = Data.define(:model, :ram_kb, :tcbm)
+
+    class Plus4Setup
+      MODELS = Plus4::Model::ALL.map(&:name).freeze
+
+      # The setup of `machine`.
+      def self.of(machine) = new(model: machine.model.name, ram_kb: machine.ram_kb, tcbm: !machine.tias.empty?)
+
+      # The model by name, the RAM and the TCBM interface, in a keyed
+      # snapshot module.
+      def write_fields(out)
+        out.text("model", model).int("ram_kb", ram_kb).bool("tcbm", tcbm)
+      end
+
+      def self.read_fields(input)
+        model = input.choice("model", MODELS, "plus4")
+        ram_kb = input.int("ram_kb", Plus4::Model.named(model).ram_kb)
+        unless Plus4::Model::RAM_SIZES.include?(ram_kb)
+          raise FormatError, "the snapshot is of a Plus/4 with #{ram_kb}K of RAM, which badline doesn't build"
+        end
+
+        new(model:, ram_kb:, tcbm: input.bool("tcbm", false))
+      end
+
+      # A machine built this way, at power-on.
+      def build = Plus4.new(model:, ram: ram_kb, tcbm:)
+
+      def to_s = "#{model} with #{ram_kb}K#{' and a TCBM interface' if tcbm}"
+    end
+  end
+end

data/lib/badline/snapshot.rb

@@ -35,8 +35,9 @@ module Badline
     # The machine's snapshot file. Saving first runs the machine on to the
     # end of the instruction its CPU is in, and of an REU transfer under
     # way (Machine::Settling), so a save advances it by a few cycles, and a
-    # second save straight after runs none. A VIC-20's or a C128's snapshot
-    # is in a container named as xvic or x128 names its machine.
+    # second save straight after runs none. A VIC-20's, a C128's or a
+    # Plus/4's snapshot is in a container named as xvic, x128 or xplus4
+    # names its machine.
     def dump(computer) = Image.of(computer).to_s
 
     def read(path) = Image.new(Container.parse(File.binread(path)), name: File.basename(path))
@@ -50,8 +51,8 @@ module Badline
     # snapshot that fails leaves the machine as it was.
     def restore(computer, path, &) = read(path).restore(computer, &)
 
-    # A machine's snapshots, as .vsf files and in memory. C64, Vic20 and
-    # C128 each include it.
+    # A machine's snapshots, as .vsf files and in memory. C64, Vic20, C128
+    # and Plus4 each include it.
     module Files
       def save_snapshot(path) = Snapshot.save(self, path)
 
@@ -90,4 +91,8 @@ module Badline
   class C128
     include Snapshot::Files
   end
+
+  class Plus4
+    include Snapshot::Files
+  end
 end

data/lib/badline/storage/g64_image.rb

@@ -47,7 +47,7 @@ module Badline
       # track 1 and 1 for track 1.5, laid out as VICE lays one out: every
       # block as long as the longest track.
       def self.create(path, tracks, half_tracks: HALF_TRACKS)
-        max = [MAX_TRACK_SIZE, *tracks.values.map { |bytes, _| bytes.length }].max
+        max = tracks.values.map { |bytes, _| bytes.length }.push(MAX_TRACK_SIZE).max
         offsets = Array.new(half_tracks, 0)
         zones = Array.new(half_tracks, 0)
         blocks = +"".b

data/lib/badline/storage/tap.rb

@@ -19,10 +19,12 @@ module Badline
       # The file it was read from, expanded, and the file's bytes.
       attr_reader :version, :platform, :path, :bytes
 
-      # A blank version 1 tape for `platform` (0 C64, 1 VIC-20) at `path`,
-      # written to the host file.
+      # A blank tape for `platform` at `path`, written to the host file: a
+      # version 1 tape for the C64 (0) or the VIC-20 (1), and a version 2
+      # C16 tape for the 264 series (2).
       def self.create(path, platform:)
-        File.binwrite(path, (SIGNATURE + [1, platform, 0, 0, 0, 0, 0, 0]).pack("C*"))
+        header = platform == 2 ? C16_SIGNATURE + [2] : SIGNATURE + [1]
+        File.binwrite(path, (header + [platform, 0, 0, 0, 0, 0, 0]).pack("C*"))
         new(path)
       end
 
@@ -61,15 +63,16 @@ module Badline
       # cycle count for a long one (a lone zero, an overflow, on a version 0
       # tape). A version 2 tape records it as two equal halves.
       def record_pulse(cycles)
-        @bytes.slice!(@pos..)
-        if version == 2
-          half = cycles / 2
-          @bytes.concat(encode(cycles - half))
-          @bytes.concat(encode(half))
-        else
-          @bytes.concat(encode(cycles))
-        end
-        @pos = @end = @bytes.length
+        return record(encode(cycles)) unless version == 2
+
+        half = cycles / 2
+        record(encode(cycles - half) + encode(half))
+      end
+
+      # Records a half wave `cycles` long at the position, in place of the
+      # rest of the tape, as a version 2 tape times them.
+      def record_half_wave(cycles)
+        record(encode(cycles))
       end
 
       # Writes the tape back to its host file, with the data size the
@@ -111,6 +114,12 @@ module Badline
         version.zero? ? OVERFLOW : long_pulse
       end
 
+      def record(times)
+        @bytes.slice!(@pos..)
+        @bytes.concat(times)
+        @pos = @end = @bytes.length
+      end
+
       def encode(cycles)
         units = (cycles + 4) / 8
         return [units] if units.between?(1, 0xff)

data/lib/badline/support/checkpoint.rb

@@ -9,8 +9,9 @@ module Badline
     # interface, so taking a checkpoint leaves the machine as it was.
     #
     # Checkpoint.take digests a C64's components, COMPONENTS.
-    # Vic20Checkpoint and C128Checkpoint digest the other families', each
-    # with a list of its own, which a checkpoint carries as +components+.
+    # Vic20Checkpoint, C128Checkpoint and Plus4Checkpoint digest the other
+    # families', each with a list of its own, which a checkpoint carries as
+    # +components+.
     #
     # Colour RAM is digested as the four bits each cell stores: the upper
     # nibble a CPU read sees comes off the open bus.

data/lib/badline/support/plus4_checkpoint.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a 264 series machine: its CPU, its RAM, the TED's
+    # picture, the TED's registers, timers and beam, its sound, and the
+    # CPU's port with the ROM banks. The sound's voices are run up to the
+    # cycle to read them, which changes nothing they do.
+    module Plus4Checkpoint
+      COMPONENTS = %w[cpu ram display ted sound port].freeze
+
+      def self.take(machine)
+        ram = machine.ram
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(ram, ram.length)),
+                         Checkpoint.fnv1a(machine.ted.display),
+                         Checkpoint.fnv1a(ted_state(machine.ted)),
+                         Checkpoint.fnv1a(sound_state(machine.sound)),
+                         Checkpoint.fnv1a(port_state(machine))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.ted_state(ted)
+        Array.new(0x20) { |register| ted.peek(0xff00 + register) } +
+          ted.timer_counts + [ted.line, ted.column, ted.interrupt_flags, ted.cpu_slots]
+      end
+
+      def self.sound_state(sound)
+        [sound.noise, sound.phase(0), sound.phase(1), sound.level, sound.volume, sound.control]
+      end
+
+      def self.port_state(machine)
+        port = machine.port
+        bus = machine.bus
+        [port.ddr, port.data, bus.low_bank, bus.high_bank, bus.rom_selected ? 1 : 0]
+      end
+    end
+  end
+end

data/lib/badline/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: badline
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -182,6 +182,13 @@ files:
 - lib/badline/chips/sid/waveform/noise_writeback.rb
 - lib/badline/chips/ted.rb
 - lib/badline/chips/ted/beam.rb
+- lib/badline/chips/ted/fetches.rb
+- lib/badline/chips/ted/keyed_state.rb
+- lib/badline/chips/ted/modes.rb
+- lib/badline/chips/ted/palette.rb
+- lib/badline/chips/ted/picture.rb
+- lib/badline/chips/ted/sound.rb
+- lib/badline/chips/ted/sound/output.rb
 - lib/badline/chips/ted/timers.rb
 - lib/badline/chips/tia.rb
 - lib/badline/chips/vdc.rb
@@ -376,6 +383,7 @@ files:
 - lib/badline/media/disk_set.rb
 - lib/badline/media/extensions.rb
 - lib/badline/media/not_disk.rb
+- lib/badline/media/plus4_media.rb
 - lib/badline/media/program.rb
 - lib/badline/media/true_drive.rb
 - lib/badline/media/tune.rb
@@ -394,9 +402,13 @@ files:
 - lib/badline/plus4.rb
 - lib/badline/plus4/acia.rb
 - lib/badline/plus4/bus.rb
+- lib/badline/plus4/cassette_sense.rb
 - lib/badline/plus4/cpu.rb
 - lib/badline/plus4/cpu_port.rb
 - lib/badline/plus4/keyboard_port.rb
+- lib/badline/plus4/keyed_modules.rb
+- lib/badline/plus4/keyed_parts.rb
+- lib/badline/plus4/keyed_state.rb
 - lib/badline/plus4/model.rb
 - lib/badline/plus4/user_port.rb
 - lib/badline/region.rb
@@ -448,6 +460,7 @@ files:
 - lib/badline/snapshot/keyed/report.rb
 - lib/badline/snapshot/keyed/writer.rb
 - lib/badline/snapshot/machine_state.rb
+- lib/badline/snapshot/plus4_setup.rb
 - lib/badline/snapshot/storage_setup.rb
 - lib/badline/snapshot/vic20_setup.rb
 - lib/badline/snapshot/vice.rb
@@ -485,6 +498,7 @@ files:
 - lib/badline/support.rb
 - lib/badline/support/c128_checkpoint.rb
 - lib/badline/support/checkpoint.rb
+- lib/badline/support/plus4_checkpoint.rb
 - lib/badline/support/vic20_checkpoint.rb
 - lib/badline/timing.rb
 - lib/badline/version.rb