badline 0.1.0 → 0.2.1

data/lib/badline/vic/sprites.rb

@@ -1,111 +1,273 @@
 # frozen_string_literal: true
 
+require "badline/vic/collisions"
+require "badline/vic/register_log"
 require "badline/vic/sprite"
 
 module Badline
   class VIC < Cycleable
     class Sprites
-      # $D019 latch bits raised by the collision registers.
-      SPRITE_COLLISION_IRQ = 0x04 # IMMC, mirrors $D01E
-      DATA_COLLISION_IRQ   = 0x02 # IMBC, mirrors $D01F
+      # 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
+      # position, multicolor and expansion — sit furthest upstream, and the
+      # priority mux lands one pixel ahead of them.
+      COLOR_DELAY = 1
+      PRIORITY_DELAY = 6
+      SEQUENCER_DELAY = 7
+
+      # The beam position a CPU write in Bauer cycle 15 sees: the VIC has
+      # run column 13 and runs column 14, where MCBASE moves, next.
+      CRUNCH_X = 14 * 8
+
+      WRITE_DELAY = Array.new(2**6).tap do |delays|
+        (0x00..0x0e).step(2) { |reg| delays[reg] = SEQUENCER_DELAY }
+        [0x10, 0x1c, 0x1d].each { |reg| delays[reg] = SEQUENCER_DELAY }
+        delays[0x1b] = PRIORITY_DELAY
+        [0x25, 0x26, *0x27..0x2e].each { |reg| delays[reg] = COLOR_DELAY }
+      end.freeze
 
       def initialize(registers, bank, width)
         @registers = registers
         @bank = bank
         @width = width
-        @sprites = Array.new(8) { |i| Sprite.new(i, registers, bank, width) }
-        @hits = Array.new(width, 0)
+        @bus = Sprite::InternalBus.new(bank, width / 8)
+        @sprites = Array.new(8) { |i| Sprite.new(i, registers, bank, width, @bus) }
+        @collisions = Collisions.new(registers, width)
+        @hits = @collisions.hits
         @win_color = Array.new(width, 0)
         @win_priority = Array.new(width, false)
+        @palette = Array.new(4, 0)
+        @log = RegisterLog.new(registers)
+        @any_dma = false
+        @stopped_dma = false
+        @carry = Array.new(8) { [] }
+        @carry_next = Array.new(8) { [] }
+        @carried = false
+        @lo = width
+        @hi = 0
+        @sequenced = -1
       end
 
       def [](index) = @sprites[index]
 
