badline 0.1.0

data/lib/badline/vic/bank.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    # The 16K window the VIC sees into RAM, selected by CIA2 $DD00. Character
+    # ROM shadows $1000-$1FFF in banks 0 and 2.
+    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
+
+      def initialize(address_bus = nil)
+        addressable_at(0x0000, length: 2**14)
+        @address_bus = address_bus || AddressBus.new
+      end
+
+      def peek(offset)
+        return ultimax_peek(offset) if @address_bus.ultimax
+
+        bits = bank_switch_register
+        if bits.allbits?(0b01) && (offset & 0xf000) == 0x1000
+          @address_bus.character_rom.peek(0xc000 + offset)
+        else
+          @address_bus.ram.peek(BANK_STARTS[bits] + offset)
+        end
+      end
+
+      def peek_color(offset)
+        address_bus.color_ram.peek(0xd800 + offset) & 0x0f
+      end
+
+      def poke(_addr, _value)
+        raise ReadOnlyMemoryError
+      end
+
+      def start
+        BANK_STARTS[bank_switch_register]
+      end
+
+      private
+
+      # 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
+        if romh && offset.allbits?(0x3000)
+          romh.peek(0xe000 + (offset & 0x1fff))
+        else
+          @address_bus.ram.peek(BANK_STARTS[bank_switch_register] + offset)
+        end
+      end
+
+      def bank_switch_register
+        @address_bus.cia2.port_a_lines & 0b11
+      end
+
+      def character_rom?
+        bank_switch_register.allbits?(0b01)
+      end
+    end
+  end
+end

