badline 0.13.0 → 0.15.0

data/lib/badline/chips/vic.rb

@@ -5,14 +5,13 @@ require "badline/chips/vic/registers"
 require "badline/chips/vic/display_state"
 require "badline/chips/vic/sequencer"
 require "badline/chips/vic/sprites"
-require "badline/chips/vic/saved_state"
+require "badline/chips/vic/keyed_parts"
 
 module Badline
   module Chips
     class VIC
       include Addressable
       include IntegerHelper
-      include SavedState
 
       # The 6569 of the breadbin C64, the HMOS 8565 of the C64C, and the
       # C128's VIC-IIe, the 8566 (PAL) and 8564 (NTSC). The VIC-IIe draws as
@@ -229,6 +228,11 @@ module Badline
         @sequencer.start_vertical_border(@rasterline == @last_line ? 0 : @rasterline + 1) if hooks.anybits?(HOOK_LAST)
       end
 
+      # Latches the sprite collisions up to the beam, as a read of $D01E or
+      # $D01F would, so the registers stand as the hardware has them when a
+      # snapshot is saved.
+      def fold_collisions! = @sprites.collide_upto(@column * 8, @sequencer.fg)
+
       # The IRQ line is held asserted while any enabled latch bit is set in
       # $D019/$D01A, until the program acknowledges it by writing to $D019.
       def interrupted?

