badline 0.12.1 → 0.13.0

data/lib/badline/{storage → sid_tune}/stil.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "badline/storage/stil/credit"
+require "badline/sid_tune/stil/credit"
 
 module Badline
-  module Storage
+  module SIDTune
     # HVSC's SID Tune Information List, `DOCUMENTS/STIL.txt`: covers,
     # subtune names and composers' comments, keyed by each tune's HVSC path.
     # An entry holds fields for the whole file, then a block per subtune
@@ -89,7 +89,7 @@ module Badline
       def entry(hvsc_path) = entries[hvsc_path]
 
       def entries
-        @entries ||= parse(Storage.latin1(File.binread(@path).bytes))
+        @entries ||= parse(Storage.latin1(::File.binread(@path).bytes))
       end
 
       private

data/lib/badline/sid_tune.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "badline/sid_tune/file"
+require "badline/sid_tune/hvsc"
+require "badline/sid_tune/song_lengths"
+require "badline/sid_tune/stil"

data/lib/badline/snapshot/c128_setup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a C128 was built: its model's name, its SID's model and the
+    # mode it resets into, the arguments C128.new takes.
+    C128Setup = Data.define(:model, :sid_model, :mode)
+
+    class C128Setup
+      MARKER = "C128"
+      SID_MODELS = %i[mos6581 mos8580].freeze
+      MODES = %i[c64 c128].freeze
+
+      # The setup a C128's State starts with.
+      def self.from(state)
+        input = StateReader.new(state)
+        input.marker(MARKER)
+        input.check_stamp
+        read(input)
+      end
+
+      def self.read(input)
+        model = input.string
+        known = C128::Model::ALL.any? { |candidate| candidate.name == model }
+        raise FormatError, "the state names a C128 model badline doesn't know" unless known
+
+        sid_model = SID_MODELS.fetch(input.int)
+        new(model:, sid_model:, mode: MODES.fetch(input.int))
+      rescue IndexError
+        raise FormatError, "the state names a SID or a mode badline doesn't know"
+      end
+
+      def write(out)
+        out.string(model).int(SID_MODELS.index(sid_model)).int(MODES.index(mode))
+      end
+
+      # A machine built this way, at power-on.
+      def build = C128.new(model:, sid_model:, mode:)
+
+      def to_s = [model, sid_model, mode].join(" with a ")
+    end
+  end
+end

data/lib/badline/snapshot/c64_setup.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a C64 was built: its VIC, CIA and SID models, its region, its
+    # RAM expansion, the size of its REU, its KERNAL, whether it has a
+    # datasette and its board, the arguments C64.new takes.
+    C64Setup = Data.define(:vic_model, :cia_model, :sid_model, :region, :ram_expansion, :reu, :kernal, :datasette,
+                           :board)
+
+    class C64Setup
+      MARKER = "COMPUTER"
+      SID_MODELS = %i[mos6581 mos8580].freeze
+      REGIONS = [Region::PAL, Region::NTSC, Region::NTSC_OLD, Region::DREAN].freeze
+      RAM_EXPANSIONS = [:none, *C64::BankedRAM::TYPES.keys].freeze
+      KERNALS = C64::Bus::ROMs::KERNALS.keys.freeze
+      BOARDS = C64::Bus::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?, board: address_bus.board)
+      end
+
+      # The setup a C64's State starts with.
+      def self.from(state)
+        input = StateReader.new(state)
+        input.marker(MARKER)
+        input.check_stamp
+        read(input)
+      end
+
+      def self.read(input)
+        new(vic_model: Chips::VIC::MODELS.fetch(input.int), cia_model: Chips::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: KERNALS.fetch(input.int), datasette: input.boolean?, board: BOARDS.fetch(input.int))
+      rescue IndexError
+        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
+
+      # An REU's size in K, written as 0 for none.
+      def self.reu(size_kb)
+        return nil if size_kb.zero?
+        return size_kb if C64::REU::SIZES_KB.include?(size_kb)
+
+        raise FormatError, "the state names a #{size_kb}K REU, which badline doesn't build"
+      end
+
+      def write(out)
+        out.int(Chips::VIC::MODELS.index(vic_model)).int(Chips::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).int(BOARDS.index(board))
+      end
+
+      # A machine built this way, at power-on.
+      def build
+        C64.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
+      # Badline::Model's.
+      def to_s
+        model = Model.of(self)
+        parts = [vic_model, cia_model, sid_model, region.name]
+        parts.unshift(model.name) if model
+        parts << ram_expansion if ram_expansion
+        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
+  end
+end