-      def start_line(line)
-        @sprites.each { |sprite| sprite.start_line(line) }
+      # Pixels a sprite drew past the end of the last line land at the start
+      # of this one, which is when the beam reaches them.
+      def start_line
+        @bus.start_line(@registers[0x15].nonzero?)
+        @log.clear
+        @sprites.each(&:start_line)
+        @collisions.start_line
+        @sequenced = -1
+        @carry, @carry_next = @carry_next, @carry
+        @carry_next.each(&:clear)
+        @carried = @carry.any?(&:any?)
+      end
+
+      # Bauer cycle 16, two columns ahead like the compares: MCBASE takes
+      # MC for every sprite whose expansion flip-flop is set.
+      def advance_mcbase
+        @sprites.each(&:advance_mcbase) if @any_dma
+      end
+
+      # The end-of-sprite compare, a column after MCBASE moves. It is the
+      # only point a sprite's DMA stops, so the cached flag is settled here
+      # and set again by the compare that starts one.
+      def finish_mcbase
+        @stopped_dma = false
+        return unless @any_dma
+
+        running = @sprites.count(&:displaying?)
+        @sprites.each(&:finish_mcbase)
+        still = @sprites.count(&:displaying?)
+        @any_dma = still.positive?
+        @stopped_dma = still < running
+      end
+
+      # True when the last #finish_mcbase ended a DMA, so the BA columns
+      # have to be rebuilt without it.
+      def stopped_dma? = @stopped_dma
+
+      # Bauer cycle 56, after the second Y compare.
+      def toggle_expansion
+        @sprites.each(&:toggle_expansion) if @any_dma
+      end
+
+      # Run the Y/enable compare (Bauer cycles 55/56) for every sprite;
+      # returns true when any sprite turned its DMA on, so the BA columns
+      # can be rebuilt mid-line.
+      def check_dma(line, column)
+        return false if @registers[0x15].zero?
+
+        hit = @sprites.map { |sprite| sprite.check_dma(line, column) }.any?
+        @any_dma ||= hit
+        hit
+      end
+
+      # Not gated on the DMA flag, since this is where a display outlives its
+      # DMA. MC now points at the next row, which a sprite firing after its
+      # reload shows, so a line sequenced before this has to be redone.
+      def check_display(line)
+        @sprites.each { |sprite| sprite.check_display(line) }
+        @sequenced = -1
+      end
+
+      # A CPU access to a VIC register, in the cycle after the VIC's
+      # `column`.
+      def bus_data(column, value) = @bus.access(column, value)
+
+      # Not gated on the DMA flag: a row fetched at the start of the line
+      # still renders when cycle 16 ends the sprite.
+      def active? = @carried || @sprites.any?(&:rendering?)
+
+      # Record a mid-line write at the pixel where it becomes visible.
+      def log_change(reg, old, value, beam_x)
+        clear_y_expansion(old & ~value, beam_x) if reg == 0x17
+        delay = WRITE_DELAY[reg]
+        return unless delay && active?
+
+        @log.log(beam_x + delay, reg, old, value)
+      end
+
+      # Latch the collisions for every sprite pixel the beam has passed
+      # since the last fold.
+      def collide_upto(beam_x, mask)
+        upto = [beam_x, @width].min
+        return if upto <= @collisions.folded
+
+        sequence_line if active?
+        @collisions.fold(mask, upto, @lo, @hi)
       end
 
-      def active? = @sprites.any?(&:displaying?)
+      def clear_collision(reg, beam_x) = @collisions.clear(reg, beam_x)
 
-      # Merge each displaying sprite's line into the scratch buffers, then
-      # apply the winners over the background in a single pass over the
-      # touched span.
-      def composite(colors, mask)
-        @sprite_clash = 0
-        @data_clash = 0
-        lo = @width
-        hi = 0
+      # End of line: fold in the pixels the beam reached since the last
+      # read, then paint the winners over the background. A line with no
+      # background to paint over — one in the vertical blank — still
+      # collides, so `colors` is nil there rather than absent.
+      def finish_line(colors, mask)
+        collide_upto(@width, mask)
+        colors ? apply(colors, mask) : clear_coverage
+      end
 
+      private
+
+      # A $d017 write that clears MxYE acts on the flip-flop at once, rather
+      # than from a column hook, and crunches in Bauer cycle 15.
+      def clear_y_expansion(cleared, beam_x)
+        crunch = beam_x == CRUNCH_X
         @sprites.each do |sprite|
-          next unless sprite.displaying?
+          sprite.clear_y_expansion(crunch) if cleared.anybits?(1 << sprite.index)
+        end
+      end
+
+      # Replay the line for every sprite, filling the per-pixel coverage
+      # that both the fold and the composite read. A write logged later in
+      # the line can only move pixels past it, so re-running after the log
+      # grows leaves everything already folded where it was.
+      def sequence_line
+        return if @sequenced == @log.length
 
-          seg_lo, seg_hi = merge(sprite, mask)
-          lo = seg_lo if seg_lo < lo
-          hi = seg_hi if seg_hi > hi
+        clear_coverage
+        @log.prepare
+        @sprites.each do |sprite|
+          sprite.sequence(@log)
+          merge(sprite)
         end
+        @sequenced = @log.length
+      end
 