data/lib/badline/chips/vic_i/keyed_parts.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VICI
+      class Sound
+        # The sound's fields in a keyed snapshot module, under `prefix`:
+        # the voices' shift registers, the noise LFSR, the level, and when
+        # each voice next shifts, in cycles from the machine's clock, with
+        # how far behind the clock the voices last ran. The volume and the
+        # voices' frequencies come from the VIC's registers on load.
+        module KeyedState
+          def save_fields(out, prefix)
+            now = @clock.cycles
+            run_to(now)
+            out.ints("#{prefix}shift_registers", @shift_registers).int("#{prefix}lfsr", @lfsr)
+            out.int("#{prefix}level", @level).int("#{prefix}ran_ago", now - @time)
+            out.ints("#{prefix}next_shifts", @next_shifts.map { |due| due - now })
+          end
+
+          def load_fields(input, prefix)
+            now = @clock.cycles
+            input.ints_into("#{prefix}shift_registers", @shift_registers)
+            @lfsr = input.masked("#{prefix}lfsr", @lfsr, 0xffff)
+            @level = input.int("#{prefix}level", @level)
+            @time = now - input.int("#{prefix}ran_ago", now - @time)
+            relative = input.ints("#{prefix}next_shifts", @next_shifts.map { |due| due - now })
+            VOICES.times { |voice| @next_shifts[voice] = now + relative.fetch(voice, 0) }
+          end
+
+          # $900A to $900E as written.
+          def restore_registers(registers)
+            @volume = registers[0x0e] & 0x0f
+            VOICES.times do |voice|
+              value = registers[0x0a + voice]
+              @frequencies[voice] = value & 0x7f
+              @enabled[voice] = value >= 0x80
+            end
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Painter
+        # The lines' fetches and the line going out, as this painter lays
+        # them out (VICI::LINE_LAYOUT), and the picture.
+        module KeyedState
+          def save_fields(out)
+            out.int("line.row", @row).int("line.painted", @painted).bool("line.written", @written)
+            out.bytes("line.patterns", @patterns).bytes("line.colors", @colors)
+            out.ints("line.counts", @counts).ints("line.starts", @starts).bytes("display", @display)
+          end
+
+          def load_fields(input, layout)
+            input.bytes_into("display", @display)
+            return unless layout
+
+            @row = input.int("line.row", @row)
+            @painted = input.int("line.painted", @painted)
+            @written = input.bool("line.written", @written)
+            input.bytes_into("line.patterns", @patterns)
+            input.bytes_into("line.colors", @colors)
+            input.ints_into("line.counts", @counts)
+            input.ints_into("line.starts", @starts)
+          end
+
+          # The colours as $900E and $900F hold them, every line to be
+          # painted afresh, and the whole display changed.
+          def restored!(registers)
+            @border = registers[0x0f] & 0x07
+            @background = registers[0x0f] >> 4
+            @reverse = registers[0x0f].nobits?(0x08)
+            @aux = registers[0x0e] >> 4
+            @stale.fill(true)
+            @memo_keys.fill(-1)
+            @dirty_lines.fill(true)
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The shape of the painter's per-line fields. A snapshot whose
+      # line.layout differs leaves them at power-on.
+      LINE_LAYOUT = 1
+
+      # The VIC-I's fields in a keyed snapshot module (Snapshot::Keyed): the
+      # registers, the beam, the text window's counters and the fetch in
+      # flight, the painter's lines under line.*, the picture, and the sound
+      # under sound.* What the registers decode to, where the line's fetches
+      # end and the next event are worked out on load.
+      module KeyedState
+        def save_fields(out)
+          out.bytes("registers", @registers).int("raster", @rasterline).int("column", @column)
+          out.bool("window_open", @window_open).bool("window_done", @window_done).int("row_start", @row_start)
+          out.int("matrix", @matrix).int("char_line", @char_line).int("text_rows", @text_rows)
+          out.int("fetch_from", @fetch_from).int("fetched", @fetched).int("code", @code)
+          out.int("line.layout", LINE_LAYOUT)
+          @painter.save_fields(out)
+          @sound&.save_fields(out, "sound.")
+          out
+        end
+
+        def load_fields(input)
+          input.bytes_into("registers", @registers)
+          @rasterline = input.int("raster", @rasterline)
+          @column = input.int("column", @column)
+          @window_open = input.bool("window_open", @window_open)
+          @window_done = input.bool("window_done", @window_done)
+          @row_start = input.int("row_start", @row_start)
+          @matrix = input.int("matrix", @matrix)
+          @char_line = input.int("char_line", @char_line)
+          @text_rows = input.int("text_rows", @text_rows)
+          @fetch_from = input.int("fetch_from", @fetch_from)
+          @fetched = input.int("fetched", @fetched)
+          @code = input.byte("code", @code)
+          line = input.int("line.layout", 0) == LINE_LAYOUT
+          input.adjust("line in progress from another renderer, restarted") unless line || input.missing?
+          @painter.load_fields(input, line)
+          @sound&.load_fields(input, "sound.")
+        end
+
+        def restored!
+          @origin_x = @registers[0] & 0x7f
+          @columns = @registers[2] & 0x7f
+          @origin_y = @registers[1]
+          rows_written(@registers[3])
+          bases_written
+          @slot = @rasterline * Painter::SLOTS
+          @fetch_to = 0
+          fetches_end if @window_open
+          schedule
+          @painter.restored!(@registers)
+          @sound&.restore_registers(@registers)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/chips/vic_i/painter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "badline/chips/vic_i/painter/saved_state"
-
 module Badline
   module Chips
     class VICI
@@ -28,8 +26,6 @@ module Badline
       # nibble's low three bits) and 11 the auxiliary colour, whatever
       # $900F bit 3 says (MOS 6560/6561 datasheet, "Color operating modes").
       class Painter
-        include SavedState
-
         # The characters a line holds room for. A line fetches at most 34.
         SLOTS = 40
 

data/lib/badline/chips/vic_i/sound.rb

@@ -30,10 +30,11 @@ module Badline
       # The output is the voices that are high, plus a little more, times the
       # volume, so a volume write steps the output even with every voice off.
       #
-      # The voices only run while #record collects the output: nothing the
-      # CPU reads depends on them. Until then a write only sets the register.
-      # While recording, the voices catch up to the current cycle whenever a
-      # write lands or the samples are drained, one shift at a time.
+      # The voices catch up to the current cycle whenever a write lands, the
+      # samples are drained or #catch_up! asks, one shift at a time, whether
+      # or not #record collects the output, so their state doesn't depend on
+      # whether the host plays it. Unrecorded, while every voice is off and
+      # shifted out to silence, they skip to the cycle at once.
       class Sound
         VOICES = 4
         NOISE = 3
