badline 0.5.0 → 0.6.0

data/lib/badline/drive1541/idle.rb

@@ -27,7 +27,8 @@ module Badline
     #
     # Such a pass runs the same way again from where it ended, for as
     # long as ATN holds still and no counter sets a flag, so the drive
-    # sleeps: host_cycle! only counts the host cycles that go by. It wakes
+    # sleeps: host_cycle! only counts the host cycles that go by (see
+    # Sleep). It wakes
     # when ATN moves, when a counter is due to set a flag, or when something
     # outside reads or changes the drive (the readers in Drive1541 call
     # settle!). Waking counts off the whole passes it owes in bulk,
@@ -41,6 +42,9 @@ module Badline
     # A pass starts at $EBFF, where the CPU always comes from the loop's
     # last instruction, a JMP, so what that leaves in the CPU's working
     # registers is the same each time round.
+    #
+    # The timer's interrupts come round too, and once they do, the drive
+    # sleeps on through them (see Orbit).
     module Idle
       # Where the DOS 2.6 idle loop starts over.
       IDLE_LOOP = 0xebff
@@ -54,38 +58,15 @@ module Badline
         @idle_skip = on
       end
 
-      # Whether the drive is skipping its idle loop right now.
-      def asleep? = @asleep
-
-      # Brings the drive up to the present, cycle for cycle, and drops the
-      # pass it was recording, since whoever called may change it. Every
-      # reader of the drive's parts calls this.
-      def settle!
-        if @asleep
-          wake!
-          @serial_port.latch_host
-        end
-        stop_recording if @recording
-      end
-
       private
 
-      # A host cycle asleep.
-      def doze
-        @slept += 1
-        settle! if @slept == @wake_at || @serial_port.atn_moved?
-      end
-
       def init_idle(debug)
         @idle_skip = !debug
-        @asleep = false
         @recording = false
-        @owed = 0
-        @budget = 0
-        @slept = 0
-        @wake_at = 0
         @pass_cycles = 0
         @pass_instructions = 0
+        init_sleep
+        init_orbits
       end
 
       # The CPU is at $EBFF. At an instruction boundary, the drive sleeps if
@@ -130,39 +111,10 @@ module Badline
         @pass_cycles = @cycles - @record_cycles
         @pass_instructions = @cpu.instructions - @record_instructions
         @asleep = true
+        @host_still = false
         @owed = 0
         @budget = quiet_cycles
-      end
-
-      # Asleep, host_cycle! counts host cycles, and leaves it to wake! to
-      # turn them into drive cycles through the phase accumulator. This sets
-      # the host cycle that brings the drive cycles owed up to the budget.
-      def plan_wake
-        @slept = 0
-        needed = ((@budget - @owed) * @host_clock_hz) - @phase
-        @wake_at = needed.positive? ? (needed + CLOCK_HZ - 1) / CLOCK_HZ : 1
-      end
-
-      # Runs the cycles owed: whole passes in bulk, up to the budget, and
-      # the rest one by one.
-      def wake!
-        @asleep = false
-        phase = @phase + (@slept * CLOCK_HZ)
-        @phase = phase % @host_clock_hz
-        owed = @owed + (phase / @host_clock_hz)
-        @owed = 0
-        @slept = 0
-        span = [owed, @budget].min
-        passes = span / @pass_cycles
-        if passes.positive?
-          cycles = passes * @pass_cycles
-          @cpu.fast_forward(cycles, passes * @pass_instructions)
-          @via1.fast_forward(cycles)
-          @via2.fast_forward(cycles)
-          @cycles += cycles
-          owed -= cycles
-        end
-        owed.times { step }
+        anchor
       end
 
       def quiet_cycles

data/lib/badline/drive1541/mechanism.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/drive1541/rotation"
+require "badline/drive1541/mechanism_state"
 
 module Badline
   class Drive1541
@@ -65,6 +66,7 @@ module Badline
     # half track after it.
     class Mechanism
       include Rotation
