badline 0.5.0 → 0.6.0

data/lib/badline/via/control_lines.rb

@@ -55,6 +55,21 @@ module Badline
 
       def active_c1_edge?(high) = high == @control.anybits?(0x01)
 
+      # The lines' levels and mode. Which flags they set, and whether reads
+      # handshake, are the port's wiring.
+      def save_state(out)
+        out.int(@control).boolean(@c1_high).boolean(@c2_high).boolean(@handshake_low).int(@pulse).boolean(@c2_output)
+      end
+
+      def load_state(input)
+        @control = input.int
+        @c1_high = input.boolean?
+        @c2_high = input.boolean?
+        @handshake_low = input.boolean?
+        @pulse = input.int
+        @c2_output = input.boolean?
+      end
+
       # Everything the lines hold, for comparing them at two points.
       def state = [@control, @c1_high, @c2_high, @handshake_low, @pulse, @c2_output]
 

data/lib/badline/via/fast_forward.rb

@@ -26,6 +26,21 @@ module Badline
         @t2.fast_forward(cycles)
       end
 
+      # The counters an orbit (see Drive1541::Idle) has to bring back: those
+      # of the armed timers, and of the timers +touched+ names (bit 0 for
+      # timer 1, bit 1 for timer 2). The others only count.
+      def counter_state(touched)
+        [(@t1.count_state if @t1.armed? || touched.anybits?(1)),
+         (@t2.count_state if @t2.armed? || touched.anybits?(2))]
+      end
+
+      # Runs +cycles+ cycles of whole orbits at once: the counters
+      # counter_state leaves out move on, and the rest come back round.
+      def skip_orbits(cycles, touched)
+        @t1.fast_forward(cycles) unless @t1.armed? || touched.anybits?(1)
+        @t2.fast_forward(cycles) unless @t2.armed? || touched.anybits?(2)
+      end
+
       # Everything the VIA holds but its counters, for comparing it at two
       # points. Timer 1's PB7 level counts only while ACR bit 7 puts it on
       # the pin: nothing reads it otherwise.

data/lib/badline/via/interrupt_register.rb

@@ -24,6 +24,15 @@ module Badline
         @enable = 0x00
       end
 
+      def save_state(out)
+        out.int(@flags).int(@enable)
+      end
+
+      def load_state(input)
+        @flags = input.int
+        @enable = input.int
+      end
+
       def set(bits)
         @flags |= bits
       end

data/lib/badline/via/shift_register.rb

@@ -67,6 +67,19 @@ module Badline
       # changes it from cycle to cycle.
       def clocking? = @bits.nonzero? && internal_clock?
 
+      def save_state(out)
+        out.int(@mode).int(@data).int(@bits).boolean(@clock).boolean(@cb2).boolean(@cb2_input)
+      end
+
+      def load_state(input)
+        @mode = input.int
+        @data = input.int
+        @bits = input.int
+        @clock = input.boolean?
+        @cb2 = input.boolean?
+        @cb2_input = input.boolean?
+      end
+
       # Everything the register holds, for comparing it at two points.
       def state = [@mode, @data, @bits, @clock, @cb2, @cb2_input]
 

data/lib/badline/via/state.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIA
+    # Saving and restoring a VIA for a snapshot.
+    module State
+      # The registers, the timers, the shift register, the interrupt flags
+      # and the control lines. The peripheral is the drive's wiring.
+      def save_state(out)
+        out.int(@ora).int(@orb).int(@ddra).int(@ddrb).int(@latch_a).int(@latch_b).int(@acr).int(@pcr)
+        out.boolean(@pb6_high).boolean(@sr_uses_t2)
+        @t1.save_state(out)
+        @t2.save_state(out)
+        @shift_register.save_state(out)
+        @ifr.save_state(out)
+        @ca.save_state(out)
+        @cb.save_state(out)
+      end
+
+      # Puts the state back without telling the peripheral, which restores
+      # its own.
+      def load_state(input)
+        @ora = input.int
+        @orb = input.int
+        @ddra = input.int
+        @ddrb = input.int
+        @latch_a = input.int
+        @latch_b = input.int
+        @acr = input.int
+        @pcr = input.int
+        @pb6_high = input.boolean?
+        @sr_uses_t2 = input.boolean?
+        @t1.load_state(input)
+        @t2.load_state(input)
+        @shift_register.load_state(input)
+        @ifr.load_state(input)
+        @ca.load_state(input)
+        @cb.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/via/timer1.rb