@@ -86,14 +87,15 @@ module Badline
         # second, for #drain_samples. `clock_hz` is the rate the cycles are
         # taken to run at.
         def record(rate:, clock_hz: @clock_hz)
-          now = @clock.cycles
-          run_to(now)
-          resume(now)
+          run_to(@clock.cycles)
           @output = Output.new(clock_hz:, rate:, level: @level)
         end
 
         def recording? = !@output.nil?
 
+        # Runs the voices up to the current cycle.
+        def catch_up! = run_to(@clock.cycles)
+
         # The samples recorded since the last drain.
         def drain_samples
           output = @output
@@ -116,29 +118,7 @@ module Badline
           @level = level_now
         end
 
-        # The registers and the voices as they last ran, for a snapshot.
-        # Recording is the host's, and starts the voices again from the
-        # cycle it starts at.
-        def save_state(out)
-          run_to(@clock.cycles)
-          out.marker("VIC20 SOUND").int(@volume).ints(@frequencies).booleans(@enabled)
-          out.ints(@shift_registers).ints(@next_shifts).int(@lfsr).int(@level).int(@time)
-        end
-
-        def load_state(input)
-          input.marker("VIC20 SOUND")
-          @volume = input.int
-          input.ints_into(@frequencies)
-          input.booleans_into(@enabled)
-          input.ints_into(@shift_registers)
-          input.ints_into(@next_shifts)
-          @lfsr = input.int
-          @level = input.int
-          @time = input.int
-          resume(@clock.cycles) if recording?
-        end
-
-        # A voice's shift register as of the current cycle, while recording.
+        # A voice's shift register as of the current cycle.
         def shift_register(voice)
           run_to(@clock.cycles)
           @shift_registers[voice]
@@ -151,35 +131,47 @@ module Badline
 
         private
 
-        # Moves each shift that the cycles since the voices last ran have
-        # passed to its next turn from `now`, keeping its phase.
-        def resume(now)
-          @time = now
-          VOICES.times do |voice|
-            due = @next_shifts[voice]
-            next if due >= now
-
-            interval = period(voice) * DIVIDERS[voice]
-            @next_shifts[voice] = due + ((now - due + interval - 1) / interval * interval)
-          end
-        end
-
         # Runs the voices up to the start of cycle `target`, the output holding
         # each level for the cycles it lasts.
         def run_to(target)
           time = @time
+          return if target <= time
+
           output = @output
-          return if output.nil? || target <= time
+          return skip_to(target) if output.nil? && silent?
 
           following = next_shift
           while following < target
-            output.hold(@level, following - time)
+            output&.hold(@level, following - time)
             time = following
             shift_due(time)
             @level = level_now
             following = next_shift
           end
-          output.hold(@level, target - time)
+          output&.hold(@level, target - time)
+          @time = target
+        end
+
+        # Whether every voice is off and shifted out to where its shifts
+        # change nothing: the tone voices' registers empty and the noise
+        # voice's LFSR full of ones.
+        def silent?
+          enabled = @enabled
+          registers = @shift_registers
+          !(enabled[0] || enabled[1] || enabled[2] || enabled[NOISE]) &&
+            registers[0].zero? && registers[1].zero? && registers[2].zero? && @lfsr == 0xffff
+        end
+
+        # Moves each shift before `target` to its next turn from there,
+        # keeping its phase.
+        def skip_to(target)
+          VOICES.times do |voice|
+            due = @next_shifts[voice]
+            next if due >= target
+
+            interval = period(voice) * DIVIDERS[voice]
+            @next_shifts[voice] = due + ((target - due + interval - 1) / interval * interval)
+          end
           @time = target
         end
 

data/lib/badline/chips/vic_i.rb

@@ -2,7 +2,8 @@
 
 require "badline/chips/vic_i/painter"
 require "badline/chips/vic_i/text_window"
-require "badline/chips/vic_i/saved_state"
+require "badline/chips/vic_i/sound"
+require "badline/chips/vic_i/keyed_parts"
 
 module Badline
   module Chips