+      include MechanismState
 
       MOTOR = 0x04
       LED = 0x08

data/lib/badline/drive1541/mechanism_state.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # Saving and restoring the Mechanism for a snapshot.
+    module MechanismState
+      # The disk (Disk#save_state) and everything the head, the motor, the
+      # stepper and the read and write electronics hold, down to the cell
+      # under the head and the read clock's phase.
+      def save_state(out)
+        out.boolean(!@disk.nil?)
+        @disk&.save_state(out)
+        [@half_track, @slip, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits, @write_shift,
+         @index, @mask, @cell_end, @width, @next].each { |value| out.int(value) }
+        [@motor, @led, @sync, @byte_ready, @writing, @write_gate, @protected, @track_written].each do |flag|
+          out.boolean(flag)
+        end
+        out.optional_int(@write_index)
+      end
+
+      # Puts the state back, reusing the disk in when it's the one the state
+      # names (Disk::State.load). A disk taken out is flushed, as insert
+      # does.
+      def load_state(input)
+        disk = input.boolean? ? Disk::State.load(input, @disk) : nil
+        flush unless disk.equal?(@disk)
+        @disk = disk
+        load_head(input)
+        load_flags(input)
+        @write_index = input.optional_int
+        head_on_track
+      end
+
+      private
+
+      def load_head(input)
+        @half_track = input.int
+        @slip = input.int
+        @zone = input.int
+        @clock = input.int
+        @time = input.int
+        @clock_at = input.int
+        @clocks = input.int
+        @shift = input.int
+        @ones = input.int
+        @bits = input.int
+        @write_shift = input.int
+        @index = input.int
+        @mask = input.int
+        @cell_end = input.int
+        @width = input.int
+        @next = input.int
+      end
+
+      def load_flags(input)
+        @motor = input.boolean?
+        @led = input.boolean?
+        @sync = input.boolean?
+        @byte_ready = input.boolean?
+        @writing = input.boolean?
+        @write_gate = input.boolean?
+        @protected = input.boolean?
+        @track_written = input.boolean?
+      end
+    end
+  end
+end

data/lib/badline/drive1541/orbit.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # Sleeping through the DOS's timer interrupts, exactly, once they come
+    # round.
+    #
+    # VIA 2's timer 1 interrupts the idle loop for the job loop, which
+    # finds no job, restarts the timer and returns into the pass it cut
+    # into, 14,998 cycles and more apart. The interrupts land at a
+    # different point in the pass each time, until, six of them on, the
+    # whole drive is back where it was: an orbit of 90,044 cycles.
+    #
+    # Each place the drive falls asleep (see Idle) is an anchor, and the
+    # drive keeps everything it holds at each one: RAM, the counters of
+    # the timers that are armed or that it read or wrote since, and the
+    # rest as Idle compares a pass. It keeps them only while it keeps to
+    # itself, with Bus#guard! checking that it doesn't read the serial
+    # bus, write VIA 1, turn the motor on or change the LED. ATN moving,
+    # or a reader settling the drive, forgets them.
+    #
+    # Coming to an anchor it kept before closes an orbit, which runs the
+    # same way again from here for as long as ATN holds still, so the
+    # drive sleeps on without waking for its counters. Waking counts off
+    # the whole orbits it owes in bulk, moving on only the counters it
+    # never touched, and runs the rest as Idle does.
+    module Orbit
+      # How many anchors the drive keeps while it looks for an orbit.
+      ANCHORS = 32
+
+      private
+
+      def init_orbits
+        @anchors = {}
+        @orbit_cycles = nil
+        @orbit_instructions = 0
+        @bus.guard!
+      end
+
+      # The drive falls asleep at an anchor. One it came to before closes
+      # an orbit: everything from there to here runs the same way again.
+      def anchor
+        forget_orbits if @bus.tainted || @anchors.size >= ANCHORS
+        key = anchor_state
+        if (seen = @anchors[key])
+          @orbit_cycles = @cycles - seen[0]
+          @orbit_instructions = @cpu.instructions - seen[1]
+        else
+          @anchors[key] = [@cycles, @cpu.instructions]
+        end
+      end
+
+      def forget_orbits
+        @anchors.clear
+        @orbit_cycles = nil
+        @bus.guard!
+      end
+
+      # Runs whole orbits, which bring the drive back to the anchor it
+      # sleeps at but for the counters it never touched. Returns the
+      # cycles.
+      def skip_orbits(orbits)
+        cycles = orbits * @orbit_cycles
+        touched = @bus.touched_timers
+        @cpu.fast_forward(cycles, orbits * @orbit_instructions)
+        @via1.skip_orbits(cycles, touched & 0x03)
+        @via2.skip_orbits(cycles, touched >> 2)
+        @cycles += cycles
+        cycles
+      end
+
+      # Everything the drive holds at an anchor, but for the counters of
+      # the unarmed timers it hasn't touched since it was last tainted.
+      def anchor_state
+        touched = @bus.touched_timers
+        [*idle_state, *@via1.counter_state(touched & 0x03), *@via2.counter_state(touched >> 2),
+         @bus.ram.snapshot]
+      end
+    end
+  end
+end

