badline 0.12.0 → 0.13.0

data/lib/badline/drives/serial_bus.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Badline
+  module Drives
+    # The serial bus between the C64 and its drives: ATN, CLK and DATA, each
+    # an open-collector line with a pull-up. A line is low while any device
+    # pulls it (wired-AND), and high otherwise. Every read works the levels
+    # out from what each side drives now.
+    #
+    # The C64 drives the lines from CIA 2's port A through 7406 inverters, so
+    # an output bit of 1 pulls its line low: PA3 ATN, PA4 CLK and PA5 DATA.
+    # The machine pushes those bits into the bus (host_lines=), which holds
+    # them. PA6 and PA7 read CLK and DATA directly, 1 for a released line.
+    # The bus stands in as CIA 2's peripheral for those two inputs.
+    #
+    # A drive drives CLK and DATA from VIA 1's PB3 and PB1, the same way. It
+    # also pulls DATA while ATN IN differs from its ATN acknowledge on PB4
+    # (an XOR gate), which answers ATN in hardware before the DOS gets to it.
+    # SerialPort reads the lines back into VIA 1. A drive whose
+    # serial_output sets DRIVE_ATN_GATED pulls DATA that way only while
+    # ATN is low, as the 1581's NAND does.
+    #
+    # Fast serial adds SRQ, which the C64 leaves alone. A C128 and a 1571
+    # clock bytes over it from a CIA's CNT, with the bits on DATA from its
+    # SP, through buffers each side turns towards the bus to send. A pin low
+    # pulls its line low. Each side pushes the lines it pulls when they
+    # move: the host through host_fast_lines=, which tells the drives
+    # (fast_lines_moved), and a drive through drives_fast_moved!, which
+    # tells the host (on_fast_change).
+    class SerialBus
+      # CIA 2 port A
+      HOST_ATN_OUT = 0x08
+      HOST_CLK_OUT = 0x10
+      HOST_DATA_OUT = 0x20
+      HOST_CLK_IN = 0x40
+      HOST_DATA_IN = 0x80
+
+      # VIA 1 port B
+      DRIVE_DATA_OUT = 0x02
+      DRIVE_CLK_OUT = 0x08
+      DRIVE_ATNA = 0x10
+
+      # The lines pulled low, as ATN, CLK, DATA and SRQ bits
+      ATN = 0x01
+      CLK = 0x02
+      DATA = 0x04
+      SRQ = 0x08
+
+      # A drive's serial_output bits above VIA 1's port B: its fast serial
+      # pins pulling DATA and SRQ.
+      DRIVE_FAST_DATA = 0x100
+      DRIVE_FAST_SRQ = 0x200
+
+      # A drive's serial_output bit whose ATN acknowledge pulls DATA only
+      # while ATN is low.
+      DRIVE_ATN_GATED = 0x400
+
+      attr_reader :drives, :host_lines
+
+      # The lines the host's fast serial pins pull, as DATA and SRQ bits.
+      attr_reader :host_fast_lines
+
+      def initialize
+        @drives = []
+        @host_lines = 0
+        @host_fast_lines = 0
+        @drive_fast_lines = 0
+        @on_fast_change = nil
+      end
+
+      # The host's fast serial pins moved: +low+ is the lines they pull, as
+      # DATA and SRQ bits.
+      def host_fast_lines=(low)
+        return if low == @host_fast_lines
+
+        @host_fast_lines = low
+        @drives.each(&:fast_lines_moved)
+      end
+
+      # A drive's fast serial pins moved (serial_output's fast bits).
+      def drives_fast_moved!
+        low = 0
+        @drives.each do |drive|
+          output = drive.serial_output
+          low |= DATA if output.anybits?(DRIVE_FAST_DATA)
+          low |= SRQ if output.anybits?(DRIVE_FAST_SRQ)
+        end
+        return if low == @drive_fast_lines
+
+        @drive_fast_lines = low
+        @on_fast_change&.call
+      end
+
+      # Calls the block whenever the drives move their fast serial pins.
+      def on_fast_change(&block)
+        @on_fast_change = block
+      end
+
+      # The machine pushes the lines it pulls, as port A bits, whenever they
+      # may have moved: its output bits, with input bits floating high as the
+      # 7406 inputs see them. A bus with only drives on it keeps 0.
+      def host_lines=(lines)
+        @host_lines = lines
+        @drives.each(&:host_written!)
+      end
+
+      def attach(drive)
+        @drives << drive unless @drives.include?(drive)
+      end
+
+      def detach(drive)
+        @drives.delete(drive)
+      end
+
+      # One pass over everything on the bus, for a reader that wants more
+      # than one line, SRQ included. +host+ is the C64's port A lines as the
+      # reader sees them, which a drive takes a cycle late (see
+      # Drives::Engine::SerialLines).
+      def low_lines(host = @host_lines)
+        atn = host.anybits?(HOST_ATN_OUT)
+        low = @host_fast_lines | @drive_fast_lines
+        low |= ATN if atn
+        low |= CLK if host.anybits?(HOST_CLK_OUT)
+        low |= DATA if host.anybits?(HOST_DATA_OUT)
+        i = 0
+        while i < @drives.length
+          drive = @drives[i].serial_output
+          low |= CLK if drive.anybits?(DRIVE_CLK_OUT)
+          low |= DATA if drive.anybits?(DRIVE_DATA_OUT) || acknowledging?(drive, atn)
+          i += 1
+        end
+        low
+      end
+
+      def atn_low?(host = @host_lines) = host.anybits?(HOST_ATN_OUT)
+
+      # Whether a drive's ATN acknowledge pulls DATA, with its serial_output
+      # +drive+, while ATN is +atn+.
+      def acknowledging?(drive, atn)
+        atn != drive.anybits?(DRIVE_ATNA) && (atn || drive.nobits?(DRIVE_ATN_GATED))
+      end
+
+      def clk_low? = low_lines.anybits?(CLK)
+
+      def data_low? = low_lines.anybits?(DATA)
+
+      # CIA 2's port A pins as the bus leaves them: CLK IN and DATA IN low
+      # while their lines are.
+      def read_a(_port_a, _port_b)
+        low = low_lines
+        value = 0xff
+        value &= ~HOST_CLK_IN if low.anybits?(CLK)
+        value &= ~HOST_DATA_IN if low.anybits?(DATA)
+        value
+      end
+
+      # Port B goes to the user port, not the serial bus.
+      def read_b(_port_a, _port_b) = 0xff
+    end
+  end
+end