@@ -41,7 +42,6 @@ module Badline
     # into the line lands 48 pixels in. Lines 0-27 are blanked.
     class VICI
       include TextWindow
-      include SavedState
 
       # What a VIC-I sets for the machine: the clock, the raster's cycles
       # per line and lines per frame, and how many lines at the top of the

data/lib/badline/chips/z80/core.rb

@@ -14,7 +14,7 @@ require "badline/chips/z80/extended_page"
 require "badline/chips/z80/block_transfers"
 require "badline/chips/z80/block_io"
 require "badline/chips/z80/interrupt_acceptance"
-require "badline/chips/z80/saved_state"
+require "badline/chips/z80/keyed_state"
 
 module Badline
   module Chips
@@ -44,7 +44,7 @@ module Badline
         include BlockTransfers
         include BlockIO
         include InterruptAcceptance
-        include SavedState
+        include KeyedState
 
         attr_reader :bus, :cycles, :nmi
         attr_accessor :int

data/lib/badline/chips/z80/keyed_state.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class Z80
+      # The Z80's fields in a keyed snapshot module (Snapshot::Keyed),
+      # between instructions, where it always is after the C128's cycle:
+      # the registers, the T-state count and the interrupt latches.
+      module KeyedState
+        def save_fields(out)
+          out.int("a", @a).int("f", @f).int("b", @b).int("c", @c).int("d", @d).int("e", @e).int("h", @h).int("l", @l)
+          out.int("af_alt", @af_alt).int("bc_alt", @bc_alt).int("de_alt", @de_alt).int("hl_alt", @hl_alt)
+          out.int("i", @i).int("r", @r).int("pc", @pc).int("sp", @sp).int("ix", @ix).int("iy", @iy).int("wz", @wz)
+          out.int("q", @q).int("last_q", @last_q).int("im", @im).int("cycles", @cycles)
+          out.bool("iff1", @iff1).bool("iff2", @iff2).bool("halted", @halted).bool("after_ei", @after_ei)
+          out.bool("after_ld_a_ir", @after_ld_a_ir).bool("int", @int).bool("nmi", @nmi)
+          out.bool("nmi_pending", @nmi_pending)
+        end
+
+        def load_fields(input)
+          load_main_fields(input)
+          load_special_fields(input)
+          @cycles = input.int("cycles", @cycles)
+          load_latch_fields(input)
+          @prefix = 0
+        end
+
+        def restored! = nil
+
+        private
+
+        def load_main_fields(input)
+          @a = input.byte("a", @a)
+          @f = input.byte("f", @f)
+          @b = input.byte("b", @b)
+          @c = input.byte("c", @c)
+          @d = input.byte("d", @d)
+          @e = input.byte("e", @e)
+          @h = input.byte("h", @h)
+          @l = input.byte("l", @l)
+          @af_alt = input.word("af_alt", @af_alt)
+          @bc_alt = input.word("bc_alt", @bc_alt)
+          @de_alt = input.word("de_alt", @de_alt)
+          @hl_alt = input.word("hl_alt", @hl_alt)
+        end
+
+        def load_special_fields(input)
+          @i = input.byte("i", @i)
+          @r = input.byte("r", @r)
+          @pc = input.word("pc", @pc)
+          @sp = input.word("sp", @sp)
+          @ix = input.word("ix", @ix)
+          @iy = input.word("iy", @iy)
+          @wz = input.word("wz", @wz)
+          @q = input.byte("q", @q)
+          @last_q = input.byte("last_q", @last_q)
+          @im = input.int("im", @im)
+        end
+
+        def load_latch_fields(input)
+          @iff1 = input.bool("iff1", @iff1)
+          @iff2 = input.bool("iff2", @iff2)
+          @halted = input.bool("halted", @halted)
+          @after_ei = input.bool("after_ei", @after_ei)
+          @after_ld_a_ir = input.bool("after_ld_a_ir", @after_ld_a_ir)
+          @int = input.bool("int", @int)
+          @nmi = input.bool("nmi", @nmi)
+          @nmi_pending = input.bool("nmi_pending", @nmi_pending)
+        end
+      end
+    end
+  end
+end