data/lib/badline/snapshot/image.rb

@@ -25,13 +25,13 @@ module Badline
       # A new machine, built as the snapshot's was and restored from it. A
       # badline snapshot restores from its BADLINE module alone, which
       # carries everything its VICE modules do, and a VICE one through the
-      # modules badline reads. Yields a line for each thing left out, or
-      # warns it without a block.
+      # modules badline reads. xvic's and x128's own modules aren't read.
+      # Yields a line for each thing left out, or warns it without a block.
       def load(&)
-        return load_vic20(&) if vic20?
-        return load_c128(&) if c128?
+        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?
 
-        computer = badline? ? opening { Computer.restored(state) } : Vice.setup(@container).build
+        computer = badline? ? opening { Setup.restored(state) } : Vice.setup(@container).build
         tell(badline? ? state_report(computer) : Vice::Restore.apply(@container, computer), &)
         computer
       end
@@ -54,26 +54,6 @@ module Badline
 
       def section = @container[MachineState::NAME]
 
-      # A VIC-20 restores from its BADLINE module alone. xvic's own modules
-      # aren't read.
-      def load_vic20(&)
-        raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" unless badline?
-
-        machine = Vic20.restored(state)
-        tell(state_report(machine), &)
-        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/machine_state.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module Snapshot
-    # The BADLINE module: a State from Computer#snapshot, which restores the
+    # The BADLINE module: a State from C64#snapshot, which restores the
     # machine exactly where it was saved. VICE skips a module it doesn't
     # know.
     #

data/lib/badline/snapshot/setup.rb

@@ -1,75 +1,31 @@
 # frozen_string_literal: true
 
+require "badline/snapshot/c64_setup"
+require "badline/snapshot/vic20_setup"
+require "badline/snapshot/c128_setup"
+
 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, 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?, board: address_bus.board)
-      end
-
-      # 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,
-            board: input.schema > 5 ? BOARDS.fetch(input.int) : :c64)
-      rescue IndexError
-        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
-
-      # An REU's size in K, written as 0 for none.
-      def self.reu(size_kb)
-        return nil if size_kb.zero?
-        return size_kb if REU::SIZES_KB.include?(size_kb)
-
-        raise FormatError, "the state names a #{size_kb}K REU, which badline doesn't build"
-      end
-
-      def write(out)
-        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).int(BOARDS.index(board))
+    # How the machine a State was taken of was built, so a machine to
+    # restore it into can be built first. A State starts with its family's
+    # marker, the stamp (StateWriter#stamp) and the family's setup:
+    # C64Setup, Vic20Setup or C128Setup. Each reads its setup from a State
+    # (.from) or from the fields after the stamp (.read), writes it
+    # (#write), builds a machine that way at power-on (#build) and names it
+    # (#to_s).
+    module Setup
+      # The setup of the family whose marker the State starts with.
+      def self.read(state)
+        family = StateReader.new(state).string
+        return Vic20Setup.from(state) if family == Vic20Setup::MARKER
+        return C128Setup.from(state) if family == C128Setup::MARKER
+
+        C64Setup.from(state)
       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:, board:)
-      end
-
-      # The chips, led by the model's name when they make one of
-      # Badline::Model's.
-      def to_s
-        model = Model.of(self)
-        parts = [vic_model, cia_model, sid_model, region.name]
-        parts.unshift(model.name) if model
-        parts << ram_expansion if ram_expansion
-        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
+      # A new machine, built as the one a State was taken of, at that
+      # state.
+      def self.restored(state) = read(state).build.apply_state(state)
     end
   end
 end

data/lib/badline/snapshot/state.rb