data/lib/badline/vic/display_state.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class DisplayState
+      FIRST_LINE = 0x30 # 48: bad lines and the DEN-at-$30 latch begin here
+      LAST_LINE  = 0xf7 # 247
+      COLUMNS_PER_ROW = 40
+
+      attr_reader :vc_base, :rc
+
+      def initialize(registers)
+        @registers = registers
+        @vc_base = 0
+        @rc = 0
+        @display = false
+        @bad_lines_enabled = false
+        @bad_line = false
+      end
+
+      def display? = @display
+      def idle? = !@display
+      def bad_line? = @bad_line
+
+      def new_frame
+        @vc_base = 0
+        @bad_lines_enabled = false
+      end
+
+      def new_line
+        @bad_line = false
+      end
+
+      def cycle(rasterline, column)
+        @bad_lines_enabled = true if rasterline == FIRST_LINE && @registers.display_enabled?
+
+        load_vc(rasterline) if column == 14
+        trigger_bad_line(rasterline) if column.between?(12, 54)
+        check_row_counter if column == 58
+      end
+
+      private
+
+      def load_vc(rasterline)
+        return unless bad_line_condition?(rasterline)
+
+        @bad_line = true
+        @display = true
+        @rc = 0
+      end
+
+      def trigger_bad_line(rasterline)
+        return if @bad_line
+        return unless bad_line_condition?(rasterline)
+
+        @bad_line = true
+        @display = true
+      end
+
+      def bad_line_condition?(rasterline)
+        @bad_lines_enabled &&
+          rasterline.between?(FIRST_LINE, LAST_LINE) &&
+          (rasterline & 0b111) == @registers.yscroll
+      end
+
+      def check_row_counter
+        return unless @display
+
+        if @rc == 7
+          @display = false
+          @vc_base = (@vc_base + COLUMNS_PER_ROW) & 0x3ff
+        else
+          @rc = (@rc + 1) & 0b111
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic/graphics_mode.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    module GraphicsMode
+      # Foreground masks depend only on the data byte, so each byte maps to a
+      # precomputed frozen pattern shared by reference instead of being
+      # written out pixel by pixel.
+      HIRES_FG = Array.new(256) do |data|
+        Array.new(8) { |i| data.anybits?(1 << (7 - i)) }.freeze
+      end.freeze
+
+      # The high bit of each 2-bit pair (10/11) is foreground.
+      PAIR_FG = Array.new(256) do |data|
+        Array.new(8) { |i| (data >> (6 - (i & ~1))).allbits?(0b10) }.freeze
+      end.freeze
+
+      NO_FG = HIRES_FG[0]
+
+      module Hires
+        def paint_hires(data, color, background, seq)
+          seq.cur_fg = HIRES_FG[data]
+          colors = seq.cur_colors
+          return colors.fill(background) if data.zero?
+
+          i = 0
+          while i < 8
+            colors[i] = data.anybits?(1 << (7 - i)) ? color : background
+            i += 1
+          end
+        end
+      end
+
+      # Decodes 2-bit pixel pairs into double-wide pixels. The colour for each
+      # pair is supplied by the block.
+      module Multicolor
+        def paint_pairs(data, seq)
+          seq.cur_fg = PAIR_FG[data]
+          colors = seq.cur_colors
+          i = 0
+          while i < 8
+            colors[i] = yield((data >> (6 - (i & ~1))) & 0b11)
+            i += 1
+          end
+        end
+      end
+
+      class Text
+        include Hires
+
+        def decode(screencode, color, _cell, row, seq)
+          registers = seq.registers
+          data = seq.bank.peek(registers.char_base + (screencode * 8) + row)
+          paint_hires(data, color, registers.background, seq)
+        end
+      end
+
+      class MulticolorText
+        include Hires
+        include Multicolor
+
+        def decode(screencode, color, _cell, row, seq)
+          registers = seq.registers
+          data = seq.bank.peek(registers.char_base + (screencode * 8) + row)
+          if color.anybits?(0x08)
+            paint_pairs(data, seq) do |pair|
+              multicolor_pixel(pair, color, registers)
+            end
+          else
+            paint_hires(data, color & 0x07, registers.background, seq)
+          end
+        end
+
+        private
+
+        def multicolor_pixel(pair, color, registers)
+          case pair
+          when 0b00 then registers.background(0)
+          when 0b01 then registers.background(1)
+          when 0b10 then registers.background(2)
+          else color & 0x07
+          end
+        end
+      end
+
+      class ExtendedBackgroundText
+        include Hires
+
+        def decode(screencode, color, _cell, row, seq)
+          registers = seq.registers
+          background = registers.background((screencode >> 6) & 0b11)
+          data = seq.bank.peek(registers.char_base + ((screencode & 0x3f) * 8) + row)
+          paint_hires(data, color, background, seq)
+        end
+      end
+
+      class Bitmap
+        include Hires
+
+        def decode(screencode, _color, cell, row, seq)
+          data = seq.bank.peek(seq.registers.bitmap_base + (cell * 8) + row)
+          foreground = (screencode >> 4) & 0x0f
+          background = screencode & 0x0f
+          paint_hires(data, foreground, background, seq)
+        end
+      end
+
+      class MulticolorBitmap
+        include Multicolor
+
+        def decode(screencode, color, cell, row, seq)
+          registers = seq.registers
+          data = seq.bank.peek(registers.bitmap_base + (cell * 8) + row)
+          paint_pairs(data, seq) do |pair|
+            multicolor_pixel(pair, screencode, color, registers)
+          end
+        end
+
+        private
+
+        def multicolor_pixel(pair, screencode, color, registers)
+          case pair
+          when 0b00 then registers.background(0)
+          when 0b01 then (screencode >> 4) & 0x0f
+          when 0b10 then screencode & 0x0f
+          else color & 0x0f
+          end
+        end
+      end
+
+      class Null
+        def decode(_screencode, _color, _cell, _row, seq)
+          seq.cur_fg = NO_FG
+          seq.cur_colors.fill(0)
+        end
+      end
+    end
+  end
+end