data/lib/badline/chips.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# The chips badline/core's machines share. The C128's own, the Z80 and the
+# VDC, stay out of the core: badline/c128 requires them.
+require "badline/chips/cpu"
+require "badline/chips/cia"
+require "badline/chips/via"
+require "badline/chips/sid"
+require "badline/chips/vic"
+require "badline/chips/vic_i"

data/lib/badline/core.rb

@@ -15,29 +15,13 @@ require "badline/memory"
 require "badline/c64/color_memory"
 require "badline/rom"
 require "badline/c64/banked_ram"
-require "badline/chips/cpu/port"
-require "badline/c64/bus"
-require "badline/chips/cpu/instruction"
-require "badline/chips/cpu/instruction_set"
 require "badline/status"
 require "badline/input"
-require "badline/drives/datasette"
-require "badline/chips/cia/time_of_day"
-require "badline/chips/cia"
-require "badline/chips/via"
-require "badline/chips/sid"
-require "badline/debug_register"
+require "badline/chips"
+require "badline/drives"
+require "badline/c64/bus"
 require "badline/c64/reu"
-require "badline/chips/cpu/interrupts"
-require "badline/chips/cpu/traps"
-require "badline/chips/cpu"
-require "badline/chips/vic"
-require "badline/keyboard_buffer"
-require "badline/drives/serial_bus"
-require "badline/drives/model1541"
-require "badline/drives/model1581"
-require "badline/drives/model1581/slot"
-require "badline/snapshot/state"
+require "badline/snapshot/keyed"
 require "badline/snapshot/c64_setup"
 require "badline/snapshot/storage_setup"
 require "badline/machine"
@@ -47,5 +31,4 @@ require "badline/storage"
 require "badline/sid_tune"
 require "badline/c64/cartridge"
 require "badline/kernal_trap"
-require "badline/chrout_trap"
 require "badline/media"

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    class Datasette
+      # The datasette's fields in a keyed snapshot module (Snapshot::Keyed,
+      # BL-TAPE): the keys, the motor, the countdown to the next pulse, and
+      # a tape in it under tape.*: its path, its bytes and how far it has
+      # played. A tape that isn't in leaves tape.* out. A datasette that
+      # times the read line's level adds when in the countdown the line
+      # rises, and whether a recording's low half wave is on the tape. The
+      # sense and flag handlers don't fire on load.
+      module KeyedState
+        def save_fields(out)
+          out.bool("playing", @playing).bool("motor", @motor).int("countdown", @countdown)
+          out.int("rise_at", @rise_at).bool("low_recorded", @low_recorded) if @level
+          tape = @tape
+          return out unless tape
+
+          out.text("tape.path", tape.path.to_s).bytes("tape.bytes", tape.bytes).int("tape.position", tape.position)
+        end
+
+        # The tape goes back in from the bytes the module holds, without its
+        # host file, unless the tape in is the same one.
+        def load_fields(input)
+          @playing = input.bool("playing", @playing)
+          @motor = input.bool("motor", @motor)
+          @countdown = input.int("countdown", @countdown)
+          @rise_at = input.int("rise_at", @rise_at)
+          @low_recorded = input.bool("low_recorded", @low_recorded)
+          bytes = input.bytes("tape.bytes", "".b).bytes
+          return @tape = nil if bytes.empty?
+
+          path = input.text("tape.path", "")
+          @tape = Storage::TAP.new(path, bytes:) unless @tape&.path.to_s == path && @tape&.bytes == bytes
+          @tape&.position = input.int("tape.position", 0)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/drives/datasette.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require "badline/drives/datasette/saved_state"
+require "badline/drives/datasette/keyed_state"
 
 module Badline
   module Drives
     # The 1530 datasette. Plays a pulse stream into CIA 1's FLAG pin while the
     # motor runs with a key pressed, and reports the keys through the cassette
     # sense line on the $01 port. With RECORD down too, it records the
-    # machine's write line onto the tape instead.
+    # machine's write line onto the tape instead. Built with +level: true+,
+    # it also times the read line's level, for a machine that reads that
+    # (#read_high?) rather than the falling edges.
     class Datasette
