badline 0.13.0 → 0.14.0

data/lib/badline/drives/model1581/disk.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "badline/drives/model1581/disk/saved_state"
-
 module Badline
   module Drives
     class Model1581
@@ -24,8 +22,6 @@ module Badline
       # file. A track formatted another way stays on the disk alone. The disk
       # is write-protected when the image won't take writes.
       class Disk
-        include SavedState
-
         CYLINDERS = 80
         SIDES = 2
 

data/lib/badline/drives/model1581/keyed_state.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Model1581
+      class WD1772
+        PHASE_NAMES = %w[idle spin_up stepped settled search read_data write_gate write_data read_track track_index
+                         write_track motor_idle index_interrupt settle_search read_address write_track_start
+                         starting].freeze
+        MODE_NAMES = %w[read write address verify_track].freeze
+
+        # The controller in a keyed snapshot module (BL-D8-FDC): its own
+        # cycle count, the step of the command running and what the search
+        # is for by name, the registers and lines, the command's counters,
+        # and when its next step, its deadline and the next ID field fall,
+        # in its cycles from now, each absent when it never does.
+        def save_fields(out)
+          out.int("now", @now).text("phase", PHASE_NAMES.fetch(@phase)).text("mode", MODE_NAMES.fetch(@mode))
+          [["due_in", @due], ["deadline_in", @deadline], ["id_in", @id_at]].each do |key, at|
+            out.int(key, at - @now) unless at == NEVER
+          end
+          out.int("command", @command).int("track", @track).int("sector", @sector).int("data", @data)
+          out.int("status", @status).int("steps", @steps).int("count", @count).int("after_spin_up", @after_spin_up)
+          out.int("found", @found).int("index", @index).int("crc", @crc).int("write_id", @write_id).int("size", @size)
+          save_flag_fields(out)
+          out.bytes("bytes", @bytes).ints("syncs", @syncs.map { |sync| sync ? 1 : 0 })
+        end
+
+        def load_fields(input)
+          @now = input.int("now", @now)
+          @phase = PHASE_NAMES.index(input.choice("phase", PHASE_NAMES, "idle")).to_i
+          @mode = MODE_NAMES.index(input.choice("mode", MODE_NAMES, "read")).to_i
+          @due = at_fields(input, "due_in")
+          @deadline = at_fields(input, "deadline_in")
+          @id_at = at_fields(input, "id_in")
+          load_register_fields(input)
+          load_flag_fields(input)
+          @bytes = input.bytes("bytes", "".b).bytes
+          @syncs = input.ints("syncs", []).map { |sync| sync == 1 }
+        end
+
+        private
+
+        def at_fields(input, key)
+          cycles = input.optional_int(key)
+          cycles.nil? ? NEVER : @now + cycles
+        end
+
+        def load_register_fields(input)
+          @command = input.byte("command", @command)
+          @track = input.byte("track", @track)
+          @sector = input.byte("sector", @sector)
+          @data = input.byte("data", @data)
+          @status = input.byte("status", @status)
+          @steps = input.int("steps", @steps)
+          @count = input.int("count", @count)
+          @after_spin_up = input.int("after_spin_up", @after_spin_up)
+          @found = input.int("found", @found)
+          @index = input.int("index", @index)
+          @crc = input.int("crc", @crc)
+          @write_id = input.int("write_id", @write_id)
+          @size = input.int("size", @size)
+        end
+
+        def save_flag_fields(out)
+          out.bool("type1", @type1).bool("drq", @drq).bool("intrq", @intrq).bool("motor_on", @motor_on)
+          out.bool("inward", @inward).bool("crc_good", @crc_good).bool("gate_open", @gate_open).bool("late", @late)
+          out.bool("settling", @settling)
+        end
+
+        def load_flag_fields(input)
+          @type1 = input.bool("type1", @type1)
+          @drq = input.bool("drq", @drq)
+          @intrq = input.bool("intrq", @intrq)
+          @motor_on = input.bool("motor_on", @motor_on)
+          @inward = input.bool("inward", @inward)
+          @crc_good = input.bool("crc_good", @crc_good)
+          @gate_open = input.bool("gate_open", @gate_open)
+          @late = input.bool("late", @late)
+          @settling = input.bool("settling", @settling)
+        end
+      end
+
+      class Mechanism
+        # The head, the motor and the disk-change switch in a keyed snapshot
+        # module (BL-D8-MECH), with the disk's angle as it stands `now`, on
+        # the controller's clock.
+        def save_fields(out, now)
+          out.int("cylinder", @cylinder).int("side", @side).int("angle", angle(now)).bool("motor", @motor)
+          out.bool("changed", @changed)
+        end
+
+        # Puts `disk` under the head without flushing the one there, as a
+        # snapshot load replaces it.
+        def load_fields(input, disk, now)
+          @disk = disk
+          @cylinder = input.int("cylinder", @cylinder)
+          @side = input.masked("side", @side, 1)
+          @angle = input.int("angle", @angle)
+          @since = now
+          @motor = input.bool("motor", @motor)
+          @changed = input.bool("changed", @changed)
+        end
+      end
+
+      class Disk
+        # A disk's fields in a keyed snapshot module (BL-D8-DISK): the image
+        # file's path and how it was opened, the image as last flushed,
+        # embedded, each track the head wrote since the disk went in, sector
+        # by sector as the WD1772 sees them, and the tracks written since the
+        # last flush.
+        module KeyedState
+          # The image's path, expanded, and whether it was opened read-only,
+          # for a disk from Disk.open. Nil for a disk made another way.
+          attr_reader :path, :read_only
+
+          # Notes the image's path and how it was opened.
+          def opened(path, read_only)
+            @path = File.expand_path(path)
+            @read_only = read_only
+            self
+          end
+
+          def save_fields(out)
+            path = @path
+            out.text("path", path) if path
+            out.bool("read_only", @read_only == true)
+            image = @image
+            out.text("image.path", image.path.to_s).bytes("image", image.contents) if image
+            changed = @changed.keys.sort
+            out.ints("changed", changed)
+            changed.each { |index| save_track_fields(out, "track#{index}.", @tracks[index]) }
+            out.ints("written", @written.keys)
+          end
+
+          def load_track_fields(input)
+            @changed.clear
+            input.ints("changed", []).each do |index|
+              @tracks[index] = load_track_sectors(input, "track#{index}.")
+              @changed[index] = true
+            end
+            @written.clear
+            input.ints("written", []).each { |index| @written[index] = true }
+            self
+          end
+
+          private
+
+          def save_track_fields(out, prefix, track)
+            out.int("#{prefix}sectors", track.sectors.length)
+            track.sectors.each_with_index do |sector, number|
+              save_field_fields(out, "#{prefix}sector#{number}.id.", sector.id)
+              data = sector.data
+              save_field_fields(out, "#{prefix}sector#{number}.data.", data) if data
+            end
+          end
+
+          def save_field_fields(out, prefix, field)
+            out.int("#{prefix}mark", field.mark).bytes("#{prefix}bytes", field.bytes)
+            out.bool("#{prefix}good", field.good).bool("#{prefix}deleted", field.deleted)
+          end
+
+          def load_track_sectors(input, prefix)
+            Track.new(Array.new(input.int("#{prefix}sectors", 0)) do |number|
+              id = load_field_fields(input, "#{prefix}sector#{number}.id.")
+              data = input.optional_int("#{prefix}sector#{number}.data.mark")
+              Track::Sector.new(id, data.nil? ? nil : load_field_fields(input, "#{prefix}sector#{number}.data."))
+            end)
+          end
+
+          def load_field_fields(input, prefix)
+            Track::Field.new(input.int("#{prefix}mark", 0), input.bytes("#{prefix}bytes", "".b).bytes,
+                             input.bool("#{prefix}good", true), input.bool("#{prefix}deleted", false))
+          end
+        end
+
+        include KeyedState
+
+        # The disk a keyed snapshot module describes: its embedded image,
+        # with the tracks the module holds laid over it. The image takes
+        # writes back to its file only while that file is there and the
+        # reader isn't `detached`. With no image, the disk is the tracks
+        # alone.
+        def self.from_fields(input, detached: false)
+          path = input.text("path", "")
+          read_only = input.bool("read_only", false)
+          bytes = input.bytes("image", "".b).bytes
+          image_path = input.text("image.path", "")
+          disk = bytes.empty? ? Disk.new : Disk.new(image_from(image_path, bytes, read_only || detached))
+          disk.opened(path, read_only || bytes.empty?) unless path.empty?
+          disk.load_track_fields(input)
+        end
+
+        def self.image_from(path, bytes, read_only)
+          Storage::D81Image.new(File.file?(path) ? path : "", read_only:, bytes:)
+        end
+      end
+
+      class Bus
+        # The drive's RAM and the byte last on its data bus, in a keyed
+        # snapshot module (BL-D8-RAM).
+        def save_fields(out)
+          out.int("data", @data).bytes("ram", @ram.read(0, @ram.length))
+        end
+
+        def load_fields(input)
+          @data = input.byte("data", @data)
+          ram = @ram.read(0, @ram.length)
+          @ram.write(0, input.bytes_into("ram", ram))
+          @watching = false
+        end
+      end
+
+      # The drive's own fields in a keyed snapshot module (BL-D8): its
+      # model, its clock phase and cycle count, the ATN level it last saw
+      # and the host's lines as the serial port latched them. The fast
+      # serial direction and the ports' lines come from the 8520 once it
+      # is loaded.
+      module KeyedState
+        def save_fields(out)
+          settle!
+          out.text("model", model_name).int("phase", @phase).int("cycles", @cycles).bool("atn", @atn)
+          @serial_port.save_fields(out, "serial.")
+          out
+        end
+
+        def load_fields(input)
+          settle!
+          input.choice("model", [model_name], model_name)
+          @phase = input.int("phase", @phase)
+          @cycles = input.int("cycles", @cycles)
+          @atn = input.bool("atn", @atn)
+          @serial_port.load_fields(input, "serial.")
+        end
+
+        def restored!
+          @fast_serial_out = @cia.port_b_lines.anybits?(FAST_SERIAL_OUT)
+          ports_written
+          push_fast_output(@fast_serial_out ? fast_pins : 0)
+          forget_orbits
+        end
+
+        # The drive as modules of its own, as the 1541's, with the 8520 and
+        # the WD1772 in place of the VIAs.
+        def save_modules(sections, name)
+          sections << Snapshot::Keyed.section(name) { |out| save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-RAM") { |out| @bus.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CIA") { |out| @cia.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-CPU") { |out| @cpu.save_fields(out) }
+          sections << Snapshot::Keyed.section("#{name}-FDC") { |out| @fdc.save_fields(out) }
+          now = @fdc.now
+          sections << Snapshot::Keyed.section("#{name}-MECH") { |out| @mechanism.save_fields(out, now) }
+          disk = @mechanism.disk
+          sections << Snapshot::Keyed.section("#{name}-DISK") { |out| disk.save_fields(out) } if disk
+          sections
+        end
+
+        # The drive from its modules, `input` being its own. The mechanism
+        # takes the disk's angle on the WD1772's clock, so it loads after
+        # the controller.
+        def load_modules(modules, input, name)
+          load_fields(input)
+          @bus.load_fields(modules.required("#{name}-RAM"))
+          @cia.load_fields(modules.required("#{name}-CIA"))
+          @cpu.load_fields(modules.required("#{name}-CPU"))
+          @fdc.load_fields(modules.required("#{name}-FDC"))
+          disk = modules.optional("#{name}-DISK")
+          mechanism = modules.required("#{name}-MECH")
+          @mechanism.load_fields(mechanism, disk.nil? ? nil : Disk.from_fields(disk, detached: modules.detached?),
+                                 @fdc.now)
+          @cia.restored!
+          @cpu.restored!
+          restored!
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/model1581/mechanism.rb

@@ -92,27 +92,6 @@ module Badline
         def write(track)
           @disk&.write(@cylinder, @side, track)
         end
-
-        # The disk (Disk#save_state) and the motor, the head and the turn.
-        def save_state(out)
-          out.boolean(!@disk.nil?)
-          @disk&.save_state(out)
-          out.int(@cylinder).int(@side).int(@angle).int(@since).boolean(@motor).boolean(@changed)
-        end
-
-        # Puts the state back, reusing the disk in when it's the one the state
-        # names (Disk::SavedState.load). A disk taken out is flushed.
-        def load_state(input)
-          disk = input.boolean? ? Disk::SavedState.load(input, @disk) : nil
-          flush unless disk.equal?(@disk)
-          @disk = disk
-          @cylinder = input.int
-          @side = input.int
-          @angle = input.int
-          @since = input.int
-          @motor = input.boolean?
-          @changed = input.boolean?
-        end
       end
     end
   end

data/lib/badline/drives/model1581/slot.rb

@@ -55,24 +55,6 @@ module Badline
 
         # Whether the 1581 is device 8.
         def drive1581_on_device8? = @drive1581&.device == KernalTrap::Routine::DEVICE
-
-        # The 1581 on the serial bus, with its device number.
-        def save_drive1581(out)
-          out.boolean(!@drive1581.nil?)
-          return unless @drive1581
-
-          out.int(@drive1581.device)
-          @drive1581.save_state(out)
-        end
-
-        def load_drive1581(input)
-          return detach_drive1581 unless input.boolean?
-
-          device = input.int
-          detach_drive1581 if @drive1581 && @drive1581.device != device
-          attach_drive1581(Model1581.new(device:)) unless @drive1581
-          @drive1581.load_state(input)
-        end
       end
     end
   end

data/lib/badline/drives/model1581/wd1772.rb

@@ -6,7 +6,6 @@ require "badline/drives/model1581/wd1772/stepping"
 require "badline/drives/model1581/wd1772/sectors"
 require "badline/drives/model1581/wd1772/sector_writes"
 require "badline/drives/model1581/wd1772/tracks"
-require "badline/drives/model1581/wd1772/saved_state"
 
 module Badline
   module Drives
@@ -45,7 +44,6 @@ module Badline
         include Sectors
         include SectorWrites
         include Tracks
-        include SavedState
 
         BYTE = 64
         START = 32

data/lib/badline/drives/model1581.rb

@@ -9,7 +9,8 @@ require "badline/drives/model1581/wd1772"
 require "badline/drives/model1581/cpu"
 require "badline/drives/model1581/serial_port"
 require "badline/drives/model1581/bus"
-require "badline/drives/model1581/saved_state"
+require "badline/drives/model1581/keyed_state"
+require "badline/drives/model1581/slot"
 
 module Badline
   module Drives
@@ -39,7 +40,6 @@ module Badline
     class Model1581
       include Engine::Core
       include Engine::FastSerial
-      include SavedState
 
       CLOCK_HZ = 2_000_000
 

data/lib/badline/drives.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# The drives and the serial bus badline/core's machines share. The C128's
+# 1571 stays out of the core: badline/c128 requires it.
+require "badline/drives/datasette"
+require "badline/drives/serial_bus"
+require "badline/drives/model1541"
+require "badline/drives/model1581"

data/lib/badline/frontend/app.rb

@@ -21,7 +21,7 @@ module Badline
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
         @screens = Screens.new(computer)
-        @led = DriveLed.for(computer)
+        @led = DriveLed.new(computer)
         @controls = Controls.new(computer)
         @window = MachineWindow.new(@screens.screen, vsync: @pacer.vsync?)
         @pacer.fit(@window.refresh_rate) if @pacer.vsync?
@@ -128,7 +128,7 @@ module Badline
         @computer = computer
         @screens.computer = computer
         fit_window
-        @led = DriveLed.for(computer)
+        @led = DriveLed.new(computer)
         @controls.computer = computer
         @gamepads.computer = computer
         @sound.switch(computer.sound_source, computer.timing.clock_hz)
@@ -220,7 +220,7 @@ module Badline
         renderer = @window.renderer
         SDL.SDL_RenderClear(renderer)
         SDL.SDL_RenderCopy(renderer, @window.texture, nil, nil)
-        @led&.draw(renderer, @window.width, @window.height)
+        @led.draw(renderer, @window.width, @window.height)
         @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) }
         SDL.SDL_RenderPresent(renderer)
       end

