badline 0.1.0

data/lib/badline/vic/sprite.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sprite
+      X_OFFSET = 104
+      ROWS = 21
+
+      attr_reader :index, :line_pixels
+
+      def initialize(index, registers, bank, width)
+        @index = index
+        @registers = registers
+        @bank = bank
+        @width = width
+        @bit = 1 << index
+        @displaying = false
+        @counter = 0
+        @bits = nil
+        @line_pixels = nil
+        @pixel_buffer = Array.new(48)
+      end
+
+      def displaying? = @displaying
+
+      def enabled? = @registers[0x15].anybits?(@bit)
+      def multicolor? = @registers[0x1c].anybits?(@bit)
+      def x_expanded? = @registers[0x1d].anybits?(@bit)
+      def y_expanded? = @registers[0x17].anybits?(@bit)
+      def priority? = @registers[0x1b].anybits?(@bit)
+
+      def x
+        msb = @registers[0x10].anybits?(@bit) ? 0x100 : 0
+        msb | @registers[index * 2]
+      end
+
+      def y = @registers[(index * 2) + 1]
+      def color = @registers[0x27 + index] & 0x0f
+
+      def leftmost = (x + X_OFFSET) % @width
+      def pixel_width = x_expanded? ? 48 : 24
+
+      def start_line(line)
+        if !@displaying && enabled? && line == y
+          @displaying = true
+          @counter = 0
+        end
+
+        return @line_pixels = nil unless @displaying
+
+        row = y_expanded? ? @counter / 2 : @counter
+        if row >= ROWS
+          @displaying = false
+          return @line_pixels = nil
+        end
+
+        @counter += 1
+        fetch(row)
+        decode_line
+      end
+
+      def pixel(raster_x)
+        return nil unless @line_pixels
+
+        dist = raster_x - leftmost
+        dist += @width if dist.negative?
+        dist < pixel_width ? @line_pixels[dist] : nil
+      end
+
+      private
+
+      # Decode the fetched 24 data bits into a buffer of pixel colors (nil is
+      # transparent), so compositing can read pixels without re-deriving them.
+      def decode_line(pixels = @pixel_buffer)
+        @line_pixels = pixels
+        if multicolor?
+          decode_multicolor(pixels, x_expanded?)
+        else
+          decode_hires(pixels, x_expanded?)
+        end
+      end
+
+      def decode_hires(pixels, expanded)
+        own = color
+        last = expanded ? 48 : 24
+        i = 0
+        while i < last
+          offset = expanded ? i >> 1 : i
+          pixels[i] = (@bits >> (23 - offset)).anybits?(1) ? own : nil
+          i += 1
+        end
+      end
+
+      def decode_multicolor(pixels, expanded)
+        shared1 = @registers[0x25] & 0x0f
+        shared2 = @registers[0x26] & 0x0f
+        own = color
+        last = expanded ? 48 : 24
+        i = 0
+        while i < last
+          offset = expanded ? i >> 1 : i
+          pixels[i] = case (@bits >> (22 - (offset & ~1))) & 0b11
+                      when 0b01 then shared1
+                      when 0b10 then own
+                      when 0b11 then shared2
+                      end
+          i += 1
+        end
+      end
+
+      def fetch(row)
+        base = (pointer * 64) + (row * 3)
+        @bits = (@bank.peek(base) << 16) |
+                (@bank.peek(base + 1) << 8) |
+                @bank.peek(base + 2)
+      end
+
+      def pointer = @bank.peek(@registers.screen_base + 0x3f8 + index)
+    end
+  end
+end

data/lib/badline/vic/sprites.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+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
+
+      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)
+        @win_color = Array.new(width, 0)
+        @win_priority = Array.new(width, false)
+      end
+
+      def [](index) = @sprites[index]
+
+      def start_line(line)
+        @sprites.each { |sprite| sprite.start_line(line) }
+      end
+
+      def active? = @sprites.any?(&:displaying?)
+
+      # 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
+
+        @sprites.each do |sprite|
+          next unless sprite.displaying?
+
+          seg_lo, seg_hi = merge(sprite, mask)
+          lo = seg_lo if seg_lo < lo
+          hi = seg_hi if seg_hi > hi
+        end
+
+        apply(colors, mask, lo, hi)
+        register_collisions
+      end
+
+      private
+
+      # 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
+        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)
+          end
+          i += 1
+        end
+
+        right = left + last
+        right > @width ? [0, @width] : [left, right]
+      end
+
+      def merge_pixel(pos, color, bit, priority, mask)
+        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?
+            colors[pos] = @win_color[pos] unless @win_priority[pos] && mask[pos]
+            @hits[pos] = 0
+          end
+          pos += 1
+        end
+      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)
+      end
+    end
+  end
+end

