badline 0.8.0 → 0.10.0

data/lib/badline/snapshot.rb

@@ -27,8 +27,12 @@ module Badline
       path
     end
 
+    # A VIC-20's snapshot holds the BADLINE module alone, in a container
+    # named as xvic names its machine.
     def dump(computer)
       state = computer.snapshot
+      return Container.new([MachineState.section(state)], machine: Container::VIC20).to_s if computer.family == :vic20
+
       Container.new(Vice.export(state) + [MachineState.section(state)]).to_s
     end
 
@@ -49,4 +53,10 @@ module Badline
 
     def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
   end
+
+  class Vic20
+    def save_snapshot(path) = Snapshot.save(self, path)
+
+    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+  end
 end

data/lib/badline/storage/crt_file.rb

@@ -6,13 +6,14 @@ module Badline
       class FormatError < StandardError; end
 
       SIGNATURE = "C64 CARTRIDGE   ".b
+      VIC20_SIGNATURE = "VIC20 CARTRIDGE ".b
       CHIP_SIGNATURE = "CHIP".b
       CHIP_HEADER_SIZE = 0x10
       RAM_CHIP = 1
 
       Chip = Data.define(:chip_type, :bank, :address, :data)
 
-      attr_reader :hardware_type, :subtype, :exrom, :game, :name, :chips
+      attr_reader :machine, :hardware_type, :subtype, :exrom, :game, :name, :chips
 
       # What .write needs of an image: the fields a parsed CRTFile reads.
       Image = Data.define(:hardware_type, :subtype, :exrom, :game, :name, :chips)
@@ -33,16 +34,19 @@ module Badline
         header + packets.join
       end
 
-      # `bytes` stands in for the file's contents.
-      def initialize(path = nil, bytes: nil)
+      # `bytes` stands in for the file's contents. `machine` is the one the
+      # image has to be for, :c64 or :vic20, or nil for either.
+      def initialize(path = nil, bytes: nil, machine: :c64)
         parse(bytes || File.binread(path))
+        return if machine.nil? || @machine == machine
+
+        raise FormatError, "Cartridge image is for the #{@machine}, not the #{machine}"
       end
 
       private
 
       def parse(bytes)
-        raise FormatError, "Missing CRT signature" unless bytes.start_with?(SIGNATURE)
-
+        @machine = signed_machine(bytes)
         @hardware_type = bytes[0x16, 2].unpack1("n")
         @exrom = bytes.getbyte(0x18)
         @game = bytes.getbyte(0x19)
@@ -51,6 +55,13 @@ module Badline
         @chips = parse_chips(bytes, bytes[0x10, 4].unpack1("N"))
       end
 
+      def signed_machine(bytes)
+        return :c64 if bytes.start_with?(SIGNATURE)
+        return :vic20 if bytes.start_with?(VIC20_SIGNATURE)
+
+        raise FormatError, "Missing CRT signature"
+      end
+
       # Trailing bytes too short to hold a CHIP header are ignored.
       def parse_chips(bytes, offset)
         chips = []

data/lib/badline/storage/disk_image.rb

@@ -36,6 +36,9 @@ module Badline
         @errors = split_error_table
       end
 
+      # The host file's path, as it was opened.
+      attr_reader :path
+
       # Whether the image was opened write-protected.
       def read_only? = @read_only
 

data/lib/badline/storage/host_directory.rb

@@ -10,6 +10,9 @@ module Badline
       NO_SYNC = 21
       ID = "DIR".bytes.freeze
 
+      # The directory's path, as it was opened.
+      attr_reader :path
+
       def initialize(path)
         @path = path
       end

data/lib/badline/storage/t64.rb

@@ -12,15 +12,21 @@ module Badline
       TAPE_NAME = 0x28
       ID = "T64".bytes.freeze
 
-      def initialize(path)
+      # `bytes` stands in for the host file's contents, as a snapshot
+      # restores the archive it holds.
+      def initialize(path, bytes: nil)
         @path = path
-        @bytes = File.binread(path).bytes
+        @bytes = bytes || File.binread(path).bytes
         raise FormatError, "Missing T64 signature" unless @bytes[0, 3] == SIGNATURE
       end
 
-      # What Storage.reopen needs to open the archive again.
+      # The host file's path, as it was opened.
+      attr_reader :path
+
+      # What Storage.reopen needs to open the archive again: its path and
+      # its bytes.
       def save_setup(out)