-      include SavedState
-
       # What inserting a tape raises on a machine without a cassette port.
       class Missing < ArgumentError; end
-
       attr_reader :tape
       attr_writer :motor
 
-      def initialize(tape = nil)
+      def initialize(tape = nil, level: false)
         @tape = tape
+        @level = level
         @connected = true
         @playing = false
         @recording = false
@@ -26,6 +26,8 @@ module Badline
         @since = 0
         @motor = false
         @countdown = 0
+        @rise_at = 0
+        @low_recorded = false
         @flag_handler = nil
         @sense_handler = nil
       end
@@ -64,6 +66,7 @@ module Badline
       def rewind
         @tape&.rewind
         @countdown = 0
+        @rise_at = 0
       end
 
       def play! = press(true)
@@ -76,6 +79,7 @@ module Badline
         press(true)
         @recording = true
         @since = 0
+        @low_recorded = false
       end
 
       def recording? = @recording
@@ -83,14 +87,27 @@ module Badline
       # The machine's tape write line. While the deck records with its motor
       # running, each rising edge ends a pulse on the tape, as long as the
       # time since the edge before, and plays back as a falling edge on the
-      # read line.
+      # read line. A datasette built with +level: true+ records a version 2
+      # tape's half waves instead: a rising edge ends the low half and a
+      # falling edge the high half after it, so the tape plays back the
+      # levels it recorded (#read_high?).
       def write_line=(high)
-        rose = high && !@write_high
+        edge = high != @write_high
         @write_high = high
-        return unless rose && @recording && running?
+        return unless edge && @recording && running?
+
+        if @level && @tape.half_waves?
+          record_half_wave(high)
+        elsif high
+          @tape.record_pulse(@since)
+          @since = 0
+        end
+      end
 
-        @tape.record_pulse(@since)
-        @since = 0
+      # Sets the write line's level without recording an edge, as a
+      # snapshot loads it.
+      def write_level=(high)
+        @write_high = high
       end
 
       def playing? = @playing
@@ -102,11 +119,22 @@ module Badline
 
       def running? = @playing && @motor && !@tape.nil?
 
+      # The tape read line's level, on a datasette built with +level: true+.
+      # Each pulse holds it low for its first half and high for its second,
+      # up to the falling edge that ends it. A version 2 tape times each
+      # half, and a version 0 or 1 tape's pulse plays as two equal halves.
+      # It reads high while the tape isn't playing.
+      def read_high?
+        return true unless running? && !@recording
+
+        @countdown.positive? && @countdown <= @rise_at
+      end
+
       def cycle!
         return unless running?
         return @since += 1 if @recording
 
-        @countdown = @tape.next_pulse.to_i if @countdown.zero?
+        next_pulse if @countdown.zero?
         return if @countdown.zero?
 
         @countdown -= 1
@@ -120,6 +148,28 @@ module Badline
 
       private
 
+      def next_pulse
+        return @countdown = @tape.next_pulse.to_i unless @level
+        return next_half_waves if @tape.half_waves?
+
+        @countdown = @tape.next_pulse.to_i
+        @rise_at = @countdown / 2
+      end
+
+      def next_half_waves
+        first = @tape.next_half_wave.to_i
+        @rise_at = @tape.next_half_wave.to_i
+        @countdown = first + @rise_at
+      end
+
+      # A high half wave goes on the tape only after the low half before it,
+      # so the tape starts with a whole pulse.
+      def record_half_wave(rose)
+        @tape.record_half_wave(@since) if rose || @low_recorded
+        @low_recorded = rose
+        @since = 0
+      end
+
       def press(down)
         return if down == @playing || !@connected
 

data/lib/badline/drives/engine/core.rb

@@ -86,6 +86,9 @@ module Badline
         # is the same at the end of every pass the drive sleeps through.
         def led_on? = @mechanism.led_on?
 
+        # The power LED, which stays lit.
+        def power_led_on? = true
+
         # Stores what the head wrote since the motor last stopped in the
         # disk's image, as the motor stopping does.
         def flush