data/lib/badline/drive1541/rotation.rb

@@ -92,6 +92,16 @@ module Badline
         @writing ? write_bit(at) : read_bit(one)
       end
 
+      # The track under the head and its layout, leaving the head's place
+      # on it as it stands.
+      def head_on_track
+        @track = @disk&.track(@half_track) || BLANK
+        @bytes = @track.bytes
+        @widths = @track.widths
+        @length = @track.length
+        @last = @length - 1
+      end
+
       # The track under the head, from the cell that's under it +time+
       # into the turn.
       def load_track(time = @time)

data/lib/badline/drive1541/serial_port.rb

@@ -44,6 +44,16 @@ module Badline
         @host = @bus ? @bus.host_lines : 0
       end
 
+      # The C64's lines as last latched. The jumpers and the bus are the
+      # drive's wiring.
+      def save_state(out)
+        out.int(@host)
+      end
+
+      def load_state(input)
+        @host = input.int
+      end
+
       # Whether the C64 has moved ATN since the last latch_host.
       def atn_moved?
         lines = @bus ? @bus.host_lines : 0

data/lib/badline/drive1541/sleep.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # The drive asleep, as Idle and Orbit let it: host_cycle! counts the
+    # host cycles that go by, and waking turns them into drive cycles
+    # through the phase accumulator and runs them. Whole orbits and whole
+    # passes go in bulk, and the rest cycle by cycle, which may find the
+    # idle loop and put the drive back to sleep.
+    #
+    # The drive looks at ATN only when the C64 may have moved it, on a
+    # bus that says when (IECBus#notifies?), and every host cycle on one
+    # that doesn't.
+    module Sleep
+      # Whether the drive is skipping its idle loop right now.
+      def asleep? = @asleep
+
+      # Brings the drive up to the present, cycle for cycle, and drops the
+      # pass it was recording and the orbits it found, since whoever called
+      # may change it. Every reader of the drive's parts calls this.
+      def settle!
+        if @asleep
+          wake!
+          @serial_port.latch_host
+          @asleep = false
+          @orbit_cycles = nil
+        end
+        stop_recording if @recording
+        forget_orbits
+      end
+
+      private
+
+      def init_sleep
+        @asleep = false
+        @host_still = false
+        @owed = 0
+        @budget = 0
+        @slept = 0
+        @wake_at = 0
+      end
+
+      # A host cycle asleep that may wake the drive. The bus says whether
+      # the next ones need a look at ATN.
+      def doze
+        @host_still = @serial_bus.notifies?
+        if @serial_port.atn_moved?
+          settle!
+        elsif @slept == @wake_at
+          wake!
+          @serial_port.latch_host
+          plan_wake if @asleep
+        end
+      end
+
+      # Asleep, host_cycle! counts host cycles, and leaves it to wake! to
+      # turn them into drive cycles through the phase accumulator. This sets
+      # the host cycle that brings the drive cycles owed up to the budget.
+      # On an orbit the drive sleeps until something outside wakes it:
+      # @slept counts from 1, so it never comes to 0.
+      def plan_wake
+        @slept = 0
+        return @wake_at = 0 if @orbit_cycles
+
+        needed = ((@budget - @owed) * @host_clock_hz) - @phase
+        @wake_at = needed.positive? ? (needed + CLOCK_HZ - 1) / CLOCK_HZ : 1
+      end
+
+      # Runs the cycles owed.
+      def wake!
+        phase = @phase + (@slept * CLOCK_HZ)
+        @phase = phase % @host_clock_hz
+        owed = @owed + (phase / @host_clock_hz)
+        @owed = 0
+        @slept = 0
+        catch_up(owed)
+      end
+
+      # Runs +owed+ drive cycles: whole orbits and whole passes in bulk,
+      # passes only up to the budget, and the rest cycle by cycle, which
+      # may put the drive back to sleep.
+      def catch_up(owed)
+        while owed.positive?
+          if @asleep
+            if @orbit_cycles && owed >= @orbit_cycles
+              owed -= skip_orbits(owed / @orbit_cycles)
+              next
+            end
+            @orbit_cycles = nil
+            passes = [owed, @budget].min / @pass_cycles
+            if passes.positive?
+              owed -= skip_passes(passes)
+              next
+            end
+            @asleep = false
+          end
+          run_cycle
+          owed -= 1
+        end
+      end
+
+      # Runs whole passes, moving the counters on. Returns the cycles.
+      def skip_passes(passes)
+        cycles = passes * @pass_cycles
+        @cpu.fast_forward(cycles, passes * @pass_instructions)
+        @via1.fast_forward(cycles)
+        @via2.fast_forward(cycles)
+        @cycles += cycles
+        @budget -= cycles
+        cycles
+      end
+    end
+  end
+end