data/lib/badline/vic/registers.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    # = VIC-II Registers
+    #
+    # == Sprite positions
+    #
+    #   $D000: Sprite 0 X
+    #   $D001: Sprite 0 Y
+    #   $D002: Sprite 1 X
+    #   $D003: Sprite 1 Y
+    #   $D004: Sprite 2 X
+    #   $D005: Sprite 2 Y
+    #   $D006: Sprite 3 X
+    #   $D007: Sprite 3 Y
+    #   $D008: Sprite 4 X
+    #   $D009: Sprite 4 Y
+    #   $D00A: Sprite 5 X
+    #   $D00B: Sprite 5 Y
+    #   $D00C: Sprite 6 X
+    #   $D00D: Sprite 6 Y
+    #   $D00E: Sprite 7 X
+    #   $D00F: Sprite 7 Y
+    #
+    #   $D010: Most Significant Bits of Sprites 0-7 Horizontal Position
+    #   $D011: Vertical Fine Scrolling and Control Register
+    #   $D012: Rasterline
+    #          - Read: Current rasterline
+    #          - Write: Set rasterline interrupt
+    #
+    # == Light pen
+    #
+    #   $D013: Light Pen Horizontal Position
+    #   $D014: Light Pen Vertical Position
+    #
+    #   $D015: Sprite Enable Register
+    #   $D016: Horizontal Fine Scrolling and Control Register
+    #   $D017: Sprite Vertical Expansion Register
+    #   $D018: VIC-II Chip Memory Control Register
+    #   $D019: VIC Interrupt Flag Register
+    #   $D01A: IRQ Mask Register
+    #   $D01B: Sprite to Foreground Display Priority Register
+    #   $D01C: Sprite Multicolor Registers
+    #   $D01D: Sprite Horizontal Expansion Register
+    #
+    # == Sprite collision detection
+    #
+    #   $D01E: Sprite to Sprite Collision Register
+    #   $D01F: Sprite to Foreground Collision Register
+    #
+    # == Color registers
+    #
+    # All color registers are 4bit, bits 4-7 always read 1.
+    #
+    #   $D020: Border color        - Default: 14, light blue
+    #   $D021: Background color 0  - Default: 6,  blue
+    #   $D022: Background color 1  - Default: 1,  white
+    #   $D023: Background color 2  - Default: 2,  red
+    #   $D024: Background color 3  - Default: 3,  cyan
+    #   $D025: Sprite multicolor 0 - Default: 4,  purple
+    #   $D026: Sprite multicolor 1 - Default: 0,  black
+    #   $D027: Sprite 0 color      - Default: 1,  white
+    #   $D028: Sprite 1 color      - Default: 2,  red
+    #   $D029: Sprite 2 color      - Default: 3,  cyan
+    #   $D02A: Sprite 3 color      - Default: 4,  purple
+    #   $D02B: Sprite 4 color      - Default: 5,  green
+    #   $D02C: Sprite 5 color      - Default: 6,  blue
+    #   $D02D: Sprite 6 color      - Default: 7,  yellow
+    #   $D02E: Sprite 7 color      - Default: 12, medium gray
+    #
+    # $D02F-$D03F: Not in use, always reads 0xff
+    # $D040-$D3FF: Repeat $D0000 to $D03F every 64 bytes
+    class Registers
+      include IntegerHelper
+
+      def initialize
+        @bytes = Array.new(2**6, 0)
+        @irq_line = false
+        write_defaults
+      end
+
+      # True while any enabled latch bit is set in $D019/$D01A. Cached and
+      # re-evaluated on writes, since it's checked every cycle.
+      def irq_line? = @irq_line
+
+      def [](reg) = @bytes[reg]
+
+      def read(reg)
+        case reg
+        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
+        else @bytes[reg]
+        end
+      end
+
+      def write(reg, value)
+        case reg
+        when 0x19 # write 1 to clear
+          @bytes[reg] &= ~value
+          update_irq_line
+        when 0x1a # only the four latch bits
+          @bytes[reg] = value & 0x0f
+          update_irq_line
+        else @bytes[reg] = value
+        end
+      end
+
+      # Graphics modes
+      def ecm = @bytes[0x11][6]
+      def bmm = @bytes[0x11][5]
+      def mcm = @bytes[0x16][4]
+      # ECM/BMM from $D011 bits 6-5, MCM from $D016 bit 4.
+      def mode = ((@bytes[0x11] >> 4) & 0b110) | ((@bytes[0x16] >> 4) & 0b001)
+
+      def xscroll = @bytes[0x16] & 0b0111
+      def yscroll = @bytes[0x11] & 0b0111
+
+      def rsel? = @bytes[0x11].anybits?(0x08)
+      def csel? = @bytes[0x16].anybits?(0x08)
+      def display_enabled? = @bytes[0x11].anybits?(0x10)
+
+      def char_base = (@bytes[0x18] & 0b1110) * 0x400
+      def bitmap_base = (@bytes[0x18] & 0b1000) * 0x400
+      def screen_base = (@bytes[0x18] >> 4) * 0x400
+
+      def border = @bytes[0x20] & 0x0f
+      def background(index = 0) = @bytes[0x21 + index] & 0x0f
+
+      def raster_target = uint16(@bytes[0x12], (@bytes[0x11] & 0x80) >> 7)
+
+      def latch_irq!(bit)
+        @bytes[0x19] |= bit
+        update_irq_line
+      end
+
+      def latch_raster_irq! = latch_irq!(0x01)
+
+      def collide!(reg, bits)
+        return false if bits.zero?
+
+        was_zero = @bytes[reg].zero?
+        @bytes[reg] |= bits
+        was_zero
+      end
+
+      private
+
+      def update_irq_line
+        @irq_line = (@bytes[0x19] & @bytes[0x1a]).anybits?(0x0f)
+      end
+
+      def read_clear(reg)
+        @bytes[reg].tap { @bytes[reg] = 0 }
+      end
+
+      def write_defaults
+        write_each(0x20, [14, 6, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 6, 7, 12])
+        write_each(0x11, [0x1b, 0]) # $D011: DEN=1, RSEL=1, YSCROLL=3
+        write_each(0x16, [0xc8])    # $D016: Text mode, XSCROLL=0
+        write_each(0x19, [0, 0])    # IRQ flags
+      end
+
+      def write_each(addr, values)
+        values.each_with_index { |v, i| @bytes[addr + i] = v }
+      end
+    end
+  end
+end