data/lib/badline/vic.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "badline/vic/bank"
+require "badline/vic/registers"
+require "badline/vic/display_state"
+require "badline/vic/sequencer"
+require "badline/vic/sprites"
+
+module Badline
+  class VIC < Cycleable
+    include Addressable
+    include IntegerHelper
+
+    attr_reader :address_bus, :display, :width, :height, :vic_bank, :column,
+                :rasterline, :dirty_lines
+
+    SPRITE_BA_RANGES = [
+      55..59, 57..61, 59..62,
+      0..2, 0..4, 2..6, 4..8, 6..10
+    ].freeze
+
+    def initialize(address_bus = nil, debug: false)
+      addressable_at(0xd000, length: 2**10)
+      @address_bus = address_bus || AddressBus.new
+      @vic_bank = VIC::Bank.new(@address_bus)
+      @debug = debug
+
+      @width = 504
+      @height = 312
+
+      @registers = VIC::Registers.new
+      @display_state = VIC::DisplayState.new(@registers)
+      @sequencer = VIC::Sequencer.new(@width, @registers, @vic_bank)
+      @sprites = VIC::Sprites.new(@registers, @vic_bank, @width)
+      @display = Array.new(@width * @height, 0)
+      @dirty_lines = Array.new(@height, true)
+
+      @column = 0
+      @rasterline = 0
+      @columns_per_line = @width / 8
+      @last_line = @height - 1
+
+      @character_buffer = Array.new(40, 0)
+      @color_buffer = Array.new(40, 0)
+      @sprite_ba = Array.new(@width / 8, false)
+
+      super()
+    end
+
+    def cycle!
+      if @column.zero?
+        @display_state.new_frame if @rasterline.zero?
+        check_raster_irq!
+        @sequencer.new_line(@rasterline)
+        @sprites.start_line(@rasterline)
+        rebuild_sprite_ba
+        @display_state.new_line
+      end
+
+      @display_state.cycle(@rasterline, @column)
+
+      fetch_character_data! if dma_active?
+
+      draw!
+
+      @column += 1
+      if @column == @columns_per_line
+        finish_line!
+        @column = 0
+        @rasterline = @rasterline == @last_line ? 0 : @rasterline + 1
+      end
+      nil
+    end
+
+    # The IRQ line is held asserted while any enabled latch bit is set in
+    # $D019/$D01A, until the program acknowledges it by writing to $D019.
+    def interrupted?
+      @registers.irq_line?
+    end
+
+    def peek(addr)
+      i = index(addr) % (2**6)
+      case i
+      when 0x11 then (@registers[0x11] & 0x7f) | ((rasterline & 0x100) >> 1)
+      when 0x12 then rasterline & 0xff
+      when 0x19 then irq_status # Latch + master IRQ bit, unused bits read 1
+      else @registers.read(i)
+      end
+    end
+
+    def poke(addr, value)
+      @registers.write(index(addr) % (2**6), value)
+    end
+
+    def position
+      (@rasterline * @width) + (@column * 8)
+    end
+
+    def dma_active?
+      @display_state.bad_line? && @column >= 15 && @column < 55
+    end
+
+    def ba_low?
+      return true if @sprite_ba[@column]
+
+      @display_state.bad_line? && @column >= 13 && @column < 56
+    end
+
+    def hblank?
+      @column < 10 || @column > 60
+    end
+
+    def vblank?
+      @rasterline < 16 || @rasterline > 299
+    end
+
+    def blanking?
+      @rasterline < 16 || @rasterline > 299 || @column < 10 || @column > 60
+    end
+
+    # Reset the dirty flags once the frontend has consumed them.
+    def clear_dirty_lines!
+      @dirty_lines.fill(false)
+    end
+
+    private
+
+    def rebuild_sprite_ba
+      @sprite_ba.fill(false)
+      SPRITE_BA_RANGES.each_with_index do |range, n|
+        next unless @sprites[n].displaying?
+
+        range.each { |c| @sprite_ba[c] = true }
+      end
+    end
+
+    def draw!
+      return if blanking?
+
+      col = @column - 16
+      unless @display_state.display?
+        @sequencer.emit_idle(col)
+        return
+      end
+
+      cell = (@display_state.vc_base + col) & 0x3ff
+      screencode = @character_buffer[col] || 0
+      @sequencer.emit(screencode, @color_buffer[col] || 1, col,
+                      cell, @display_state.rc)
+    end
+
+    def finish_line!
+      return if vblank?
+
+      # Composite the active sprites over the finished background line
+      # and copy the line into the frame display.
+      if @sprites.active?
+        @sprites.composite(@sequencer.colors, @sequencer.fg)
+        @sequencer.apply_border
+      end
+      base = @rasterline * @width
+      colors = @sequencer.colors
+      return if @display[base, @width] == colors
+
+      @display[base, @width] = colors
+      @dirty_lines[@rasterline] = true
+    end
+
+    def video_matrix(index)
+      vic_bank.peek(@registers.screen_base + index)
+    end
+
+    def check_raster_irq!
+      return unless @rasterline == @registers.raster_target
+
+      # Latch the raster IRQ flag. The line asserts via #interrupted? when the
+      # matching mask bit in $D01A is set.
+      @registers.latch_raster_irq!
+    end
+
+    def irq_status
+      (@registers[0x19] & 0x0f) | 0x70 | (interrupted? ? 0x80 : 0)
+    end
+
+    def fetch_character_data!
+      vmli = @column - 15
+      vc = (@display_state.vc_base + vmli) & 0x3ff
+      @character_buffer[vmli] = video_matrix(vc)
+      @color_buffer[vmli] = vic_bank.peek_color(vc)
+    end
+  end
+end