data/lib/badline/drive1541.rb

@@ -7,7 +7,9 @@ require "badline/drive1541/track"
 require "badline/drive1541/disk"
 require "badline/drive1541/mechanism"
 require "badline/drive1541/disk_via"
+require "badline/drive1541/sleep"
 require "badline/drive1541/idle"
+require "badline/drive1541/orbit"
 
 module Badline
   # The 1541 disk drive as a machine of its own: a 6502 running the DOS
@@ -27,9 +29,12 @@ module Badline
   # While the DOS idles, host_cycle! skips the drive's cycles and catches
   # up on them later, exactly (see Idle). The readers of the drive's parts
   # catch up first, so they find the drive as running every cycle would
-  # have left it.
+  # have left it. Once the DOS's timer interrupts come round, the drive
+  # sleeps through them too (see Orbit).
   class Drive1541
+    include Sleep
     include Idle
+    include Orbit
 
     CLOCK_HZ = 1_000_000
 
@@ -143,8 +148,14 @@ module Badline
     # The host has run this cycle already, and the drive sees what it did
     # from the next one on (see SerialPort). Asleep, the drive owes the
     # cycles instead, until ATN moves or its counters are due (see Idle).
+    # It looks at ATN only after the C64 wrote CIA 2's port A, on a bus
+    # that says so (see host_written!).
     def host_cycle!
-      return doze if @asleep
+      if @asleep
+        return if (@slept += 1) != @wake_at && @host_still
+
+        return doze
+      end
 
       phase = @phase + CLOCK_HZ
       while phase >= @host_clock_hz
@@ -157,6 +168,11 @@ module Badline
       plan_wake if @asleep
     end
 
+    # The C64 wrote CIA 2's port A, so ATN may have moved.
+    def host_written!
+      @host_still = false
+    end
+
     # Runs one drive cycle, catching up first on any the drive owes (see
     # step).
     def cycle!
@@ -164,6 +180,40 @@ module Badline
       step
     end
 