-        out.int(T64_ARCHIVE).string(::File.expand_path(@path))
+        out.int(T64_ARCHIVE).string(::File.expand_path(@path)).blob(@bytes)
       end
 
       def read_file(name, **)

data/lib/badline/storage/tap.rb

@@ -3,9 +3,9 @@
 module Badline
   module Storage
     # Raw datasette pulse stream. The header holds the signature, the
-    # version at $0c and the data size at $10; the data runs from $14, every
-    # byte the time to the next falling edge on the tape read line, in units
-    # of 8 cycles.
+    # version at $0c, the platform at $0d (0 C64, 1 VIC-20, 2 C16) and the
+    # data size at $10; the data runs from $14, every byte the time to the
+    # next falling edge on the tape read line, in units of 8 cycles.
     class TAP
       class FormatError < StandardError; end
 
@@ -13,18 +13,28 @@ module Badline
       HEADER_SIZE = 0x14
       OVERFLOW = 0x100 * 8
 
-      # The file it was read from, expanded, and the offset of the next
-      # pulse byte.
-      attr_reader :version, :path
+      # The file it was read from, expanded, and the file's bytes.
+      attr_reader :version, :platform, :path, :bytes
 
-      def initialize(path)
+      # A blank version 1 tape for `platform` (0 C64, 1 VIC-20) at `path`,
+      # written to the host file.
+      def self.create(path, platform:)
+        File.binwrite(path, (SIGNATURE + [1, platform, 0, 0, 0, 0, 0, 0]).pack("C*"))
+        new(path)
+      end
+
+      # `bytes` stands in for the host file's contents, as a snapshot
+      # restores the tape it holds.
+      def initialize(path, bytes: nil)
         @path = File.expand_path(path)
-        @bytes = File.binread(path).bytes
+        @bytes = bytes || File.binread(path).bytes
         raise FormatError, "Missing TAP signature" unless @bytes[0, SIGNATURE.length] == SIGNATURE
 
         @version = @bytes[0x0c].to_i
         raise FormatError, "Unsupported TAP version #{@version}" if @version > 1
 
+        @platform = @bytes[0x0d].to_i
+
         @end = tape_end
         rewind
       end
@@ -33,6 +43,7 @@ module Badline
         @pos = HEADER_SIZE
       end
 
+      # The offset of the next pulse byte.
       def position = @pos
 
       def position=(offset)
@@ -41,6 +52,31 @@ module Badline
 
       def end? = @pos >= @end
 
+      # Records a pulse `cycles` long at the position, in place of the rest
+      # of the tape: a byte of units of 8 cycles, or a zero and the 24-bit
+      # cycle count for a long one (a lone zero, an overflow, on a version 0
+      # tape).
+      def record_pulse(cycles)
+        units = (cycles + 4) / 8
+        encoded = if units.between?(1, 0xff) then [units]
+                  elsif version.zero? then [0]
+                  else
+                    count = [cycles, 0xffffff].min
+                    [0, count & 0xff, (count >> 8) & 0xff, count >> 16]
+                  end
+        @bytes.slice!(@pos..)
+        @bytes.concat(encoded)
+        @pos = @end = @bytes.length
+      end
+
+      # Writes the tape back to its host file, with the data size the
+      # header states.
+      def save
+        size = @bytes.length - HEADER_SIZE
+        @bytes[0x10, 4] = [size & 0xff, (size >> 8) & 0xff, (size >> 16) & 0xff, size >> 24]
+        File.binwrite(@path, @bytes.pack("C*"))
+      end
+
       # Cycles until the next falling edge, or nil once the tape has run out.
       def next_pulse
         return if end?

data/lib/badline/storage/unavailable.rb

@@ -2,10 +2,12 @@
 
 module Badline
   module Storage
-    # Stands in for a directory or archive a detached restore leaves out
+    # Stands in for a directory a detached restore leaves out
     # (Snapshot::StateReader): it finds no files and refuses every write
     # as a write-protected disk does.
     class Unavailable
+      def path = ""
+
       def read_file(_name, **) = nil
 
       def write_file(_name, _bytes, **)

data/lib/badline/storage.rb

@@ -45,16 +45,16 @@ module Badline
     T64_ARCHIVE = 4
 
     class << self