data/lib/badline/frontend/boot.rb

@@ -10,7 +10,7 @@ module Badline
     # attach, an --at key names nothing or an event fails, which it warns
     # about.
     def self.run(options)
-      error = Timeline.error(options.timeline)
+      error = Timeline.error(options.timeline, options.family)
       unless error.empty?
         warn "#{options.program}: #{error}"
         return 1

data/lib/badline/frontend/controls.rb

@@ -29,6 +29,7 @@ module Badline
         @arrows_port = 2
         @mouse = Input::Mouse1351.new
         @paddles = Input::Paddles.new
+        @held = {}
       end
 
       # Routes the input to another machine, the pot device going into its
@@ -73,10 +74,8 @@ module Badline
       def key(scancode, down)
         if joystick_mode? && Keys.joystick?(scancode)
           joystick_key(scancode, down)
-        elsif @computer.family == :c128
-          c128_key(Keys.c128_key(scancode, @computer.mode), down)
         else
-          c64_key(Keys.c64_key(scancode), down)
+          machine_key(scancode, down)
         end
       end
 
@@ -104,6 +103,23 @@ module Badline
 
       private
 
+      # A host key lets go of the key it pressed, though the C128 has
+      # switched between C64 and C128 mode since and maps it elsewhere.
+      def machine_key(scancode, down)
+        @held[scancode] = host_key(scancode) if down || !@held.key?(scancode)
+        key = @held[scancode]
+        @held.delete(scancode) unless down
+        if @computer.family == :c128
+          c128_key(key, down)
+        else
+          c64_key(key, down)
+        end
+      end
+
+      def host_key(scancode)
+        @computer.family == :c128 ? Keys.c128_key(scancode, @computer.mode) : Keys.c64_key(scancode)
+      end
+
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
       def c64_key(key, down)
         if key == :restore

