badline 0.5.1 → 0.6.0

data/lib/badline/via/timer1.rb

@@ -92,6 +92,19 @@ 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]

data/lib/badline/via/timer2.rb

@@ -84,6 +84,24 @@ 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]

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

data/lib/badline/vic/sprites_state.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sprites
+      # The sprites' save_state and load_state.
+      module SavedState
+        # Whether any sprite's DMA runs, set after Sprite#restore_counters.
+        def update_any_dma
+          @any_dma = @sprites.any?(&:displaying?)
+        end
+
+        # The sprites, their shared bus, the collisions and the register log,
+        # then the line's coverage and the pixels carried into the next line,
+        # each as x, colour and priority.
+        def save_state(out)
+          out.boolean(@any_dma).boolean(@stopped_dma).boolean(@carried).int(@lo).int(@hi).int(@sequenced)
+          out.blob(@win_color).booleans(@win_priority).ints(@palette)
+          [@carry, @carry_next].each { |carry| carry.each { |pixels| save_carry(pixels, out) } }
+          @sprites.each { |sprite| sprite.save_state(out) }
+          @bus.save_state(out)
+          @collisions.save_state(out)
+          @log.save_state(out)
+        end
+
+        def load_state(input)
+          @any_dma = input.boolean?
+          @stopped_dma = input.boolean?
+          @carried = input.boolean?
+          @lo = input.int
+          @hi = input.int
+          @sequenced = input.int
+          input.blob_into(@win_color)
+          input.booleans_into(@win_priority)
+          input.ints_into(@palette)
+          [@carry, @carry_next].each { |carry| carry.each { |pixels| load_carry(pixels, input) } }
+          @sprites.each { |sprite| sprite.load_state(input) }
+          @bus.load_state(input)
+          @collisions.load_state(input)
+          @log.load_state(input)
+        end
+
+        private
+
+        def save_carry(pixels, out)
+          out.int(pixels.length / 3)
+          pixels.each_slice(3) { |x, color, priority| out.int(x).int(color).boolean(priority) }
+        end
+
+        def load_carry(pixels, input)
+          pixels.clear
+          input.int.times { pixels.push(input.int, input.int, input.boolean?) }
+        end
+      end
+    end
+  end
+end