@@ -8,19 +8,14 @@ module Badline
 
     # A machine's state, held in memory: the Integers each chip writes in
     # turn, and the byte strings for memories, names and paths. Booleans
-    # are written as 0 and 1. Computer#snapshot takes one and
-    # Computer#restore puts it back.
+    # are written as 0 and 1. C64#snapshot takes one and
+    # C64#restore puts it back.
     class State
       # 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, layout 4, without the VIA shift
-      # register's clock delay, layout 5, without the board in the setup,
-      # layout 6, without the C128's Z80, layout 7, without a 1581 on the
-      # serial bus, and layout 8, with the VIC's unused cycle count and
-      # pending-write flag, still read.
-      SCHEMA = 9
-      READABLE = [3, 4, 5, 6, 7, 8, SCHEMA].freeze
+      # fails before anything is read into a machine. A State only reads in
+      # the layout and the badline version that wrote it.
+      SCHEMA = 10
 
       attr_reader :values, :strings
 
@@ -110,16 +105,12 @@ module Badline
     # device 8 serves is left out, and a true drive's disk keeps the
     # state's tracks without its image file.
     class StateReader
-      # The layout check_stamp found.
-      attr_reader :schema
-
       def initialize(state, detached: false)
         @values = state.values
         @strings = state.strings
         @value = 0
         @string = 0
         @detached = detached
-        @schema = State::SCHEMA
       end
 
       def detached? = @detached
@@ -170,13 +161,12 @@ module Badline
         raise FormatError, "expected #{name} in the state, found #{found[0, 20].inspect}" unless found == name
       end
 
-      # Fails unless the State was written in a layout this badline reads
-      # (State::READABLE) by this badline version.
+      # Fails unless the State was written in this layout by this badline
+      # version.
       def check_stamp
         schema = int
         version = string
-        @schema = schema
-        return if State::READABLE.include?(schema) && version == VERSION
+        return if schema == State::SCHEMA && version == VERSION
 
         raise FormatError, "the state was written by badline #{version.inspect} in layout #{schema}, " \
                            "and this is badline #{VERSION}, layout #{State::SCHEMA}"

data/lib/badline/snapshot/storage_setup.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # The storage device 8 serves through the traps, as a State holds it:
+    # its kind, its path and, for an archive or a disk image, its bytes, so
+    # it opens again without the host file.
+    module StorageSetup
+      HOST_DIRECTORY = 0
+      D64 = 1
+      D71 = 2
+      D81 = 3
+      T64_ARCHIVE = 4
+
+      module_function
+
+      # The same directory by its path, an archive with the bytes it held,
+      # or a disk image with its path, whether it is write-protected, and
+      # its bytes with the error table after them.
+      def write(storage, out)
+        if storage.is_a?(Storage::HostDirectory)
+          out.int(HOST_DIRECTORY).string(File.expand_path(storage.path))
+        elsif storage.is_a?(Storage::T64)
+          out.int(T64_ARCHIVE).string(File.expand_path(storage.path)).blob(storage.bytes)
+        else
+          write_image(storage, out)
+        end
+      end
+
+      def write_image(image, out)
+        out.int(image_kind(image)).string(File.expand_path(image.path)).boolean(image.read_only?).blob(image.contents)
+      end
+
+      def image_kind(image)
+        return D71 if image.is_a?(Storage::D71Image)
+        return D64 if image.is_a?(Storage::D64Image)
+        return D81 if image.is_a?(Storage::D81Image)
+
+        raise ArgumentError, "#{image.class} can't go in a snapshot"
+      end
+
+      # Opens the storage `write` wrote: the same directory by its path, an
+      # archive with the bytes it held, or a disk image with the bytes it
+      # held, writes and all. A detached reader gets the image
+      # write-protected, and Storage::Unavailable for a directory.
+      def read(input)
+        kind = input.int
+        path = input.string
+        case kind
+        when HOST_DIRECTORY then input.detached? ? Storage::Unavailable.new : Storage::HostDirectory.new(path)
+        when T64_ARCHIVE then Storage::T64.new(path, bytes: input.blob)
+        else read_image(kind, path, input)
+        end
+      end
+
+      def read_image(kind, path, input)
+        read_only = input.boolean? || input.detached?
+        bytes = input.blob
+        case kind
+        when D64 then Storage::D64Image.new(path, read_only:, bytes:)
+        when D71 then Storage::D71Image.new(path, read_only:, bytes:)
+        when D81 then Storage::D81Image.new(path, read_only:, bytes:)
+        else raise FormatError, "unknown storage #{kind} in the state"
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vic20_setup.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    # How a VIC-20 was built: its RAM expansion, a key of
+    # Vic20::Bus::RAM_CONFIGURATIONS, the argument Vic20.new takes.
+    Vic20Setup = Data.define(:ram)
+
+    class Vic20Setup
+      MARKER = "VIC20"
+      RAM_CONFIGURATIONS = Vic20::Bus::RAM_CONFIGURATIONS.keys.freeze
+
+      # The setup a VIC-20's State starts with.
+      def self.from(state)
+        input = StateReader.new(state)
+        input.marker(MARKER)
+        input.check_stamp
+        read(input)
+      end
+
+      def self.read(input)
+        new(ram: RAM_CONFIGURATIONS.fetch(input.int))
+      rescue IndexError
+        raise FormatError, "the state names a VIC-20 RAM expansion badline doesn't know"
+      end
+
+      def write(out)
+        out.int(RAM_CONFIGURATIONS.index(ram))
+      end
+
+      # A machine built this way, at power-on.
+      def build = Vic20.new(ram:)
+
+      def to_s = ram.to_s
+    end
+  end
+end