+    # The drive's whole state: its clock phase, the CPU, RAM, both VIAs,
+    # the serial port's latch of the C64's lines and the mechanism with its
+    # disk. The drive settles first, so it is awake and not recording a
+    # pass, and a restored drive starts the same way, its orbits forgotten
+    # from the state it takes: Idle's and Orbit's bookkeeping
+    # isn't stored. The device number, the host's clock rate and whether
+    # the drive may sleep are the machine's wiring.
+    def save_state(out)
+      settle!
+      out.marker("DRIVE1541")
+      out.int(@phase).int(@cycles).boolean(@so_pending)
+      @serial_port.save_state(out)
+      @via1.save_state(out)
+      @via2.save_state(out)
+      @bus.save_state(out)
+      @cpu.save_state(out)
+      @mechanism.save_state(out)
+    end
+
+    def load_state(input)
+      settle!
+      input.marker("DRIVE1541")
+      @phase = input.int
+      @cycles = input.int
+      @so_pending = input.boolean?
+      @serial_port.load_state(input)
+      @via1.load_state(input)
+      @via2.load_state(input)
+      @bus.load_state(input)
+      @cpu.load_state(input)
+      @mechanism.load_state(input)
+      forget_orbits
+    end
+
     def inspect
       "#<#{self.class.name} cycles=#{cycles} cpu=(#{cpu.inspect})>"
     end

data/lib/badline/gui/application.rb

@@ -6,6 +6,9 @@ module Badline
       TITLE = "Badline"
       TOGGLE_SYM = SDL::KEY_TAB
       MUTE_SYM = SDL::KEY_F10
+      SAVE_SYM = SDL::KEY_F11
+      RESTORE_SYM = SDL::KEY_F12
+      HOST_SYMS = [TOGGLE_SYM, MUTE_SYM, SAVE_SYM, RESTORE_SYM].freeze
       REVERSE_MOD = SDL::KMOD_SHIFT
 
       SHARED_KEYS = %i[cursor_up cursor_left cursor_h cursor_v space w a s d lshift].freeze
@@ -34,14 +37,12 @@ module Badline
       # options (autostart:, song:, disk:) go to Media.attach.
       def initialize(media_path: nil, machine: {}, sound: false, verbose: false, **media)
         @verbose = verbose
-        @computer = Computer.new(**machine_options(machine, media_path))
-        Media::TrueDrive.plug(@computer) if machine[:true_drive]
-        puts Media.attach(@computer, media_path, **media) if media_path
+        @snapshots = Snapshots.new
+        @computer = @snapshots.boot(media_path, machine, media)
 
         @mode = :keyboard
         @pot_device = nil
-        @panes = [ScreenPane.new(@computer)]
-        @panes << DriveLedPane.new(@computer.drive1541, @panes.first) if @computer.drive1541
+        @panes = panes
         @stream = open_stream if sound
         @paced = ENV["NOVSYNC"].nil?
         @window = Window.new(
@@ -94,8 +95,7 @@ module Badline
       end
 
       def handle_key_down(event)
-        return cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1) if event.sym == TOGGLE_SYM
-        return toggle_mute if event.sym == MUTE_SYM
+        return host_key(event) if HOST_SYMS.include?(event.sym)
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -105,6 +105,16 @@ module Badline
         end
       end
 
+      # Tab, F10, F11 and F12 drive the front end, not the machine.
+      def host_key(event)
+        case event.sym
+        when TOGGLE_SYM then cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1)
+        when MUTE_SYM then toggle_mute
+        when SAVE_SYM then @snapshots.save(@computer) unless event.repeat
+        else restore_snapshot unless event.repeat
+        end
+      end
+
       # RESTORE isn't in the key matrix, so it goes to the machine instead,
       # once per press as the real key's one-shot fires.
       def press_key(key, repeat)
@@ -115,7 +125,7 @@ module Badline
       end
 
       def handle_key_up(event)
-        return if [TOGGLE_SYM, MUTE_SYM].include?(event.sym)
+        return if HOST_SYMS.include?(event.sym)
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -155,6 +165,29 @@ module Badline
         update_title
       end
 