data/lib/badline/frontend/drive_led.rb

@@ -2,48 +2,71 @@
 
 module Badline
   module Frontend
-    # The true drive's red LED, drawn over the bottom right corner of the
-    # border: bright while the DOS lights it, as it does while a file is
-    # open or after an error, and dim otherwise.
+    # The true drive's LEDs, drawn over the bottom right corner of the
+    # border: the red activity LED, bright while the DOS lights it, as it
+    # does while a file is open or after an error, and dim otherwise, and
+    # left of it the green power LED, which a 1581 flashes after an error.
+    # They follow whichever true drive the machine has, one plugged in
+    # after start among them, and are drawn only while it has one.
     class DriveLed
       WIDTH = 12
       HEIGHT = 4
 
+      # The power LED's distance left of the activity LED.
+      POWER_OFFSET = WIDTH + 4
+
       LIT = [0xff, 0x20, 0x20].freeze
       DARK = [0x40, 0x00, 0x00].freeze
+      POWER_LIT = [0x20, 0xff, 0x20].freeze
+      POWER_DARK = [0x00, 0x40, 0x00].freeze
 
-      # The LED of the machine's true drive, or nil without one.
-      def self.for(computer)
-        drive = computer.true_drive
-        drive ? new(drive) : nil
-      end
-
-      # Sets SDL.led_rect to where the LED goes on a screen `width` by
-      # `height`.
-      def self.place(width, height)
+      # Sets SDL.led_rect to where the activity LED goes on a screen `width`
+      # by `height`, or with `offset` that many pixels left of it.
+      def self.place(width, height, offset = 0)
         rect = SDL.led_rect