data/lib/badline/snapshot/vice/c64_mem.rb

@@ -44,7 +44,7 @@ module Badline
           computer.ram.write(0, fields.bytes(0x10000))
           fields.skip(3 + 8)
           charge = FLOATING.sum { |bit| fields.flag? ? bit : 0 }
-          driven = ddr & AddressBus::PORT_FLOATING
+          driven = ddr & C64::Bus::PORT_FLOATING
           computer.address_bus.restore_port(ddr, data, (data & driven) | (charge & ~driven & 0xff))
         end
       end

data/lib/badline/snapshot/vice/restore.rb

@@ -25,7 +25,7 @@ module Badline
         # so nothing it was doing carries into the snapshot's machine.
         def import(container, computer)
           setup = Vice.setup(container)
-          ours = Setup.of(computer.address_bus)
+          ours = C64Setup.of(computer.address_bus)
           raise FormatError, "the snapshot is of a machine with #{setup}, not #{ours}" unless setup == ours
 
           apply(container, setup.build)

data/lib/badline/snapshot/vice/reu1764.rb

@@ -36,7 +36,7 @@ module Badline
         # The REU's size in K, which builds the machine.
         def size_kb(section)
           size = FieldReader.new(section).dword
-          return size if REU::SIZES_KB.include?(size)
+          return size if C64::REU::SIZES_KB.include?(size)
 
           raise FormatError, "#{section}: a #{size}K REU, which badline doesn't build"
         end

data/lib/badline/snapshot/vice/reu_fields.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      # The REU as VICE's REU1764 module holds it (Snapshot::Vice::REU1764):
+      # the registers as they read from $DF00, and the RAM.
+      module ViceFields
+        # The sixteen bytes the REC's registers read from $DF00, without
+        # what reading the status does, as VICE's REU1764 module holds them.
+        def register_file = Array.new(16) { |register| register_value(register) }
+
+        # Sets the registers from a register file, as writing them would but
+        # without starting a transfer: each address and the length set both
+        # the counter and the value it starts from. A command with the
+        # execute bit set and the $FF00 trigger on arms the REC.
+        def restore_registers(values)
+          @status = (values[STATUS] & (INTERRUPT_PENDING | END_OF_BLOCK | FAULT)) | @chips
+          @command = values[COMMAND]
+          @c64 = @c64_start = values[C64_LOW] | (values[C64_HIGH] << 8)
+          @expansion = @expansion_start = values[EXPANSION_LOW] | (values[EXPANSION_HIGH] << 8)
+          @bank = @bank_start = values[EXPANSION_BANK] & @bank_bits
+          @length = @length_start = values[LENGTH_LOW] | (values[LENGTH_HIGH] << 8)
+          @interrupt_mask = values[INTERRUPT_MASK] | 0x1f
+          @address_control = values[ADDRESS_CONTROL] | 0x3f
+          @armed = @command.anybits?(EXECUTE) && @command.nobits?(NO_FF00_TRIGGER)
+          @requested = @running = @ba_was_low = false
+          interrupt(@status.anybits?(INTERRUPT_PENDING))
+        end
+
+        # The RAM, every byte of it, as one string.
+        def ram_contents = @ram.contents
+
+        def restore_ram(bytes) = @ram.restore(bytes)
+      end
+
+      include ViceFields
+    end
+  end
+end

