badline 0.12.1 → 0.14.0

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      class Registers
+        # The registers as the VIC holds them. The IRQ line comes from
+        # $D019 and $D01A on load.
+        module KeyedState
+          def save_fields(out)
+            out.bytes("registers", @bytes)
+          end
+
+          def load_fields(input)
+            input.bytes_into("registers", @bytes)
+          end
+
+          def restored! = update_irq_line
+        end
+
+        include KeyedState
+      end
+
+      class DisplayState
+        # The video counters, the row counter, display or idle state, the
+        # bad line conditions and BA.
+        module KeyedState
+          def save_fields(out)
+            out.int("vc_base", @vc_base).int("vc", @vc).int("vmli", @vmli).int("rc", @rc)
+            out.bool("display_state", @display).bool("bad_lines_enabled", @bad_lines_enabled).bool("matched", @matched)
+            out.optional_int("ba", @ba)
+            out.int("line_bits", @line_bits).bool("den_line", @den_line).bool("in_window", @in_window)
+          end
+
+          def load_fields(input)
+            @vc_base = input.masked("vc_base", @vc_base, 0x3ff)
+            @vc = input.masked("vc", @vc, 0x3ff)
+            @vmli = input.int("vmli", @vmli)
+            @rc = input.masked("rc", @rc, 0x07)
+            @display = input.bool("display_state", @display)
+            @bad_lines_enabled = input.bool("bad_lines_enabled", @bad_lines_enabled)
+            @matched = input.bool("matched", @matched)
+            @ba = input.optional_int("ba")
+            @line_bits = input.int("line_bits", @line_bits)
+            @den_line = input.bool("den_line", @den_line)
+            @in_window = input.bool("in_window", @in_window)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class GraphicsShifter
+        # The pipeline between the g-access and the pixels, under `prefix`.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}next_ecm_bmm", @next_ecm_bmm).int("#{prefix}black_below", @black_below)
+            out.ints("#{prefix}colors", @colors).ints("#{prefix}fg", @fg.map { |set| set ? 1 : 0 })
+            out.int("#{prefix}gbuf", @gbuf).int("#{prefix}vbuf", @vbuf).int("#{prefix}cbuf", @cbuf)
+            out.int("#{prefix}flop", @flop).int("#{prefix}pixel", @pixel).int("#{prefix}mode_lookup", @mode_lookup)
+            out.int("#{prefix}mode_read", @mode_read).bool("#{prefix}late_mcm", @late_mcm)
+            out.bool("#{prefix}late_read", @late_read)
+          end
+
+          def load_fields(input, prefix)
+            @next_ecm_bmm = input.int("#{prefix}next_ecm_bmm", @next_ecm_bmm)
+            @black_below = input.int("#{prefix}black_below", @black_below)
+            input.ints_into("#{prefix}colors", @colors)
+            fg = input.ints("#{prefix}fg", @fg.map { |set| set ? 1 : 0 })
+            @fg.each_index { |index| @fg[index] = fg.fetch(index, 0) == 1 }
+            @gbuf = input.int("#{prefix}gbuf", @gbuf)
+            @vbuf = input.int("#{prefix}vbuf", @vbuf)
+            @cbuf = input.int("#{prefix}cbuf", @cbuf)
+            @flop = input.int("#{prefix}flop", @flop)
+            @pixel = input.int("#{prefix}pixel", @pixel)
+            @mode_lookup = input.int("#{prefix}mode_lookup", @mode_lookup)
+            @mode_read = input.int("#{prefix}mode_read", @mode_read)
+            @late_mcm = input.bool("#{prefix}late_mcm", @late_mcm)
+            @late_read = input.bool("#{prefix}late_read", @late_read)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class BorderMask
+        # The line's border coverage, under `prefix`.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.ints("#{prefix}groups", @groups).ints("#{prefix}mask", @mask.map { |set| set ? 1 : 0 })
+            out.bytes("#{prefix}snapshot", @snapshot)
+          end
+
+          def load_fields(input, prefix)
+            input.ints_into("#{prefix}groups", @groups)
+            mask = input.ints("#{prefix}mask", @mask.map { |set| set ? 1 : 0 })
+            @mask.each_index { |index| @mask[index] = mask.fetch(index, 0) == 1 }
+            input.bytes_into("#{prefix}snapshot", @snapshot)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class ColorPatches
+        # The line's colour writes, four values to a patch, under `prefix`.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.ints("#{prefix}patches", @patches.flatten)
+          end
+
+          def load_fields(input, prefix)
+            values = input.ints("#{prefix}patches", [])
+            @patches.replace(values.each_slice(4).to_a)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Sequencer
+        # The sequencer's fields: the border flip-flops and compares, the
+        # pixel pipeline and the shifter, with the line batch under
+        # `line_prefix` when `line` is true. Foreground masks go as text:
+        # "shifter", or the mode table and the data byte.
+        module KeyedState
+          # The foreground patterns' codes: the shifter's own, HIRES_FG's by
+          # index, and PAIR_FG's after them.
+          FG_SHIFTER = -1
+          PAIR_CODES = 256
+
+          def save_fields(out, line_prefix)
+            out.bool("first_csel", @first_csel).optional_int("left_vertical_border", left_vertical_code)
+            out.ints("cur_colors", @cur_colors).text("cur_fg", fg_name(@cur_fg))
+            out.ints("prev_colors", @prev_colors).text("prev_fg", fg_name(@prev_fg))
+            out.bool("vertical_border", @vertical_border).bool("vertical_armed", @vertical_armed)
+            out.bool("main_border", @main_border).int("xscroll", @xscroll).int("last_shift", @last_shift)
+            out.int("last_mode", @last_mode).bool("settling", @settling).bool("prev_fresh", @prev_fresh)
+            out.bool("check", @check)
+            @shifter.save_fields(out, "shifter.")
+            out.int("#{line_prefix}number", @line).bytes("#{line_prefix}colors", @colors)
+            out.ints("#{line_prefix}fg", @fg.map { |set| set ? 1 : 0 })
+            @border_mask.save_fields(out, "#{line_prefix}border.")
+            @color_patches.save_fields(out, line_prefix)
+          end
+
+          def load_fields(input, line_prefix, line)
+            @first_csel = input.bool("first_csel", @first_csel)
+            left = input.optional_int("left_vertical_border")
+            @left_vertical_border = left.nil? ? nil : left == 1
+            input.ints_into("cur_colors", @cur_colors)
+            @cur_fg = fg_named(input.text("cur_fg", fg_name(@cur_fg)))
+            input.ints_into("prev_colors", @prev_colors)
+            @prev_fg = fg_named(input.text("prev_fg", fg_name(@prev_fg)))
+            load_pipeline_fields(input)
+            @shifter.load_fields(input, "shifter.")
+            load_line_fields(input, line_prefix) if line
+          end
+
+          private
+
+          def left_vertical_code
+            left = @left_vertical_border
+            return nil if left.nil?
+
+            left ? 1 : 0
+          end
+
+          def load_pipeline_fields(input)
+            @vertical_border = input.bool("vertical_border", @vertical_border)
+            @vertical_armed = input.bool("vertical_armed", @vertical_armed)
+            @main_border = input.bool("main_border", @main_border)
+            @xscroll = input.masked("xscroll", @xscroll, 0x07)
+            @last_shift = input.int("last_shift", @last_shift)
+            @last_mode = input.int("last_mode", @last_mode)
+            @settling = input.bool("settling", @settling)
+            @prev_fresh = input.bool("prev_fresh", @prev_fresh)
+            @check = input.bool("check", @check)
+          end
+
+          def load_line_fields(input, line_prefix)
+            @line = input.int("#{line_prefix}number", @line)
+            input.bytes_into("#{line_prefix}colors", @colors)
+            fg = input.ints("#{line_prefix}fg", @fg.map { |set| set ? 1 : 0 })
+            @fg.each_index { |index| @fg[index] = fg.fetch(index, 0) == 1 }
+            @border_mask.load_fields(input, "#{line_prefix}border.")
+            @color_patches.load_fields(input, line_prefix)
+          end
+
+          def fg_name(pattern)
+            code = fg_code(pattern)
+            return "shifter" if code == FG_SHIFTER
+            return "hires:#{code}" if code < PAIR_CODES
+
+            "pair:#{code - PAIR_CODES}"
+          end
+
+          def fg_named(name)
+            return @shifter.fg if name == "shifter"
+
+            table, number = name.split(":")
+            index = number.to_i
+            return GraphicsMode::PAIR_FG.fetch(index.clamp(0, GraphicsMode::PAIR_FG.length - 1)) if table == "pair"
+
+            GraphicsMode::HIRES_FG.fetch(index.clamp(0, GraphicsMode::HIRES_FG.length - 1))
+          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
+        end
+
+        include KeyedState
+      end
+    end
+  end
+end
+
+require "badline/chips/vic/keyed_sprites"
+require "badline/chips/vic/keyed_state"