data/lib/badline/frontend/boot.rb

@@ -33,9 +33,9 @@ module Badline
     def self.media_problem
       yield
       ""
-    rescue Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Datasette::Missing,
-           SystemCallError, Storage::SIDFile::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
-           Storage::CRTFile::FormatError, Storage::G64Image::FormatError, Cartridge::UnsupportedTypeError,
+    rescue Machine::Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Drives::Datasette::Missing,
+           SystemCallError, SIDTune::File::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
+           Storage::CRTFile::FormatError, Storage::G64Image::FormatError, C64::Cartridge::UnsupportedTypeError,
            Snapshot::FormatError => e
       e.message
     end
@@ -53,11 +53,10 @@ module Badline
       start(options, media, options.writable?)
     end
 
-    # A new machine built from the options, with `media`, if not nil,
-    # attached and started as the command line does, its disk writable if
-    # `writable`. The family and model give the machine, and a .sid tune
-    # or --sid the SID. The VIC-20 raises Unsupported for a .sid
-    # tune.
+    # A new machine built from the options (Machine.for_options), with
+    # `media`, if not nil, attached and started as the command line does,
+    # its disk writable if `writable`. The VIC-20 raises
+    # Machine::Unsupported for a .sid tune.
     def self.start(options, media, writable)
       computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
@@ -68,60 +67,10 @@ module Badline
       computer
     end
 
+    # The machine the options name, built for `media`, which says the RAM
+    # expansion a VIC-20 gets for it.
     def self.build(options, media)