-      # Opens the storage a save_setup wrote: the same directory or archive
-      # by its path, or a disk image with the bytes it held, writes and
-      # all. A detached reader gets the image write-protected, and
-      # Unavailable for a directory or archive.
+      # Opens the storage a save_setup wrote: the same directory by its
+      # path, an archive with the bytes it held, or a disk image with the
+      # bytes it held, writes and all. A detached reader gets the image
+      # write-protected, and Unavailable for a directory.
       def reopen(input)
         kind = input.int
         path = input.string
         case kind
         when HOST_DIRECTORY then input.detached? ? Unavailable.new : HostDirectory.new(path)
-        when T64_ARCHIVE then input.detached? ? Unavailable.new : T64.new(path)
+        when T64_ARCHIVE then T64.new(path, bytes: input.blob)
         else reopen_image(kind, path, input)
         end
       end

data/lib/badline/timing.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Badline
+  # = Timing
+  #
+  # What a front end needs to run a machine's frames and show them: the CPU
+  # clock, the raster's cycles per line and lines per frame, and the
+  # [left, top, width, height] of the raster it shows, and how many of the
+  # window's square pixels wide each of its pixels shows. Each machine
+  # derives it from its region.
+  Timing = Data.define(:clock_hz, :cycles_per_line, :lines_per_frame, :crop, :pixel_width)
+end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

data/lib/badline/via/shift_register.rb

@@ -13,14 +13,20 @@ module Badline
     # modes 3 and 7 off whatever drives CB1 from outside.
     #
     # Under its own clock the register drives CB1, idling high. Reading or
-    # writing the data register starts a byte: CB1 falls on the first clock
-    # tick after the access and rises on the second, and so on, so a byte is
-    # eight pulses over sixteen ticks. The interrupt flag is set on the tick
-    # that raises CB1 over the eighth bit, and CB1 then stays high until the
-    # next access. A tick is a φ2 cycle in modes 2 and 6, which makes a byte
-    # sixteen cycles, and a timer 2 low byte underflow in modes 1, 4 and 5,
-    # which makes it sixteen underflows. Mode 4 never stops and never
-    # interrupts: its counter is disabled, and the byte goes round and round.
+    # writing the data register starts a byte, but only while the register
+    # is idle and enabled: an access in mode 0, or one before the eighth bit
+    # is in, leaves the count alone. CB1 falls on the first clock tick of
+    # the byte and rises on the second, and so on, so a byte is eight pulses
+    # over sixteen ticks. The interrupt flag is set on the tick that raises
+    # CB1 over the eighth bit, and CB1 then stays high until the next
+    # access.
+    #
+    # In modes 2 and 6 a tick is a φ2 cycle, from the second cycle after
+    # the access on, which makes a byte sixteen cycles. In modes 1, 4 and 5
+    # it comes two cycles after each timer 2 low byte underflow, on the
+    # cycle after the low byte reloads, which makes a byte sixteen
+    # underflows. Mode 4 never stops and never interrupts: its counter is
+    # disabled, and the byte goes round and round.
     #
     # Under an external clock the register shifts on every CB1 edge, access
     # or not. The access only arms the counter: the flag is set on the eighth
@@ -43,6 +49,10 @@ module Badline
         @data = 0x00
         # Bits still to count before the flag, zero when the counter is idle.
         @bits = 0
+        # The clock's last two cycles, newest in bit 0: timer 2 low byte
+        # underflows in modes 1, 4 and 5, and whether the byte has started
+        # in modes 2 and 6.
+        @delay = 0
         @clock = true
         @cb2 = true
         # Nothing drives CB2 from outside, so it floats high.
@@ -57,10 +67,13 @@ module Badline
         @data = value & 0xff
       end
 
-      # Every read or write of the data register (re)starts the count of
-      # eight bits.
+      # A read or write of the data register, which starts a byte if the
+      # register is idle and enabled.
       def access!
+        return if @mode == DISABLED || @bits.nonzero?
+
         @bits = 8
+        @delay = 0 if @mode == IN_PHI2 || @mode == OUT_PHI2
       end
 
       # Whether the register is counting bits off its own clock, which
@@ -68,20 +81,21 @@ module Badline
       def clocking? = @bits.nonzero? && internal_clock?
 
       def save_state(out)