@@ -92,10 +92,29 @@ module Badline
         @counter = @reload ? 0xffff : @latch - phase + 1
       end
 
+      def save_state(out)
+        out.int(@counter).int(@latch).boolean(@hold).boolean(@reload).boolean(@armed).boolean(@pb7)
+      end
+
+      def load_state(input)
+        @counter = input.int
+        @latch = input.int
+        @hold = input.boolean?
+        @reload = input.boolean?
+        @armed = input.boolean?
+        @pb7 = input.boolean?
+      end
+
       # What the counter and PB7 don't hold, for comparing the timer at two
       # points.
       def state = [@latch, @armed]
 
+      # Whether a timeout sets the flag.
+      def armed? = @armed
+
+      # The count, for comparing the timer at two points where it matters.
+      def count_state = [@counter, @hold, @reload]
+
       private
 
       # The counter reloads either way. Armed, PB7 inverts and the flag

data/lib/badline/via/timer2.rb

@@ -84,10 +84,34 @@ module Badline
         @low_underflowed = @counter.allbits?(0xff)
       end
 
+      def save_state(out)
+        out.int(@counter).int(@latch_low)
+        [@hold, @low_reload, @armed, @low_underflowed, @count_pulses, @counting_pulses].each do |flag|
+          out.boolean(flag)
+        end
+      end
+
+      def load_state(input)
+        @counter = input.int
+        @latch_low = input.int
+        @hold = input.boolean?
+        @low_reload = input.boolean?
+        @armed = input.boolean?
+        @low_underflowed = input.boolean?
+        @count_pulses = input.boolean?
+        @counting_pulses = input.boolean?
+      end
+
       # What the counter and the low byte's underflow don't hold, for
       # comparing the timer at two points.
       def state = [@latch_low, @armed, @hold, @low_reload, @count_pulses, @counting_pulses]
 
+      # Whether the next underflow sets the flag.
+      def armed? = @armed
+
+      # The count, for comparing the timer at two points where it matters.
+      def count_state = [@counter, @low_underflowed]
+
       private
 
       # A cycle while counting pulses, or held after a load or a low byte

data/lib/badline/via.rb

@@ -4,6 +4,7 @@ require "badline/via/control_lines"
 require "badline/via/fast_forward"
 require "badline/via/interrupt_register"
 require "badline/via/shift_register"
+require "badline/via/state"
 require "badline/via/timer1"
 require "badline/via/timer2"
 
@@ -18,6 +19,7 @@ module Badline
   class VIA
     include Addressable
     include FastForward
+    include State
 
     attr_reader :start, :peripheral, :shift_register, :acr, :pcr
 

data/lib/badline/vic/border_mask.rb

@@ -27,6 +27,16 @@ module Badline
         @groups.fill(FULL)
       end
 
+      def save_state(out)
+        out.ints(@groups).booleans(@mask).blob(@snapshot)
+      end
+
+      def load_state(input)
+        input.ints_into(@groups)
+        input.booleans_into(@mask)
+        input.blob_into(@snapshot)
+      end
+
       def at?(pixel_x)
         case @groups[pixel_x >> 3]
         when FULL then true

data/lib/badline/vic/collisions.rb

@@ -36,6 +36,17 @@ module Badline
         @cleared_data = 0
       end
 
+      def save_state(out)
+        out.blob(@hits).int(@folded).int(@cleared_sprite).int(@cleared_data)
+      end
+
+      def load_state(input)
+        input.blob_into(@hits)
+        @folded = input.int
+        @cleared_sprite = input.int
+        @cleared_data = input.int
+      end
+
       def start_line
         @folded = 0
         @cleared_sprite = carry(@cleared_sprite)

data/lib/badline/vic/color_patches.rb

@@ -17,6 +17,17 @@ module Badline
 
       def clear = @patches.clear
 
+      # Each patch as its four numbers: the boundary pixel, the register,
+      # the old colour and the new.
+      def save_state(out)
+        out.int(@patches.length)
+        @patches.each { |patch| out.ints(patch) }
+      end
+
+      def load_state(input)
+        @patches.replace(Array.new(input.int) { input.ints })
+      end
+
       def log(reg, old, value, boundary_x)
         @patches << [boundary_x, reg, @grey_dots ? GREY_DOT : old & 0x0f, value & 0x0f]
       end

data/lib/badline/vic/display_state.rb

@@ -30,7 +30,7 @@ module Badline
 
       GRAPHICS_COLUMNS = Array.new(65) { |column| column.between?(GRAPHICS_FIRST, GRAPHICS_LAST) }.freeze
 