-      case options.family
-      when :vic20 then vic20(options, media)
-      when :c128 then c128(options, media)
-      else c64(options, media)
-      end
-    end
-
-    def self.c64(options, media)
-      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
-      Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
-    end
-
-    # A C128 in C128 mode. With --c64, or media only C64 mode runs, a .sid
-    # tune or a program that loads at the C64's BASIC start, C= is held
-    # through the reset, so the C128 KERNAL starts C64 mode.
-    def self.c128(options, media)
-      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
-      machine = C128.new(model: options.model, sid_model:, mode: :c128)
-      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
-      machine
-    end
-
-    def self.c64_media?(media)
-      return false if media.nil? || !File.file?(media)
-
-      extension = File.extname(media).downcase
-      return true if extension == ".sid"
-      return false unless %w[.prg .p00].include?(extension)
-
-      [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
+      Machine.for_options(options, media) { |line| puts line }
     end
-
-    # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
-    # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
-    # media a VIC-20 doesn't take.
-    def self.vic20(options, media)
-      ram = options.ram
-      unless media.nil?
-        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
-        raise Unsupported, "doesn't go in a VIC-20" if unsupported
-
-        ram ||= vic20_ram(media)
-      end
-      Machine.build(:vic20, model: options.model, ram:)
-    end
-
-    def self.vic20_ram(media)
-      ram = Media::Vic20Media.ram_for(media)
-      puts "RAM expansion: #{ram}"
-      ram
-    end
-
-    # Media the machine the options name doesn't take.
-    class Unsupported < ArgumentError; end
   end
 end

data/lib/badline/frontend/machine_window.rb

@@ -17,7 +17,8 @@ module Badline
       attr_reader :renderer, :texture
 
       # Opens the window for `screen`, presenting in step with the display
-      # when `vsync`.
+      # when `vsync`. Text input stays off, so a dead key such as ´ on a Mac
+      # arrives as a key press, as every other key does.
       def initialize(screen, vsync:)
         abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
 
@@ -28,6 +29,7 @@ module Badline
           TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
           SDL::WINDOW_RESIZABLE
         )
+        SDL.SDL_StopTextInput
         flags = SDL::RENDERER_ACCELERATED
         flags |= SDL::RENDERER_PRESENTVSYNC if vsync
         @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)

data/lib/badline/frontend/player/filter_view.rb

@@ -31,7 +31,7 @@ module Badline
         cutoff = (history.register(frame, 0x15) & 0x07) | (history.register(frame, 0x16) << 3)
         resonance = history.register(frame, 0x17) >> 4
         mode_volume = history.register(frame, 0x18)
-        hertz = SID::Filter::W0.fetch(model)[cutoff] / (2 * Math::PI * SID::Filter::SCALE)
+        hertz = Chips::SID::Filter::W0.fetch(model)[cutoff] / (2 * Math::PI * Chips::SID::Filter::SCALE)
         paint = @painter
         paint.text(LEFT, top, "FILTER", BRIGHT)
         x = LEFT + 64

data/lib/badline/frontend/player/player_controller.rb

@@ -106,7 +106,7 @@ module Badline
       # Keeps the subtune's STIL credits for the header and the whole entry
       # for the INFO view.
       def stil(fields, subtune, subtune_fields)
-        @credits = Storage::STIL::Credit.list(subtune_fields.empty? ? fields : subtune_fields)
+        @credits = SIDTune::STIL::Credit.list(subtune_fields.empty? ? fields : subtune_fields)
         @stil = fields
         @stil_subtune = subtune
         @subtune_stil = subtune_fields
@@ -211,7 +211,7 @@ module Badline
 
       def draw
         @next_draw = now + FRAME
-        @screen.draw(@state, @player, @history, @tune_file, Storage::STIL::Credit.at(@credits, @state.played))
+        @screen.draw(@state, @player, @history, @tune_file, SIDTune::STIL::Credit.at(@credits, @state.played))
       end
 
       def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)

data/lib/badline/frontend/player/player_screen.rb

@@ -31,6 +31,7 @@ module Badline
         SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
         @window = SDL.SDL_CreateWindow(TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
                                        WIDTH * SCALE, height(view) * SCALE, SDL::WINDOW_RESIZABLE)
+        SDL.SDL_StopTextInput
         @renderer = SDL.SDL_CreateRenderer(@window, -1, SDL::RENDERER_ACCELERATED)
         SDL.SDL_RenderSetLogicalSize(@renderer, WIDTH, height(view))
         build

data/lib/badline/frontend/player/theme.rb

@@ -6,13 +6,13 @@ module Badline
     # C64's palette: one for each voice, and light blue on blue as on the
     # machine's screen.
     module PlayerTheme
-      TEXT = VIC::PALETTE[14]
-      BRIGHT = VIC::PALETTE[1]
-      DIM = VIC::PALETTE[11]
-      BOX = VIC::PALETTE[0]
-      BACKGROUND = VIC::PALETTE[6]
-      WARNING = VIC::PALETTE[10]
-      VOICE_COLORS = [VIC::PALETTE[7], VIC::PALETTE[13], VIC::PALETTE[3]].freeze
+      TEXT = Chips::VIC::PALETTE[14]
+      BRIGHT = Chips::VIC::PALETTE[1]
+      DIM = Chips::VIC::PALETTE[11]
+      BOX = Chips::VIC::PALETTE[0]
+      BACKGROUND = Chips::VIC::PALETTE[6]
+      WARNING = Chips::VIC::PALETTE[10]
+      VOICE_COLORS = [Chips::VIC::PALETTE[7], Chips::VIC::PALETTE[13], Chips::VIC::PALETTE[3]].freeze
     end
   end
 end