-        out.int(@mode).int(@data).int(@bits).boolean(@clock).boolean(@cb2).boolean(@cb2_input)
+        out.int(@mode).int(@data).int(@bits).int(@delay).boolean(@clock).boolean(@cb2).boolean(@cb2_input)
       end
 
       def load_state(input)
         @mode = input.int
         @data = input.int
         @bits = input.int
+        @delay = input.schema > 4 ? input.int : 0
         @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]
+      def state = [@mode, @data, @bits, @delay, @clock, @cb2, @cb2_input]
 
       # The CB1 level the register drives, or nil when CB1 is an input.
       def cb1_output
@@ -96,11 +110,9 @@ module Badline
       # Clocked once per φ2 cycle, with whether timer 2's low byte underflowed
       # on it. Returns true on the cycle that sets the interrupt flag.
       def cycle!(t2_low_underflow)
-        return false if @bits.zero?
-
         case @mode
-        when IN_PHI2, OUT_PHI2 then tick
-        when IN_T2, OUT_T2, OUT_FREE_RUNNING then t2_low_underflow && tick
+        when IN_PHI2, OUT_PHI2 then @bits.nonzero? && phi2_tick
+        when IN_T2, OUT_T2, OUT_FREE_RUNNING then t2_tick(t2_low_underflow)
         else false
         end
       end
@@ -123,6 +135,21 @@ module Badline
         @mode != DISABLED && @mode != IN_EXTERNAL && @mode != OUT_EXTERNAL
       end
 
+      # A φ2 cycle of a byte: every one but the first ticks.
+      def phi2_tick
+        started = @delay.nonzero?
+        @delay = 1
+        started && tick
+      end
+
+      # Ticks on the underflow from two cycles back, while a byte is under
+      # way.
+      def t2_tick(underflow)
+        due = @delay.anybits?(2)
+        @delay = ((@delay << 1) & 2) | (underflow ? 1 : 0)
+        due && @bits.nonzero? && tick
+      end
+
       # One half period of the register's own clock: a falling edge puts a
       # bit out, and a rising one takes a bit in and counts it.
       def tick

data/lib/badline/vic/bank.rb

@@ -5,44 +5,81 @@ module Badline
     # The 16K window the VIC sees into RAM, selected by CIA2 $DD00, in the
     # bank a +256K picks for it. Character
     # ROM shadows $1000-$1FFF in banks 0 and 2.
+    #
+    # The machine's bus pushes in what the VIC sees through #connect,
+    # #map_character_rom and #map whenever it changes. Until then the bank
+    # has a CIA 2, RAM, colour RAM and character ROM of its own.
     class Bank
       include Addressable
 
       # The CIA2 port A bank bits are inverted: %11 selects bank 0.
       BANK_STARTS = [0xc000, 0x8000, 0x4000, 0x0000].freeze
 
-      attr_reader :address_bus
+      attr_reader :ram, :color_ram
 
       # The bank lines as #sample_lines last saw them.
       attr_accessor :lines
 
-      def initialize(address_bus = nil)
+      def initialize(vic)
         addressable_at(0x0000, length: 2**14)
-        @address_bus = address_bus || AddressBus.new
+        connect(cia2: CIA.new(start: 0xdd00), color_ram: ColorMemory.new(vic))
+        map_character_rom(ROM.load("character.rom", 0xd000))
+        @base = 0
+        @starts = BANK_STARTS
+        map(Memory.new([], length: 2**16, start: 0))
         @lines = 0b11
         @swapped = false
       end
 
+      # CIA 2, whose port A picks the bank, and the colour RAM, read from
+      # the address +color_base+ gives offset 0.
+      def connect(cia2:, color_ram:, color_base: 0xd800)
+        @cia2 = cia2
+        @color_ram = color_ram
+        @color_base = color_base
+      end
+
+      # The character ROM, read from the address +base+ gives offset 0. It
+      # shows in the banks whose low line is high, unless +shadow+ is false.
+      def map_character_rom(rom, base: 0xc000, shadow: true)
+        @character_rom = rom
+        @character_base = base
+        @shadow_mask = shadow ? 0b01 : 0b00
+      end
+
+      # The RAM the VIC's 64K starts at +base+ in, and the cartridge's
+      # Ultimax lines in each half of the cycle with the ROMH bank they
+      # show.
+      def map(ram, base: 0, phi1_ultimax: false, ultimax: false, romh: nil)
+        @ram = ram
+        unless base == @base
+          @base = base
+          @starts = BANK_STARTS.map { |start| base + start }.freeze
+        end
+        @phi1_ultimax = phi1_ultimax
+        @ultimax = ultimax
+        @romh = romh
+      end
+
       # On the 8565, a port A write that swaps the two bank lines, driving
       # one high as the other goes low, shows the VIC both lines low for the
       # cycle after it: every access in that cycle reads bank 3. A swap that
       # the DDR makes, releasing a line to float high, shows nothing.
       # Called once a cycle, ahead of the cycle's accesses.
       def sample_lines