+      # Runs the restored machine in place of the one before: the screen,
+      # the drive LED, the gamepads and the sound go over to it. The input
+      # mode stays the host's, so a mouse or paddles go back in their port.
+      def restore_snapshot
+        computer = @snapshots.restore
+        return unless computer
+
+        release_inputs
+        @computer = computer
+        @panes = panes
+        @gamepads.computer = computer
+        @stream&.sid = computer.sid
+        attach_pot_device if POT_DEVICES.key?(@mode)
+      end
+
+      # The screen, and the drive LED in its border when a true drive is
+      # plugged in.
+      def panes
+        screen = ScreenPane.new(@computer)
+        drive = @computer.drive1541
+        drive ? [screen, DriveLedPane.new(drive, screen)] : [screen]
+      end
+
       def update_title
         tags = [MODES[@mode], @stream&.muted? && "MUTED"].select(&:itself)
         @window.title = [TITLE, *tags.map { |tag| "[#{tag}]" }].join(" ")
@@ -169,12 +202,6 @@ module Badline
         warn "badline: no sound, can't open the audio device: #{e.message}"
       end
 
-      def machine_options(machine, media_path)
-        options = { sid_model: machine[:sid_model] || Media.sid_model(media_path), **machine.slice(:reu) }
-        options[:region] = Region::NTSC if machine[:ntsc]
-        options
-      end
-
       def fit_frame
         rate = @window.refresh_rate
         clock_hz = @computer.region.clock_hz

data/lib/badline/gui/gamepads.rb

@@ -53,6 +53,13 @@ module Badline
                        .reject(&:null?)
       end
 
+      # Wires the controllers to another machine's joysticks, which take
+      # what they hold on the next poll.
+      def computer=(computer)
+        @computer = computer
+        @pressed.map! { [] }
+      end
+
       def poll
         @controllers.each_with_index { |controller, index| apply(controller, index) }
       end

data/lib/badline/gui/snapshots.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  module GUI
+    # The window's snapshots: a .vsf opened as the media, F11 saving the
+    # machine to a new badline-<date>-<time>.vsf in the working directory,
+    # and F12 going back to the snapshot last saved or opened.
+    class Snapshots
+      def self.snapshot?(path) = !path.nil? && File.extname(path).casecmp?(".vsf")
+
+      def initialize
+        @last = nil
+      end
+
+      # The machine the window starts with: for a .vsf the machine it holds,
+      # built with that machine's chip models, which F12 goes back to, and
+      # otherwise one built from the machine options (Application.new) with
+      # the media attached.
+      def boot(media_path, machine, media)
+        return load(media_path) if Snapshots.snapshot?(media_path)
+
+        Computer.new(**machine_options(machine, media_path)).tap do |computer|
+          Media::TrueDrive.plug(computer) if machine[:true_drive]
+          puts Media.attach(computer, media_path, **media) if media_path
+        end
+      end
+
+      # A new machine, built as the snapshot's was and restored from it.
+      def load(path)
+        computer = Snapshot.load(path) { |line| puts line }
+        @last = path
+        puts "Restored #{path}"
+        computer
+      end
+
+      # Saves the machine, and warns when it can't.
+      def save(computer)
+        path = "badline-#{Time.now.strftime('%Y%m%d-%H%M%S')}.vsf"
+        computer.save_snapshot(path)
+        @last = path
+        puts "Saved #{path}, F12 restores it"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
+      # A new machine restored from the snapshot last saved or opened, or
+      # nil when there is none or it fails, which it warns about.
+      def restore
+        return load(@last) if @last
+
+        puts "No snapshot to restore, F11 saves one"
+        nil
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{@last}: #{e.message}"
+        nil
+      end
+
+      private
+
+      def machine_options(machine, media_path)
+        options = { sid_model: machine[:sid_model] || Media.sid_model(media_path), **machine.slice(:reu) }
+        options[:region] = Region::NTSC if machine[:ntsc]
+        options
+      end
+    end
+  end
+end