data/lib/badline/vic/sequencer.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "badline/vic/graphics_mode"
+
+module Badline
+  class VIC < Cycleable
+    # = VIC-II Sequencer
+    #
+    # Turns fetched graphics data into output pixels.
+    class Sequencer
+      DISPLAY_X_BOUNDS = [
+        [135, 438].freeze,
+        [128, 447].freeze
+      ].freeze
+
+      # The graphics window always spans the full 40 columns, ignoring CSEL.
+      GFX_X_START = DISPLAY_X_BOUNDS[1][0]
+      GFX_X_END = DISPLAY_X_BOUNDS[1][1] + 1
+
+      # [left compare, right compare] for the border flip-flop per CSEL state.
+      WINDOW_COMPARES = [
+        [DISPLAY_X_BOUNDS[0][0], DISPLAY_X_BOUNDS[0][1] + 1].freeze,
+        [GFX_X_START, GFX_X_END].freeze
+      ].freeze
+
+      BORDER_Y_BOUNDS = [
+        [55, 247].freeze,
+        [51, 251].freeze
+      ].freeze
+
+      # Border coverage per 8-pixel group, tracked so apply_border can skip
+      # window groups and bulk-fill full border groups.
+      BORDER_FULL  = 0
+      BORDER_NONE  = 1
+      BORDER_MIXED = 2
+
+      NULL_MODE = GraphicsMode::Null.new
+      MODES = [
+        GraphicsMode::Text.new,                   # 000 standard text
+        GraphicsMode::MulticolorText.new,         # 001 multicolour text
+        GraphicsMode::Bitmap.new,                 # 010 standard bitmap
+        GraphicsMode::MulticolorBitmap.new,       # 011 multicolour bitmap
+        GraphicsMode::ExtendedBackgroundText.new, # 100 ECM text
+        NULL_MODE,                                # 101 invalid
+        NULL_MODE,                                # 110 invalid
+        NULL_MODE                                 # 111 invalid
+      ].freeze
+
+      attr_reader :colors, :fg, :border, :registers, :bank, :cur_colors
+      # The fg masks are shared frozen patterns assigned by reference, never
+      # mutated in place.
+      attr_accessor :cur_fg
+
+      def initialize(width, registers, bank)
+        @width = width
+        @registers = registers
+        @bank = bank
+        @colors = Array.new(width, 0)
+        @fg = Array.new(width, false)
+        @border = Array.new(width, true)
+        @border_groups = Array.new(width / 8, BORDER_FULL)
+        @cur_colors = Array.new(8, 0)
+        @cur_fg = GraphicsMode::NO_FG
+        @prev_colors = Array.new(8, 0)
+        @prev_fg = GraphicsMode::NO_FG
+        @vertical_border = true
+        @main_border = true
+        new_line(0)
+      end
+
+      # Reset the line buffers at the start of a rasterline and re-evaluate the
+      # vertical border flip-flop.
+      def new_line(line)
+        update_vertical_border(line)
+        @colors.fill(@registers.border)
+        @fg.fill(false)
+        @border_groups.fill(BORDER_FULL)
+        @prev_colors.fill(@registers.background)
+        @prev_fg = GraphicsMode::NO_FG
+      end
+
+      # Repaint the border over the composited line, hiding the sprites.
+      def apply_border
+        color = @registers.border
+        group = 0
+        while group < @border_groups.length
+          case @border_groups[group]
+          when BORDER_FULL then @colors.fill(color, group * 8, 8)
+          when BORDER_MIXED then paint_mixed_border(color, group * 8)
+          end
+          group += 1
+        end
+      end
+
+      def emit(screencode, color, col, cell, row)
+        MODES[@registers.mode].decode(screencode, color, cell, row, self)
+        output(col)
+        roll
+      end
+
+      def emit_idle(col)
+        @cur_colors.fill(@registers.background)
+        @cur_fg = GraphicsMode::NO_FG
+        output(col)
+        roll
+      end
+
+      private
+
+      # Write the 8-pixel group for a column into the line buffers. The main
+      # border flip-flop only changes state in the groups containing the
+      # window edge compares, so all other groups take a branch-free bulk
+      # path: fully border or fully window.
+      def output(col)
+        x_pos = (col + 16) * 8
+        win_lo, right_compare = WINDOW_COMPARES[@registers.csel? ? 1 : 0]
+
+        if boundary_group?(x_pos, win_lo, right_compare)
+          output_boundary(col, x_pos, win_lo, right_compare)
+        elsif @main_border || @vertical_border
+          output_border(x_pos)
+        else
+          output_window(col, x_pos)
+        end
+      end
+
+      # True if the group contains a window edge, where the main border
+      # flip-flop can change state.
+      def boundary_group?(x_pos, win_lo, right_compare)
+        lo_delta = win_lo - x_pos
+        hi_delta = right_compare - x_pos
+        (lo_delta >= 0 && lo_delta < 8) || (hi_delta >= 0 && hi_delta < 8)
+      end
+
+      def output_border(x_pos)
+        @colors.fill(@registers.border, x_pos, 8)
+        @border_groups[x_pos >> 3] = BORDER_FULL
+        @fg.fill(false, x_pos, 8)
+      end
+
+      def output_window(col, x_pos)
+        in_gfx = x_pos >= GFX_X_START && x_pos < GFX_X_END
+        @border_groups[x_pos >> 3] = BORDER_NONE
+
+        if @registers.xscroll.zero?
+          @colors[x_pos, 8] = @cur_colors
+          if in_gfx
+            @fg[x_pos, 8] = @cur_fg
+          else
+            @fg.fill(false, x_pos, 8)
+          end
+        else
+          output_window_shifted(col, x_pos, in_gfx)
+        end
+      end
+
+      def output_window_shifted(col, x_pos, in_gfx)
+        shift = @registers.xscroll
+        keep = 8 - shift
+
+        @colors[x_pos + shift, keep] = @cur_colors[0, keep]
+        if col.positive? # the left column only exists from column 1 on
+          @colors[x_pos, shift] = @prev_colors[keep, shift]
+        else
+          @colors.fill(@registers.background, x_pos, shift)
+        end
+        output_shifted_fg(col, x_pos, in_gfx, shift, keep)
+      end
+
+      def output_shifted_fg(col, x_pos, in_gfx, shift, keep)
+        return @fg.fill(false, x_pos, 8) unless in_gfx
+
+        @fg[x_pos + shift, keep] = @cur_fg[0, keep]
+        if col.positive?
+          @fg[x_pos, shift] = @prev_fg[keep, shift]
+        else
+          @fg.fill(false, x_pos, shift)
+        end
+      end
+
+      # Slow path for the groups where the border flip-flop can change state.
+      def output_boundary(col, x_pos, win_lo, right_compare)
+        shift = @registers.xscroll
+        bg = @registers.background
+        bleed = col.positive?
+        border = @registers.border
+        @border_groups[x_pos >> 3] = BORDER_MIXED
+
+        i = 0
+        while i < 8
+          src = i - shift
+          if src >= 0
+            pixel = @cur_colors[src]
+            mask = @cur_fg[src]
+          elsif bleed
+            pixel = @prev_colors[8 + src]
+            mask = @prev_fg[8 + src]
+          else
+            pixel = bg
+            mask = false
+          end
+          x = x_pos + i
+          shown = pixel_shown?(x, win_lo, right_compare)
+          @colors[x] = shown ? pixel : border
+          @border[x] = !shown
+          @fg[x] = x >= GFX_X_START && x < GFX_X_END ? mask : false
+          i += 1
+        end
+      end
+
+      def paint_mixed_border(color, x_pos)
+        i = 0
+        while i < 8
+          @colors[x_pos + i] = color if @border[x_pos + i]
+          i += 1
+        end
+      end
+
+      def pixel_shown?(pixel_x, left_compare, right_compare)
+        @main_border = true if pixel_x == right_compare
+        @main_border = false if pixel_x == left_compare && !@vertical_border
+        !(@main_border || @vertical_border)
+      end
+
+      def roll
+        @prev_colors, @cur_colors = @cur_colors, @prev_colors
+        @prev_fg, @cur_fg = @cur_fg, @prev_fg
+      end
+
+      def update_vertical_border(line)
+        top, bottom = BORDER_Y_BOUNDS[@registers.rsel? ? 1 : 0]
+        @vertical_border = true if line == bottom
+        @vertical_border = false if line == top && @registers.display_enabled?
+      end
+    end
+  end
+end