data/lib/badline.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "badline/version"
+require "badline/integer_helper"
+require "badline/addressable"
+require "badline/memory"
+require "badline/color_memory"
+require "badline/rom"
+require "badline/address_bus"
+require "badline/instruction"
+require "badline/instruction_set"
+require "badline/status"
+require "badline/keyboard"
+require "badline/joystick"
+require "badline/control_ports"
+require "badline/cycleable"
+require "badline/time_of_day"
+require "badline/cia"
+require "badline/sid"
+require "badline/traps"
+require "badline/cpu"
+require "badline/vic"
+require "badline/keyboard_buffer"
+require "badline/computer"
+require "badline/storage"
+require "badline/cartridge"
+require "badline/kernal_trap"
+require "badline/chrout_trap"
+require "badline/media"

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: badline
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Inge Jørgensen
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-sdl2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Badline is a Commodore 64 emulator written in Ruby, implementing cycle-accurate
+  timing and hardware behavior. Supports PRG/P00 programs, D64/D71/D81 disk images
+  and CRT cartridges.
+email:
+- inge@elektronaut.no
+executables:
+- badline
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- exe/badline
+- lib/badline.rb
+- lib/badline/address_bus.rb
+- lib/badline/addressable.rb
+- lib/badline/cartridge.rb
+- lib/badline/cartridge/magic_desk.rb
+- lib/badline/cartridge/ocean.rb
+- lib/badline/cartridge/standard.rb
+- lib/badline/chrout_trap.rb
+- lib/badline/cia.rb
+- lib/badline/cia/timer.rb
+- lib/badline/color_memory.rb
+- lib/badline/computer.rb
+- lib/badline/control_ports.rb
+- lib/badline/cpu.rb
+- lib/badline/cycleable.rb
+- lib/badline/gui.rb
+- lib/badline/gui/application.rb
+- lib/badline/gui/joy_map.rb
+- lib/badline/gui/key_map.rb
+- lib/badline/gui/palette.rb
+- lib/badline/gui/pane.rb
+- lib/badline/gui/screen_pane.rb
+- lib/badline/gui/window.rb
+- lib/badline/instruction.rb
+- lib/badline/instruction_set.rb
+- lib/badline/instruction_set/arithmetic.rb
+- lib/badline/instruction_set/bitwise.rb
+- lib/badline/instruction_set/branch.rb
+- lib/badline/instruction_set/flag.rb
+- lib/badline/instruction_set/illegal.rb
+- lib/badline/instruction_set/inc_dec.rb
+- lib/badline/instruction_set/stack.rb
+- lib/badline/instruction_set/transfer.rb
+- lib/badline/integer_helper.rb
+- lib/badline/joystick.rb
+- lib/badline/kernal_trap.rb
+- lib/badline/kernal_trap/file.rb
+- lib/badline/kernal_trap/load.rb
+- lib/badline/kernal_trap/save.rb
+- lib/badline/keyboard.rb
+- lib/badline/keyboard_buffer.rb
+- lib/badline/media.rb
+- lib/badline/memory.rb
+- lib/badline/rom.rb
+- lib/badline/roms/README
+- lib/badline/roms/basic.rom
+- lib/badline/roms/character.rom
+- lib/badline/roms/kernal.rom
+- lib/badline/sid.rb
+- lib/badline/status.rb
+- lib/badline/storage.rb
+- lib/badline/storage/crt_file.rb
+- lib/badline/storage/d64_image.rb
+- lib/badline/storage/d71_image.rb
+- lib/badline/storage/d81_image.rb
+- lib/badline/storage/disk_image.rb
+- lib/badline/storage/host_directory.rb
+- lib/badline/storage/p00.rb
+- lib/badline/time_of_day.rb
+- lib/badline/traps.rb
+- lib/badline/version.rb
+- lib/badline/vic.rb
+- lib/badline/vic/bank.rb
+- lib/badline/vic/display_state.rb
+- lib/badline/vic/graphics_mode.rb
+- lib/badline/vic/registers.rb
+- lib/badline/vic/sequencer.rb
+- lib/badline/vic/sprite.rb
+- lib/badline/vic/sprites.rb
+homepage: https://github.com/elektronaut/badline
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/elektronaut/badline
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A cycle-accurate Commodore 64 emulator
+test_files: []