-        SDL.rect_x(rect, width - WIDTH - 8)
+        SDL.rect_x(rect, width - WIDTH - 8 - offset)
         SDL.rect_y(rect, height - HEIGHT - 6)
         SDL.rect_w(rect, WIDTH)
         SDL.rect_h(rect, HEIGHT)
       end
 
-      def initialize(drive)
-        @drive = drive
+      def initialize(computer)
+        @computer = computer
       end
 
-      def lit? = @drive.led_on?
+      # Whether the machine has a true drive, and so LEDs to draw.
+      def shown? = !@computer.true_drive.nil?
+
+      def lit?
+        drive = @computer.true_drive
+        drive.nil? ? false : drive.led_on?
+      end
+
+      def power_lit?
+        drive = @computer.true_drive
+        drive.nil? ? false : drive.power_led_on?
+      end
 
       def color = lit? ? LIT : DARK
 
-      # Fills the LED's rectangle on a screen `width` by `height` in its
-      # colour, then puts back the black that RenderClear clears with.
+      def power_color = power_lit? ? POWER_LIT : POWER_DARK
+
+      # Fills the LEDs' rectangles on a screen `width` by `height` in their
+      # colours, then puts back the black that RenderClear clears with.
       def draw(renderer, width, height)
-        DriveLed.place(width, height)
-        rgb = color
+        return unless shown?
+
+        fill(renderer, width, height, 0, color)
+        fill(renderer, width, height, POWER_OFFSET, power_color)
+        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
+      end
+
+      private
+
+      def fill(renderer, width, height, offset, rgb)
+        DriveLed.place(width, height, offset)
         SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
         SDL.SDL_RenderFillRect(renderer, SDL.led_rect)