data/lib/badline/frontend/timeline.rb

@@ -39,15 +39,15 @@ module Badline
 
       # The Keyboard's key for a name such as space, return or a.
       def self.keyboard_key(name)
-        key = Keyboard.new.matrix.flatten.find { |candidate| candidate.to_s == name }
-        key.nil? ? Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name } : key
+        key = Input::Keyboard.new.matrix.flatten.find { |candidate| candidate.to_s == name }
+        key.nil? ? Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name } : key
       end
 
       # The direction of joy1-NAME or joy2-NAME, such as up or fire.
       def self.joystick_direction(name)
         return nil unless name.start_with?("joy1-") || name.start_with?("joy2-")
 
-        Joystick::DIRECTIONS.keys.find { |direction| direction.to_s == name[5, name.size - 5] }
+        Input::Joystick::DIRECTIONS.keys.find { |direction| direction.to_s == name[5, name.size - 5] }
       end
 
       # The screenshot's file name, with the frame's number in place of %d,

data/lib/badline/input/control_ports.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    # CIA 1's control ports and the keyboard matrix that spans them.
+    #
+    # Port A carries the matrix rows together with joystick 2, port B the matrix
+    # columns together with joystick 1. Every switch is active low, so the
+    # joysticks are wired-AND onto the lines *before* the matrix settles: a stick
+    # held in a direction selects rows and columns of its own, which is where
+    # hardware's phantom keypresses come from. Paddles and a 1351 mouse have
+    # buttons on those same lines.
+    #
+    # The ports also carry SID's POTX/POTY lines, which reach them through analog
+    # switches closed by CIA 1 PA6 (port 1) and PA7 (port 2). Close both and the
+    # pots sit in parallel, so SID charges through the lower of the two
+    # resistances; close neither and the lines float high. Reading a pot asks the
+    # CIA for the current select lines, since a program sets them and then goes
+    # straight to SID without touching the ports again.
+    #
+    # A matrix may have rows beyond port A's eight. Their select lines come from
+    # outside the CIA and are pushed into +extra_rows+, bit 0 for the ninth row
+    # upwards, active low like port A; idle, every line is high and none of
+    # those rows is selected. They settle with port A's lines as rows 8 and up,
+    # so their keys reach port B, but port A reads only its own eight.
+    class ControlPorts
+      PORT1_POTS = 0x40
+      PORT2_POTS = 0x80
+      FIRE = 0x10
+
+      attr_reader :keyboard, :joystick1, :joystick2
+      attr_accessor :device1, :device2, :port_a_source, :extra_rows
+
+      def initialize(keyboard:, joystick1:, joystick2:)
+        @keyboard = keyboard
+        @joystick1 = joystick1
+        @joystick2 = joystick2
+        @device1 = nil
+        @device2 = nil
+        @port_a_source = nil
+        @extra_rows = 0xff
+      end
+
+      def read_a(port_a, port_b) = scan(port_a, port_b).first & 0xff
+
+      def read_b(port_a, port_b) = scan(port_a, port_b).last
+
+      # Control port 1 pin 6 is both the port B fire line and the VIC's light
+      # pen input, so joystick 1's button and a 1351's left button latch
+      # $D013/$D014. The CIA samples this every cycle, so it skips the matrix and
+      # asks only what the port's own devices drive.
+      def port_b4_high? = port_bits(@joystick1, @device1).anybits?(FIRE)
+
+      def pot_x = selected_devices.map(&:pot_x).min || 0xff
+
+      def pot_y = selected_devices.map(&:pot_y).min || 0xff
+
+      private
+
+      def selected_devices
+        lines = @port_a_source&.port_a_lines || 0x00
+        devices = []
+        devices << @device1 if @device1 && lines.anybits?(PORT1_POTS)
+        devices << @device2 if @device2 && lines.anybits?(PORT2_POTS)
+        devices
+      end
+
+      def scan(port_a, port_b)
+        keyboard.scan((port_a & port_bits(@joystick2, @device2)) | (@extra_rows << 8),
+                      port_b & port_bits(@joystick1, @device1))
+      end
+
+      def port_bits(joystick, device)
+        device ? joystick.port_bits & device.port_bits : joystick.port_bits
+      end
+    end
+  end
+end