data/lib/badline/chips/vic/keyed_sprites.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      class Sprite
+        # A sprite's fields under `prefix`: its DMA and display, MC, MCBASE
+        # and the expansion flip-flop, the fetch in progress and the shift
+        # register, and the line batch under `line_prefix` when `line` is
+        # true.
+        module KeyedState
+          # 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_fields(out, prefix, line_prefix)
+            out.bool("#{prefix}dma", @dma).bool("#{prefix}display_on", @display_on).int("#{prefix}mcbase", @mcbase)
+            out.int("#{prefix}mc", @mc).bool("#{prefix}exp_ff", @exp_ff).optional_int("#{prefix}crunched_mc",
+                                                                                      @crunched_mc)
+            out.int("#{prefix}bits", @bits).bool("#{prefix}row_ready", @row_ready)
+            out.optional_int("#{prefix}prev_bits", @prev_bits).bool("#{prefix}first_byte_lost", @first_byte_lost)
+            out.bool("#{prefix}blind", @blind).int("#{prefix}sr", @sr).int("#{prefix}latch", @latch)
+            out.bool("#{prefix}mc_flop", @mc_flop).bool("#{prefix}xe_flop", @xe_flop)
+            save_line_fields(out, line_prefix)
+          end
+
+          def load_fields(input, prefix, line_prefix, line)
+            @dma = input.bool("#{prefix}dma", @dma)
+            @display_on = input.bool("#{prefix}display_on", @display_on)
+            @mcbase = input.masked("#{prefix}mcbase", @mcbase, 0x3f)
+            @mc = input.masked("#{prefix}mc", @mc, 0x3f)
+            @exp_ff = input.bool("#{prefix}exp_ff", @exp_ff)
+            @crunched_mc = input.optional_int("#{prefix}crunched_mc")
+            @bits = input.int("#{prefix}bits", @bits)
+            @row_ready = input.bool("#{prefix}row_ready", @row_ready)
+            @prev_bits = input.optional_int("#{prefix}prev_bits")
+            @first_byte_lost = input.bool("#{prefix}first_byte_lost", @first_byte_lost)
+            @blind = input.bool("#{prefix}blind", @blind)
+            @sr = input.int("#{prefix}sr", @sr)
+            @latch = input.int("#{prefix}latch", @latch)
+            @mc_flop = input.bool("#{prefix}mc_flop", @mc_flop)
+            @xe_flop = input.bool("#{prefix}xe_flop", @xe_flop)
+            load_line_fields(input, line_prefix) if line
+          end
+
+          private
+
+          def save_line_fields(out, prefix)
+            out.int("#{prefix}show_from", @show_from).optional_int("#{prefix}stop_x", @stop_x)
+            out.ints("#{prefix}codes", @codes).int("#{prefix}leftmost", @leftmost).int("#{prefix}span", @span)
+            out.ints("#{prefix}reload_codes", @reload_codes).int("#{prefix}reload_leftmost", @reload_leftmost)
+            out.int("#{prefix}reload_span", @reload_span)
+          end
+
+          def load_line_fields(input, prefix)
+            @show_from = input.int("#{prefix}show_from", @show_from)
+            @stop_x = input.optional_int("#{prefix}stop_x")
+            input.ints_into("#{prefix}codes", @codes)
+            @leftmost = input.int("#{prefix}leftmost", @leftmost)
+            @span = input.int("#{prefix}span", @span)
+            input.ints_into("#{prefix}reload_codes", @reload_codes)
+            @reload_leftmost = input.int("#{prefix}reload_leftmost", @reload_leftmost)
+            @reload_span = input.int("#{prefix}reload_span", @reload_span)
+          end
+        end
+
+        include KeyedState
+
+        class InternalBus
+          # The sprites' internal bus, under `prefix`.
+          module KeyedState
+            def save_fields(out, prefix)
+              out.int("#{prefix}lines", @lines).int("#{prefix}ghost", @ghost).ints("#{prefix}value", @value)
+              out.ints("#{prefix}line", @line)
+            end
+
+            def load_fields(input, prefix)
+              @lines = input.int("#{prefix}lines", @lines)
+              @ghost = input.byte("#{prefix}ghost", @ghost)
+              input.ints_into("#{prefix}value", @value)
+              input.ints_into("#{prefix}line", @line)
+            end
+          end
+
+          include KeyedState
+        end
+      end
+
+      class Collisions
+        # The read-clear timing at the beam, and the line's coverage under
+        # `line_prefix` when `line` is true.
+        module KeyedState
+          def save_fields(out, line_prefix)
+            out.int("collisions.cleared_sprite", @cleared_sprite).int("collisions.cleared_data", @cleared_data)
+            out.bytes("#{line_prefix}hits", @hits).int("#{line_prefix}folded", @folded)
+          end
+
+          def load_fields(input, line_prefix, line)
+            @cleared_sprite = input.int("collisions.cleared_sprite", @cleared_sprite)
+            @cleared_data = input.int("collisions.cleared_data", @cleared_data)
+            return unless line
+
+            input.bytes_into("#{line_prefix}hits", @hits)
+            @folded = input.int("#{line_prefix}folded", @folded)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class RegisterLog
+        # The line's sprite register writes, under `prefix`: the entries as
+        # pixel, register and value in turn, the seed with -1 for a register
+        # not logged, and the next pixel as -1 past the last entry.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.ints("#{prefix}entries", @entries.flatten)
+            out.ints("#{prefix}seed", @seed.map { |value| value.nil? ? -1 : value })
+            out.ints("#{prefix}values", @values).int("#{prefix}cursor", @cursor)
+            out.int("#{prefix}next_x", @next_x.infinite? ? -1 : @next_x)
+          end
+
+          def load_fields(input, prefix)
+            @entries.replace(input.ints("#{prefix}entries", []).each_slice(3).to_a)
+            @seed.replace(input.ints("#{prefix}seed", []).map { |value| value.negative? ? nil : value })
+            input.ints_into("#{prefix}values", @values)
+            @cursor = input.int("#{prefix}cursor", @cursor)
+            next_x = input.int("#{prefix}next_x", 0)
+            @next_x = next_x.negative? ? Float::INFINITY : next_x
+          end
+        end
+
+        include KeyedState
+      end
+
+      class Sprites
+        # The sprites under sprite0. to sprite7., their bus under sbus.,
+        # the collisions, and the line batch under `line_prefix`: the
+        # window's colours and priorities, the span touched, the pixels
+        # carried into the next line, the register log. Whether any DMA
+        # runs comes from the sprites on load.
+        module KeyedState
+          # Whether any sprite's DMA runs, set after Sprite#restore_counters.
+          def update_any_dma
+            @any_dma = @sprites.any?(&:displaying?)
+          end
+
+          def save_fields(out, line_prefix)
+            @sprites.each do |sprite|
+              sprite.save_fields(out, "sprite#{sprite.index}.", "#{line_prefix}sprite#{sprite.index}.")
+            end
+            @bus.save_fields(out, "sbus.")
+            @collisions.save_fields(out, "#{line_prefix}collisions.")
+            out.bool("#{line_prefix}carried", @carried).int("#{line_prefix}lo", @lo).int("#{line_prefix}hi", @hi)
+            out.int("#{line_prefix}sequenced", @sequenced).bytes("#{line_prefix}win_color", @win_color)
+            out.ints("#{line_prefix}win_priority", @win_priority.map { |set| set ? 1 : 0 })
+            out.ints("#{line_prefix}palette", @palette).bool("#{line_prefix}stopped_dma", @stopped_dma)
+            save_carry_fields(out, "#{line_prefix}carry", @carry)
+            save_carry_fields(out, "#{line_prefix}carry_next", @carry_next)
+            @log.save_fields(out, "#{line_prefix}log.")
+          end
+
+          def load_fields(input, line_prefix, line)
+            @sprites.each do |sprite|
+              sprite.load_fields(input, "sprite#{sprite.index}.", "#{line_prefix}sprite#{sprite.index}.", line)
+            end
+            @bus.load_fields(input, "sbus.")
+            @collisions.load_fields(input, "#{line_prefix}collisions.", line)
+            load_line_fields(input, line_prefix) if line
+          end
+
+          def restored! = update_any_dma
+
+          private
+
+          def load_line_fields(input, prefix)
+            @carried = input.bool("#{prefix}carried", @carried)
+            @lo = input.int("#{prefix}lo", @lo)
+            @hi = input.int("#{prefix}hi", @hi)
+            @sequenced = input.int("#{prefix}sequenced", @sequenced)
+            input.bytes_into("#{prefix}win_color", @win_color)
+            priority = input.ints("#{prefix}win_priority", @win_priority.map { |set| set ? 1 : 0 })
+            @win_priority.each_index { |index| @win_priority[index] = priority.fetch(index, 0) == 1 }
+            input.ints_into("#{prefix}palette", @palette)
+            @stopped_dma = input.bool("#{prefix}stopped_dma", @stopped_dma)
+            load_carry_fields(input, "#{prefix}carry", @carry)
+            load_carry_fields(input, "#{prefix}carry_next", @carry_next)
+            @log.load_fields(input, "#{prefix}log.")
+          end
+
+          # Each sprite's carried pixels as x, colour and priority (0 or 1)
+          # in turn.
+          def save_carry_fields(out, prefix, carry)
+            carry.each_with_index do |pixels, index|
+              values = []
+              pixels.each_slice(3) { |x, color, priority| values.push(x, color, priority ? 1 : 0) }
+              out.ints("#{prefix}#{index}", values)
+            end
+          end
+
+          def load_carry_fields(input, prefix, carry)
+            carry.each_with_index do |pixels, index|
+              pixels.clear
+              input.ints("#{prefix}#{index}", []).each_slice(3) do |x, color, priority|
+                pixels.push(x, color, priority == 1)
+              end
+            end
+          end
+        end
+
+        include KeyedState
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      # The shape of the line batch the renderer keeps (design note §9.2).
+      # A snapshot whose line.layout differs restarts the rest of its line
+      # with an empty pipeline.
+      LINE_LAYOUT = 1
+
+      # The VIC-II's fields in a keyed snapshot module (Snapshot::Keyed):
+      # the beam, the g-access ring oldest first under g.*, the light pen
+      # and raster latches, the video matrix line, the registers, the
+      # display state, the sequencer and the sprites, the line batch under
+      # line.* with line.layout, and the picture as display. The IRQ line,
+      # the sprites' BA columns, whether any sprite DMA runs and the
+      # display's copy of the lines are worked out on load.
+      module KeyedState
+        def save_fields(out)
+          out.int("column", @column).int("raster", @rasterline).int("fetch_d011", @fetch_d011)
+          save_ring_fields(out)
+          out.bool("lp_triggered", @lp_triggered).bool("lp_low", @lp_low).bool("raster_match", @raster_match)
+          out.int("bank_lines", @vic_bank.lines).bytes("character_buffer", @character_buffer)
+          out.bytes("color_buffer", @color_buffer)
+          out.int("output_line", @output_line).bool("test_wrap", @test_wrap) if @iie
+          @registers.save_fields(out)
+          @display_state.save_fields(out)
+          out.int("line.layout", LINE_LAYOUT)
+          @sequencer.save_fields(out, "line.")
+          @sprites.save_fields(out, "line.")
+          out.bytes("display", @lines.flatten)
+          out
+        end
+
+        def load_fields(input)
+          @column = input.int("column", @column)
+          @rasterline = @output_line = input.int("raster", @rasterline)
+          @fetch_d011 = input.byte("fetch_d011", @fetch_d011)
+          load_ring_fields(input)
+          @lp_triggered = input.bool("lp_triggered", @lp_triggered)
+          @lp_low = input.bool("lp_low", @lp_low)
+          @raster_match = input.bool("raster_match", @raster_match)
+          @vic_bank.lines = input.int("bank_lines", @vic_bank.lines)
+          input.bytes_into("character_buffer", @character_buffer)
+          input.bytes_into("color_buffer", @color_buffer)
+          load_test_fields(input) if @iie
+          @registers.load_fields(input)
+          @display_state.load_fields(input)
+          line = input.int("line.layout", 0) == LINE_LAYOUT
+          input.adjust("line in progress from another renderer, restarted") unless line || input.missing?
+          @sequencer.load_fields(input, "line.", line)
+          @sprites.load_fields(input, "line.", line)
+          load_display_fields(input)
+        end
+
+        def restored!
+          @registers.restored!
+          @sprites.restored!
+          rebuild_sprite_ba
+          @dirty_lines.fill(true)
+        end
+
+        private
+
+        # Oldest first, so the ring's base is the reader's own.
+        def save_ring_fields(out)
+          order = Array.new(4) { |age| (@g_tick + 1 + age) & 3 }
+          out.ints("g.kind", order.map { |slot| @g_kind[slot] }).ints("g.data", order.map { |slot| @g_data[slot] })
+          out.ints("g.char", order.map { |slot| @g_char[slot] }).ints("g.color", order.map { |slot| @g_color[slot] })
+          out.int("g.kept_char", @g_kept_char).int("g.kept_color", @g_kept_color).bool("g.display", @g_display)
+        end
+
+        def load_ring_fields(input)
+          @g_tick = 3
+          input.ints_into("g.kind", @g_kind)
+          input.ints_into("g.data", @g_data)
+          input.ints_into("g.char", @g_char)
+          input.ints_into("g.color", @g_color)
+          @g_kept_char = input.byte("g.kept_char", @g_kept_char)
+          @g_kept_color = input.masked("g.kept_color", @g_kept_color, 0x0f)
+          @g_display = input.bool("g.display", @g_display)
+        end
+
+        def load_test_fields(input)
+          @output_line = input.int("output_line", @output_line)
+          @test_wrap = input.bool("test_wrap", @test_wrap)
+        end
+
+        def load_display_fields(input)
+          display = @lines.flatten
+          input.bytes_into("display", display)
+          @lines.each_with_index do |line, number|
+            line.replace(display[number * @width, @width])
+            @display[number * @width, @width] = line
+          end
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