-        apply(colors, mask, lo, hi)
-        register_collisions
+      # Write one sprite's pixels into the coverage, picking up the color and
+      # priority registers as they stood at each pixel. The first sprite to
+      # claim a pixel wins (lowest index has priority); later ones only add
+      # their bit to it.
+      def merge(sprite)
+        bit = 1 << sprite.index
+        @carry_next[sprite.index].clear
+        @carry[sprite.index].each_slice(3) do |x, color, priority|
+          track(x, 1)
+          merge_pixel(x, color, bit, priority)
+        end
+        merge_run(sprite, sprite.leftmost, sprite.span, sprite.codes)
+        merge_run(sprite, sprite.reload_leftmost, sprite.reload_span, sprite.reload_codes)
       end
 
-      private
+      def merge_run(sprite, leftmost, span, codes)
+        return if span.zero?
+
+        track(leftmost, span)
+        log = @log.empty? ? nil : @log
+        log&.rewind
+        merge_span(sprite, log, leftmost, span, codes)
+      end
 
-      # Write one sprite's pixels into the scratch line. The first sprite to
-      # claim a pixel wins (lowest index has priority); later hits only
-      # accumulate collision bits.
-      def merge(sprite, mask)
-        left = sprite.leftmost
-        pixels = sprite.line_pixels
-        last = sprite.pixel_width
+      def merge_span(sprite, log, leftmost, span, codes)
         bit = 1 << sprite.index
-        priority = sprite.priority?
-
-        i = 0
-        while i < last
-          color = pixels[i]
-          if color
-            x = left + i
-            x -= @width if x >= @width
-            merge_pixel(x, color, bit, priority, mask)
+        palette = sprite.palette(log || @registers, @palette)
+        priority = (log || @registers)[0x1b].anybits?(bit)
+        pos = leftmost
+        boundary = log ? 0 : Float::INFINITY
+        index = 0
+        while index < span
+          if pos >= boundary
+            log.advance(pos)
+            sprite.palette(log, palette)
+            priority = log[0x1b].anybits?(bit)
+            boundary = log.next_x
           end
-          i += 1
+          code = codes[index]
+          place(pos, palette[code], bit, priority) unless code.zero?
+          index += 1
+          pos += 1
         end
+      end
 
-        right = left + last
-        right > @width ? [0, @width] : [left, right]
+      # A pixel past the end of the line belongs to the start of the next.
+      def place(pos, color, bit, priority)
+        if pos < @width
+          merge_pixel(pos, color, bit, priority)
+        else
+          @carry_next[bit.bit_length - 1].push(pos - @width, color, priority)
+        end
       end
 
-      def merge_pixel(pos, color, bit, priority, mask)
+      def track(left, span)
+        right = left + span
+        if right > @width
+          @lo = 0
+          @hi = @width
+        else
+          @lo = left if left < @lo
+          @hi = right if right > @hi
+        end
+      end
+
+      def merge_pixel(pos, color, bit, priority)
         bits = @hits[pos]
         if bits.zero?
           @win_color[pos] = color
           @win_priority[pos] = priority
-        else
-          @sprite_clash |= bits | bit
         end
         @hits[pos] = bits | bit
-        @data_clash |= bit if mask[pos]
       end
 
-      def apply(colors, mask, from, upto)
-        pos = from
-        while pos < upto
-          if @hits[pos].nonzero?
+      def apply(colors, mask)
+        pos = @lo
+        while pos < @hi
+          unless @hits[pos].zero?
             colors[pos] = @win_color[pos] unless @win_priority[pos] && mask[pos]
             @hits[pos] = 0
           end
           pos += 1
         end
+        @lo = @width
+        @hi = 0
       end
 
-      def register_collisions
-        if @sprite_clash.nonzero? && @registers.collide!(0x1e, @sprite_clash)
-          @registers.latch_irq!(SPRITE_COLLISION_IRQ)
-        end
-        return if @data_clash.zero?
-        return unless @registers.collide!(0x1f, @data_clash)
-
-        @registers.latch_irq!(DATA_COLLISION_IRQ)
+      def clear_coverage
+        @hits.fill(0, @lo, @hi - @lo) if @hi > @lo
+        @lo = @width
+        @hi = 0
       end
     end
   end