-      attr_reader :vc_base, :vc, :vmli, :rc
+      attr_reader :vc_base, :vc, :vmli, :rc, :bad_lines_enabled
 
       # The wrap column is the last column of a rasterline, 62 on the 6569,
       # which already compares against the line about to start, the same
@@ -50,6 +50,15 @@ module Badline
       end
 
       def display? = @display
+
+      # Sets VCBASE, VC, RC and VMLI, in that order, and the display and
+      # bad-line flags, as a VICE snapshot gives them.
+      def restore_counters(counters, display, bad_lines_enabled)
+        @vc_base, @vc, @rc, @vmli = counters
+        @display = display
+        @bad_lines_enabled = bad_lines_enabled
+      end
+
       def idle? = !@display
       def bad_line? = !@ba.nil?
 
@@ -63,6 +72,25 @@ module Badline
         @matched && column >= FETCH_FIRST && column <= DMA_LAST
       end
 
+      def save_state(out)
+        out.int(@vc_base).int(@vc).int(@vmli).int(@rc).boolean(@display).boolean(@bad_lines_enabled)
+        out.boolean(@matched).optional_int(@ba).int(@line_bits).boolean(@den_line).boolean(@in_window)
+      end
+
+      def load_state(input)
+        @vc_base = input.int
+        @vc = input.int
+        @vmli = input.int
+        @rc = input.int
+        @display = input.boolean?
+        @bad_lines_enabled = input.boolean?
+        @matched = input.boolean?
+        @ba = input.optional_int
+        @line_bits = input.int
+        @den_line = input.boolean?
+        @in_window = input.boolean?
+      end
+
       def new_frame
         @vc_base = 0
         @bad_lines_enabled = false

data/lib/badline/vic/graphics_shifter.rb

@@ -50,6 +50,24 @@ module Badline
         @late_read = false
       end
 
+      def save_state(out)
+        out.int(@next_ecm_bmm).int(@black_below).ints(@colors).booleans(@fg)
+        out.int(@gbuf).int(@vbuf).int(@cbuf).int(@flop).int(@pixel)
+        out.int(@mode_lookup).int(@mode_read).boolean(@late_mcm).boolean(@late_read)
+      end
+
+      def load_state(input)
+        @next_ecm_bmm = input.int
+        @black_below = input.int
+        input.ints_into(@colors)
+        input.booleans_into(@fg)
+        load_buffers(input)
+        @mode_lookup = input.int
+        @mode_read = input.int
+        @late_mcm = input.boolean?
+        @late_read = input.boolean?
+      end
+
       # Rebuilds the state at the end of a group that painted whole bytes:
       # the byte loaded at pixel shift under an unchanging mode.
       def prime(data, screencode, color, shift, mode)
@@ -78,6 +96,14 @@ module Badline
 
       private
 
+      def load_buffers(input)
+        @gbuf = input.int
+        @vbuf = input.int
+        @cbuf = input.int
+        @flop = input.int
+        @pixel = input.int
+      end
+
       def step_mode(pixel, mode)
         case pixel
         when 0 then start_group

data/lib/badline/vic/register_log.rb

@@ -19,6 +19,24 @@ module Badline
       # The pixel at which the next logged write takes effect.
       attr_reader :next_x
 
+      # The entries as pixel, register and value in turn, the seed with -1
+      # for a register the line hasn't logged, and a next pixel past the
+      # last entry as -1.
+      def save_state(out)
+        out.ints(@entries.flatten)
+        out.ints(@seed.map { |value| value.nil? ? -1 : value })
+        out.ints(@values).int(@cursor).int(@next_x.infinite? ? -1 : @next_x)
+      end
+
+      def load_state(input)
+        @entries.replace(input.ints.each_slice(3).to_a)
+        @seed.replace(input.ints.map { |value| value.negative? ? nil : value })
+        input.ints_into(@values)
+        @cursor = input.int
+        next_x = input.int
+        @next_x = next_x.negative? ? Float::INFINITY : next_x
+      end
+
       def empty? = @entries.empty?
       def length = @entries.length
 

data/lib/badline/vic/registers.rb

@@ -143,6 +143,15 @@ module Badline
 
       def latch_raster_irq! = latch_irq!(0x01)
 