data/lib/badline/input/joystick.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    class Joystick
+      DIRECTIONS = { up: 0, down: 1, left: 2, right: 3, fire: 4 }.freeze
+
+      # Kept up to date as switches move, since the CIA samples the fire line
+      # every cycle to drive the light pen input.
+      attr_reader :port_bits
+
+      def initialize
+        @port_bits = 0xff
+      end
+
+      def press(direction)
+        bit = DIRECTIONS[direction]
+        @port_bits &= ~(1 << bit) if bit
+      end
+
+      def release(direction)
+        bit = DIRECTIONS[direction]
+        @port_bits |= 1 << bit if bit
+      end
+    end
+  end
+end

data/lib/badline/input/keyboard.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    # The key matrix spanning CIA 1's two ports: rows on port A, columns on
+    # port B. Row lines beyond the eighth sit above port A's bits in +rows+.
+    #
+    # A pressed key shorts its row line to its column line, so whichever side is
+    # pulled low drags the other down with it. Scanning works in either
+    # direction, and chains of keys sharing a line propagate the pulldown -- the
+    # ghost keys real hardware reports.
+    class Keyboard
+      include IntegerHelper
+
+      # Keys the C64 types as a combination: cursor up and cursor left are the
+      # shifted cursor keys. Pressing one holds both of its matrix keys, while
+      # a shift key held on its own stays down when it is released.
+      COMBINATIONS = {
+        cursor_up: %i[lshift cursor_v],
+        cursor_left: %i[lshift cursor_h]
+      }.freeze
+
+      # The C64's wiring: one row of keys per port A line, in port B column
+      # order.
+      C64_MATRIX = [
+        %i[delete return cursor_h f7 f1 f3 f5 cursor_v],
+        %i[3 w a 4 z s e lshift],
+        %i[5 r d 6 c f t x],
+        %i[7 y g 8 b h u v],
+        %i[9 i j 0 m k o n],
+        %i[+ p l - . : @ ,],
+        %i[£ * ; clr_home rshift = up /],
+        %i[1 left control 2 space cbm q run_stop]
+      ].freeze
+
+      attr_reader :keys, :matrix
+
+      def initialize(matrix: C64_MATRIX)
+        @keys = []
+        @row_masks = nil
+        @matrix = matrix
+        @connected = true
+      end
+
+      # Whether the machine has a keyboard. The C64GS has none: no key goes
+      # down on it.
+      def connected? = @connected
+
+      def connected=(connected)
+        @connected = connected
+        @keys.clear unless connected
+        @row_masks = nil
+      end
+
+      def press(key)
+        return unless @connected && valid_key?(key)
+
+        @keys << key
+        @row_masks = nil
+      end
+
+      def release(key)
+        @keys.reject! { |k| k == key }
+        @row_masks = nil
+      end
+
+      # Settles the row (port A) and column (port B) lines against each other
+      # until no key contact pulls a line low any more, and returns both.
+      def scan(rows, cols)
+        return [rows, cols] if keys.empty?
+
+        loop do
+          settled_rows = rows
+          settled_cols = cols
+
+          row_masks.each_with_index do |mask, row|
+            bit = 1 << row
+            next if mask.zero? || (rows.allbits?(bit) && cols.allbits?(mask))
+
+            rows &= ~bit
+            cols &= ~mask
+          end
+
+          return [rows, cols] if rows == settled_rows && cols == settled_cols
+        end
+      end
+
+      def read_a(port_a, port_b) = scan(port_a, port_b).first
+
+      def read_b(port_a, port_b) = scan(port_a, port_b).last
+
+      private
+
+      # Columns held down per row, as a bit mask of port B lines.
+      def row_masks
+        @row_masks ||= begin
+          pressed = held
+          matrix.map do |row|
+            row.each_with_index.sum { |key, column| pressed.include?(key) ? 1 << column : 0 }
+          end
+        end
+      end
+
+      # The matrix keys held down, with each combination expanded.
+      def held
+        keys.flat_map { |key| COMBINATIONS[key] || [key] }
+      end
+
+      def valid_key?(key)
+        COMBINATIONS.key?(key) || matrix.flatten.include?(key)
+      end
+    end
+  end
+end

data/lib/badline/input.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/input/keyboard"
+require "badline/input/joystick"
+require "badline/input/control_ports"
 require "badline/input/mouse1351"
 require "badline/input/paddles"

data/lib/badline/kernal_trap/{drive → dos}/block_commands.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # The commands that read and write a block through a buffer channel,
       # and B-P, which moves its pointer.
       module BlockCommands