-        cia2 = @address_bus.cia2
-        lines = cia2.port_a_lines & 0b11
-        @swapped = swap?(@lines, lines) && cia2.port_registers[2].allbits?(0b11)
+        lines = @cia2.port_a_lines & 0b11
+        @swapped = swap?(@lines, lines) && @cia2.port_registers[2].allbits?(0b11)
         @lines = lines
       end
 
       def peek(offset)
-        return ultimax_peek(offset) if @address_bus.phi1_ultimax
+        return ultimax_peek(offset) if @phi1_ultimax
 
         bits = bank_switch_register
-        if bits.allbits?(0b01) && (offset & 0xf000) == 0x1000
-          @address_bus.character_rom.peek(0xc000 + offset)
+        if (bits & @shadow_mask) == 0b01 && (offset & 0xf000) == 0x1000
+          @character_rom.peek(@character_base + offset)
         else
-          @address_bus.video_ram.peek(BANK_STARTS[bits] + offset)
+          @ram.peek(@starts[bits] + offset)
         end
       end
 
@@ -50,11 +87,11 @@ module Badline
       # memory configuration the CPU does in that half. No cartridge drives
       # Ultimax mode in the first half alone, so otherwise it reads as #peek.
       def peek_phi2(offset)
-        @address_bus.ultimax ? ultimax_peek(offset) : peek(offset)
+        @ultimax ? ultimax_peek(offset) : peek(offset)
       end
 
       def peek_color(offset)
-        address_bus.color_ram.nibble(0xd800 + offset)
+        @color_ram.nibble(@color_base + offset)
       end
 
       def poke(_addr, _value)
@@ -63,7 +100,7 @@ module Badline
 
       # True if the VIC reads the character ROM at this offset.
       def character_rom?(offset)
-        !@address_bus.phi1_ultimax && bank_switch_register.allbits?(0b01) && (offset & 0xf000) == 0x1000
+        !@phi1_ultimax && (bank_switch_register & @shadow_mask) == 0b01 && (offset & 0xf000) == 0x1000
       end
 
       def start
@@ -75,11 +112,11 @@ module Badline
       # In Ultimax mode the cartridge ROMH replaces the character ROM
       # shadow, visible at $3000-$3FFF of the window.
       def ultimax_peek(offset)
-        romh = @address_bus.cartridge.romh
+        romh = @romh
         if romh && offset.allbits?(0x3000)
           romh.peek(0xe000 + (offset & 0x1fff))
         else
-          @address_bus.video_ram.peek(BANK_STARTS[bank_switch_register] + offset)
+          @ram.peek(@starts[bank_switch_register] + offset)
         end
       end
 
@@ -88,7 +125,7 @@ module Badline
       def bank_switch_register
         return 0 if @swapped
 
-        @address_bus.cia2.port_a_lines & 0b11
+        @cia2.port_a_lines & 0b11
       end
     end
   end

data/lib/badline/vic/registers.rb

@@ -69,7 +69,13 @@ module Badline
     #   $D02D: Sprite 6 color
     #   $D02E: Sprite 7 color
     #
-    # $D02F-$D03F: Not in use, always reads 0xff
+    # == VIC-IIe (8566 and 8564)
+    #
+    #   $D02F: Extra keyboard lines K0-K2 in bits 0-2, bits 3-7 read 1
+    #   $D030: FAST (2 MHz) in bit 0 and TEST in bit 1, bits 2-7 read 1
+    #
+    # $D02F-$D03F: Not in use on the 6569 and 8565, always reads 0xff,
+    # and $D031-$D03F on the VIC-IIe
     # $D040-$D3FF: Repeat $D0000 to $D03F every 64 bytes
     class Registers
       include IntegerHelper