data/lib/badline/chips/vic/register_log.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Badline
+  module Chips
+    class VIC
+      # Mid-line writes to the sprite registers, keyed by the pixel at which
+      # they become visible. Compositing replays the line through the log, so
+      # each pixel is drawn with the register values that were in effect when
+      # the VIC reached it.
+      class RegisterLog
+        def initialize(registers)
+          @registers = registers
+          @entries = []
+          @seed = []
+          @values = Array.new(2**6, 0)
+          @cursor = 0
+          @next_x = 0
+        end
+
+        # The pixel at which the next logged write takes effect.
+        attr_reader :next_x
+
+        def empty? = @entries.empty?
+        def length = @entries.length
+
+        def clear
+          return if @entries.empty?
+
+          @entries.clear
+          @seed.clear
+        end
+
+        def log(pixel_x, reg, old, value)
+          @seed[reg] = old if @seed[reg].nil?
+          @entries << [pixel_x, reg, value]
+        end
+
+        def prepare
+          @entries.sort_by! { |entry| entry[0] }
+        end
+
+        # Restart the cursor before the line's first pixel, with every logged
+        # register back at the value it held when the line started.
+        def rewind
+          @values.length.times { |reg| @values[reg] = @registers[reg] }
+          @seed.each_with_index { |value, reg| @values[reg] = value unless value.nil? }
+          @cursor = 0
+          @next_x = @entries.empty? ? Float::INFINITY : @entries[0][0]
+        end
+
+        def [](reg) = @values[reg]
+
+        # Apply every write visible at or before pixel_x.
+        def advance(pixel_x)
+          while @cursor < @entries.length && @entries[@cursor][0] <= pixel_x
+            entry = @entries[@cursor]
+            @values[entry[1]] = entry[2]
+            @cursor += 1
+          end
+          @next_x = @cursor < @entries.length ? @entries[@cursor][0] : Float::INFINITY
+        end
+      end
+    end
+  end
+end