+      def save_state(out)
+        out.blob(@bytes).boolean(@irq_line)
+      end
+
+      def load_state(input)
+        input.blob_into(@bytes)
+        @irq_line = input.boolean?
+      end
+
       def collide!(reg, bits)
         return false if bits.zero?
 
@@ -151,12 +160,14 @@ module Badline
         was_zero
       end
 
-      private
-
+      # Works the IRQ line out from $D019 and $D01A again, after the bytes
+      # were set directly.
       def update_irq_line
         @irq_line = (@bytes[0x19] & @bytes[0x1a]).anybits?(0x0f)
       end
 
+      private
+
       def read_clear(reg)
         @bytes[reg].tap { @bytes[reg] = 0 }
       end

data/lib/badline/vic/sequencer.rb

@@ -5,6 +5,7 @@ require "badline/vic/color_patches"
 require "badline/vic/graphics_mode"
 require "badline/vic/graphics_shifter"
 require "badline/vic/sequencer_output"
+require "badline/vic/sequencer_state"
 
 module Badline
   class VIC < Cycleable
@@ -13,6 +14,7 @@ module Badline
     # Turns fetched graphics data into output pixels.
     class Sequencer
       include Output
+      include SavedState
 
       BORDER_Y_BOUNDS = [
         [55, 247].freeze,
@@ -149,6 +151,16 @@ module Badline
       # slot before is the byte the previous group loaded.
       attr_reader :ring_data, :ring_char, :ring_color
 
+      # The border flip-flops: vertical, the vertical one armed to set, and
+      # the main one.
+      def borders = [@vertical_border, @vertical_armed, @main_border]
+
+      def restore_borders(vertical, armed, main)
+        @vertical_border = vertical
+        @vertical_armed = armed
+        @main_border = main
+      end
+
       # Paints the byte in the slot through the current mode. An idle access
       # latches 0/0 and one that made no access passes on zero data with the
       # kept values; under a closed border neither has foreground. A group

data/lib/badline/vic/sequencer_state.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sequencer
+      # The sequencer's save_state and load_state.
+      module SavedState
+        FG_SHIFTER = -1
+        PAIR_CODES = 256
+
+        # The line buffers, the border flip-flops, the g-access ring and the
+        # pixel pipeline. The foreground masks the groups point at go as
+        # FG_SHIFTER for the shift register's, or their data byte in
+        # GraphicsMode's HIRES_FG, or that plus 256 in its PAIR_FG. The left
+        # vertical border compare goes as -1 before it has run.
+        def save_state(out)
+          out.int(@line).boolean(@first_csel).int(@left_vertical_border.nil? ? -1 : bit(@left_vertical_border))
+          out.blob(@colors).booleans(@fg)
+          @border_mask.save_state(out)
+          out.ints(@cur_colors).int(fg_code(@cur_fg)).ints(@prev_colors).int(fg_code(@prev_fg))
+          out.boolean(@vertical_border).boolean(@vertical_armed).boolean(@main_border)
+          @color_patches.save_state(out)
+          @shifter.save_state(out)
+          out.int(@xscroll).int(@last_shift).int(@last_mode).boolean(@settling).boolean(@prev_fresh).boolean(@check)
+          out.ints(@ring_data).ints(@ring_char).ints(@ring_color)
+        end
+
+        def load_state(input)
+          load_line(input)
+          @border_mask.load_state(input)
+          input.ints_into(@cur_colors)
+          @cur_fg = fg_pattern(input.int)
+          input.ints_into(@prev_colors)
+          @prev_fg = fg_pattern(input.int)
+          @vertical_border = input.boolean?
+          @vertical_armed = input.boolean?
+          @main_border = input.boolean?
+          @color_patches.load_state(input)
+          @shifter.load_state(input)
+          load_pipeline(input)
+        end
+
+        private
+
+        def bit(flag) = flag ? 1 : 0
+
+        def load_line(input)
+          @line = input.int
+          @first_csel = input.boolean?
+          left = input.int
+          @left_vertical_border = left.negative? ? nil : left == 1
+          input.blob_into(@colors)
+          input.booleans_into(@fg)
+        end
+
+        def load_pipeline(input)
+          @xscroll = input.int
+          @last_shift = input.int
+          @last_mode = input.int
+          @settling = input.boolean?
+          @prev_fresh = input.boolean?
+          @check = input.boolean?
+          input.ints_into(@ring_data)
+          input.ints_into(@ring_char)
+          input.ints_into(@ring_color)
+        end
+
+        def fg_code(pattern)
+          return FG_SHIFTER if pattern.equal?(@shifter.fg)
+
+          hires = GraphicsMode::HIRES_FG.index { |fg| fg.equal?(pattern) }
+          return hires if hires
+
+          pair = GraphicsMode::PAIR_FG.index { |fg| fg.equal?(pattern) }
+          raise ArgumentError, "a foreground mask the sequencer doesn't know" unless pair
+
+          PAIR_CODES + pair
+        end
+
+        def fg_pattern(code)
+          return @shifter.fg if code == FG_SHIFTER
+          return GraphicsMode::HIRES_FG.fetch(code) if code < PAIR_CODES
+
+          GraphicsMode::PAIR_FG.fetch(code - PAIR_CODES)
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic/sprite/internal_bus.rb

@@ -25,6 +25,17 @@ module Badline
           @line = Array.new(columns, -1)
         end
 
+        def save_state(out)
+          out.int(@lines).int(@ghost).ints(@value).ints(@line)
+        end
+
+        def load_state(input)
+          @lines = input.int
+          @ghost = input.int
+          input.ints_into(@value)
+          input.ints_into(@line)
+        end
+
         # Sprites 3-7 fetch in Bauer cycles 1-10, so the idle byte is taken
         # as the line starts.
         def start_line(sprites_enabled)

data/lib/badline/vic/sprite/saved_state.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sprite
+      # The sprite's save_state and load_state.
+      module SavedState
+        # The shift register, MC, MCBASE, the expansion flip-flop and whether
+        # the sprite shows, for a VICE snapshot.
+        attr_reader :sr, :mc, :mcbase, :exp_ff, :display_on
+
+        # Sets MC, MCBASE, the expansion flip-flop, whether the sprite's DMA
+        # runs and whether it shows, as a VICE snapshot gives them.
+        def restore_counters(counter, base, expanded, dma, shows)
+          @mc = counter
+          @mcbase = base
+          @exp_ff = expanded
+          @dma = dma
+          @display_on = shows
+        end
+
+        def save_state(out)
+          out.boolean(@dma).boolean(@display_on).int(@mcbase).int(@mc).boolean(@exp_ff).optional_int(@crunched_mc)
+          out.int(@bits).boolean(@row_ready).optional_int(@prev_bits).boolean(@first_byte_lost).boolean(@blind)
+          out.int(@show_from).optional_int(@stop_x)
+          out.ints(@codes).int(@leftmost).int(@span).ints(@reload_codes).int(@reload_leftmost).int(@reload_span)
+          out.int(@sr).int(@latch).boolean(@mc_flop).boolean(@xe_flop)
+        end
+
+        def load_state(input)
+          load_counters(input)
+          @show_from = input.int
+          @stop_x = input.optional_int
+          input.ints_into(@codes)
+          @leftmost = input.int
+          @span = input.int
+          input.ints_into(@reload_codes)
+          @reload_leftmost = input.int
+          @reload_span = input.int
+          @sr = input.int
+          @latch = input.int
+          @mc_flop = input.boolean?
+          @xe_flop = input.boolean?
+        end
+
+        private
+
+        def load_counters(input)
+          @dma = input.boolean?
+          @display_on = input.boolean?
+          @mcbase = input.int
+          @mc = input.int
+          @exp_ff = input.boolean?
+          @crunched_mc = input.optional_int
+          @bits = input.int
+          @row_ready = input.boolean?
+          @prev_bits = input.optional_int
+          @first_byte_lost = input.boolean?
+          @blind = input.boolean?
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic/sprite.rb

@@ -2,6 +2,7 @@
 
 require "badline/vic/sprite/internal_bus"
 require "badline/vic/sprite/shifter"
+require "badline/vic/sprite/saved_state"
 require "badline/vic/sprite/timing"
 
 module Badline
@@ -51,6 +52,7 @@ module Badline
       DISPLAY_OFF_X = 460
 
       include Shifter
+      include SavedState
 
       attr_reader :index, :leftmost, :span, :codes,
                   :reload_leftmost, :reload_span, :reload_codes

data/lib/badline/vic/sprites.rb

@@ -3,10 +3,13 @@
 require "badline/vic/collisions"
 require "badline/vic/register_log"
 require "badline/vic/sprite"
+require "badline/vic/sprites_state"
 
 module Badline
   class VIC < Cycleable
     class Sprites
+      include SavedState
+
       # Pixels between the start of the cycle following a write and the
       # point the new value shows. Each signal reaches the output on its own
       # path: the colors feed the final mux, the sequencer inputs — X