-        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
       end
     end
   end

data/lib/badline/frontend/menu/menu_dialogs.rb

@@ -8,8 +8,8 @@ module Badline
     # name. A disk or tape picked goes straight in, and a save loads.
     class MenuDialogs
       EXTENSIONS = {
-        disk: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl], tape: %w[.tap], cartridge: %w[.crt],
-        program: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl .tap .crt .prg .p00 .sid], snapshot: %w[.vsf]
+        disk: Media::Extensions::DEVICE8, tape: Media::Extensions.of(%i[tape]),
+        cartridge: Media::Extensions.of(%i[cartridge]), program: Media::Extensions::ALL, snapshot: %w[.vsf]
       }.freeze
       TITLES = { disk: "INSERT A DISK", tape: "INSERT A TAPE", cartridge: "INSERT A CARTRIDGE",
                  program: "QUICK OPEN", snapshot: "LOAD A SAVE" }.freeze

data/lib/badline/frontend/snapshots.rb

@@ -20,6 +20,7 @@ module Badline
       def initialize(computer, options)
         @computer = computer
         @at_finish = options.save_snapshot
+        @vice = options.vice?
         @autosave = options.frames.zero?
         @autosave_at = AUTOSAVE_FRAMES
       end
@@ -128,11 +129,21 @@ module Badline
       end
 
       def finish
-        save(@at_finish) unless @at_finish.empty?
+        return if @at_finish.empty?
+
+        @vice ? export(@at_finish) : save(@at_finish)
       end
 
       private
 
+      # Saves the machine with VICE's modules too, and warns when it can't.
+      def export(path)
+        @computer.export_snapshot(path)
+        puts "Saved #{path} for badline and VICE"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
       def restore_from(path)
         @computer = Snapshot.load(path) { |line| puts line }
         puts "Restored #{name_of(path)} from #{path}"