@@ -77,10 +83,12 @@ module Badline
       # The raw register bytes, for the per-column reads on the hot path.
       attr_reader :bytes
 
-      # Every register powers on as zero, as in VICE.
-      def initialize
+      # Every register powers on as zero, as in VICE. A VIC-IIe reads
+      # $D02F and $D030 back as registers.
+      def initialize(iie: false)
         @bytes = Array.new(2**6, 0)
         @irq_line = false
+        @iie = iie
       end
 
       # True while any enabled latch bit is set in $D019/$D01A. Cached and
@@ -95,7 +103,9 @@ module Badline
         when 0x18 then @bytes[reg] | 0x01 # bit 0 unused, reads 1
         when 0x1a, 0x20..0x2e then @bytes[reg] | 0xf0
         when 0x1e, 0x1f then read_clear(reg) # collision registers clear on read
-        when 0x2f..0x3f then 0xff
+        when 0x2f then @iie ? @bytes[reg] | 0xf8 : 0xff
+        when 0x30 then @iie ? @bytes[reg] | 0xfc : 0xff
+        when 0x31..0x3f then 0xff
         else @bytes[reg]
         end
       end
@@ -134,6 +144,12 @@ module Badline
       def border = @bytes[0x20] & 0x0f
       def background(index = 0) = @bytes[0x21 + index] & 0x0f
 
+      # The VIC-IIe's $D02F and $D030 bits. The 6569 and 8565 drive no
+      # extra keyboard lines and run at 1 MHz.
+      def extra_keyboard_lines = @iie ? @bytes[0x2f] & 0x07 : 0x07
+      def fast? = @iie && @bytes[0x30].anybits?(0x01)
+      def test? = @iie && @bytes[0x30].anybits?(0x02)
+
       def raster_target = uint16(@bytes[0x12], (@bytes[0x11] & 0x80) >> 7)
 
       def latch_irq!(bit)

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

@@ -11,10 +11,9 @@ module Badline
       # fetches or the compare run a cycle later than on the 6569, what
       # hangs off them moves 8 pixels with them.
       class Timing
-        # The X counter's value where it holds on a raster of more than 512
-        # pixels, and the four values it repeats from there.
+        # The X counter's value where it steps back on a raster of more than
+        # 512 pixels, to run over the eight values below it again.
         HOLD_AT = 0x188
-        HOLD_BASE = 0x184
 
         attr_reader :columns, :sprite_cycle, :display_off_x, :x_pixels
 
@@ -36,14 +35,11 @@ module Badline
         def reload_x(index) = RELOAD_X + (8 * @shift) + (RELOAD_STEP * index)
 
         # The X counter at a raster pixel: X_OFFSET behind it, wrapping at
-        # the end of the line, less the pixels it held for past HOLD_AT,
-        # where it ran over $184-$187 again instead.
+        # the end of the line, less the pixels it held for from HOLD_AT on,
+        # where it ran over $180-$187 a second time.
         def self.xpos(pixel, width, hold)
           count = (pixel - X_OFFSET) % width
-          return count if count < HOLD_AT
-          return count - hold if count >= HOLD_AT + hold
-
-          HOLD_BASE + ((count - HOLD_AT) % 4)
+          count < HOLD_AT ? count : count - hold
         end
 
         # The raster pixels at which the X counter reads each coordinate, 512

data/lib/badline/vic/sprite.rb

@@ -37,8 +37,9 @@ module Badline
       # The s-accesses reload the shift register partway through the line,
       # at raster pixel 459 for sprite 0 and 16 later for each sprite after
       # it. A sprite still shifting there loses the rest of its row, and the
-      # comparator is ignored for the twelve pixels from it (the spritescan
-      # dump). Its output holds the last pixel for seven, through K+6
+      # comparator is ignored for the twelve pixels from it, running on into
+      # the next line from a reload near the end of this one (the spritescan
+      # dumps). Its output holds the last pixel for seven, through K+6
       # (spritefetchbug).
       RELOAD_X = 459
       RELOAD_STEP = 16
@@ -275,7 +276,7 @@ module Badline
       end
 
       def sequence_hit(log, start, reload_bits)
-        return if (@stop_x && start >= @stop_x) || start < @show_from
+        return if (@stop_x && start >= @stop_x) || start < @show_from || start < @reload_x + RELOAD_DEAD - @width
 
         if start < @reload_x
           sequence_early(log, start)