data/lib/badline/snapshot/vice.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "badline/snapshot/vice/fields"
 require "badline/snapshot/vice/main_cpu"
 require "badline/snapshot/vice/c64_mem"
 require "badline/snapshot/vice/cias"
 require "badline/snapshot/vice/cias_import"
 require "badline/snapshot/vice/sid_registers"
 require "badline/snapshot/vice/sid_extended"
+require "badline/snapshot/vice/reu_fields"
 require "badline/snapshot/vice/reu1764"
 require "badline/snapshot/vice/peripherals"
 require "badline/snapshot/vice/vicii"
@@ -47,7 +49,7 @@ module Badline
       # The copy is detached from the host's files (Snapshot::StateReader),
       # so it reads none and its traps write none.
       def self.settled(state)
-        copy = Computer.restored(state, detached: true)
+        copy = C64.restored(state, detached: true)
         (BOUNDARY_CYCLES + TRANSFER_CYCLES).times do
           break if copy.cpu.boundary? && !copy.reu&.dma?
 
@@ -67,10 +69,10 @@ module Badline
         sid = container[SIDRegisters::NAME] ? SIDRegisters.model(container[SIDRegisters::NAME]) : :mos6581
         reu = container[REU1764::NAME]
         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,
-                  board: :c64)
+        C64Setup.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,
+                     board: :c64)
       end
     end
   end

data/lib/badline/snapshot.rb

@@ -4,7 +4,6 @@ require "zlib"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
 require "badline/snapshot/container"
-require "badline/snapshot/fields"
 require "badline/snapshot/machine_state"
 require "badline/snapshot/vice"
 require "badline/snapshot/image"
@@ -14,7 +13,7 @@ module Badline
   #
   # A snapshot badline writes carries VICE's modules for what both
   # emulators model, and a BADLINE module holding the State
-  # Computer#snapshot takes, with everything badline needs to carry on
+  # C64#snapshot takes, with everything badline needs to carry on
   # exactly where it stopped. VICE skips modules it doesn't know. Restoring
   # a badline snapshot uses the BADLINE module alone; a snapshot from VICE
   # restores through its modules, as far as they map, and reports the
@@ -48,7 +47,7 @@ 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. Computer, Vic20 and C128 each
+    # A machine's snapshots as .vsf files. C64, Vic20 and C128 each
     # include it.
     module Files
       def save_snapshot(path) = Snapshot.save(self, path)
@@ -57,7 +56,7 @@ module Badline
     end
   end
 
-  class Computer
+  class C64
     include Snapshot::Files
   end
 

data/lib/badline/storage/d64_image.rb

@@ -15,8 +15,6 @@ module Badline
         count
       end
 
-      def storage_kind = D64
-
       # The sides of a disk the image's tracks fill.
       def sides = 1
 

data/lib/badline/storage/d71_image.rb

@@ -5,8 +5,6 @@ module Badline
     class D71Image < D64Image
       ERROR_TABLES = { 351_062 => 1366 }.freeze
 
-      def storage_kind = D71
-
       # Tracks 1-35 on the first side and 36-70 on the second.
       def track_count = 70
 

data/lib/badline/storage/d81_image.rb

@@ -5,8 +5,6 @@ module Badline
     class D81Image < DiskImage
       ERROR_TABLES = { 822_400 => 3200 }.freeze
 
-      def storage_kind = D81
-
       private
 
       def error_tables = ERROR_TABLES