badline 0.12.1 → 0.14.0

data/lib/badline/frontend/snapshots.rb

@@ -20,6 +20,7 @@ module Badline
       def initialize(computer, options)
         @computer = computer
         @at_finish = options.save_snapshot
+        @vice = options.vice?
         @autosave = options.frames.zero?
         @autosave_at = AUTOSAVE_FRAMES
       end
@@ -128,11 +129,21 @@ module Badline
       end
 
       def finish
-        save(@at_finish) unless @at_finish.empty?
+        return if @at_finish.empty?
+
+        @vice ? export(@at_finish) : save(@at_finish)
       end
 
       private
 
+      # Saves the machine with VICE's modules too, and warns when it can't.
+      def export(path)
+        @computer.export_snapshot(path)
+        puts "Saved #{path} for badline and VICE"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
       def restore_from(path)
         @computer = Snapshot.load(path) { |line| puts line }
         puts "Restored #{name_of(path)} from #{path}"

data/lib/badline/frontend/timeline.rb

@@ -21,10 +21,13 @@ module Badline
         @failed = false
       end
 
-      # What's wrong with the events, the first key or menu page that
-      # names nothing, or an empty string.
-      def self.error(events)
-        event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument) }
+      # The C128's two locking keys, outside its matrix.
+      LOCKS = %w[caps_lock forty_eighty].freeze
+
+      # What's wrong with the events for the family's machine, the first
+      # key or menu page that names nothing, or an empty string.
+      def self.error(events, family)
+        event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument, family) }
         return "no such key: #{event.argument}" unless event.nil?
 
         event = events.find { |candidate| candidate.action == "menu" && !page?(candidate.argument) }
@@ -35,19 +38,24 @@ module Badline
       # sound. An empty one is its first.
       def self.page?(name) = name.empty? || PauseMenu::PAGES.any? { |page| page.to_s == name }
 
-      def self.key?(name) = name == "restore" || !keyboard_key(name).nil? || !joystick_direction(name).nil?
+      def self.key?(name, family)
+        name == "restore" || (family == :c128 && LOCKS.include?(name)) ||
+          !keyboard_key(name, family).nil? || !joystick_direction(name).nil?
+      end
 
-      # 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
+      # The family's Keyboard key for a name such as space, return or a,
+      # or on the C128 esc or keypad1.
+      def self.keyboard_key(name, family)
+        matrix = family == :c128 ? C128::KEYBOARD_MATRIX : Input::Keyboard::C64_MATRIX
+        key = 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,
@@ -130,6 +138,8 @@ module Badline
 
       def press(computer, event)
         name = event.argument
+        return lock(computer, name) if LOCKS.include?(name)
+
         if name == "restore"
           computer.press_restore
           return hold(event)
@@ -137,13 +147,21 @@ module Badline
 
         direction = Timeline.joystick_direction(name)
         if direction.nil?
-          computer.keyboard.press(Timeline.keyboard_key(name))
+          computer.keyboard.press(Timeline.keyboard_key(name, computer.family))
         else
           joystick(computer, name).press(direction)
         end
         hold(event)
       end
 
+      # CAPS LOCK and 40/80 DISPLAY lock: a push puts one down if it was up,
+      # and up if it was down.
+      def lock(computer, name)
+        return unless computer.family == :c128
+
+        name == "caps_lock" ? computer.push_caps_lock : computer.push_display_key
+      end
+
       # The VIC-20 and the C128 have no cartridge with a button yet.
       def freeze(computer, event)
         return unless computer.family == :c64
@@ -164,7 +182,7 @@ module Badline
 
         direction = Timeline.joystick_direction(name)
         if direction.nil?
-          computer.keyboard.release(Timeline.keyboard_key(name))
+          computer.keyboard.release(Timeline.keyboard_key(name, computer.family))
         else
           joystick(computer, name).release(direction)
         end

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/matrix_typist.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    # Types PETSCII codes on a Keyboard's matrix, one key at a time, for
+    # software that scans the keys itself instead of reading a KERNAL's
+    # keyboard buffer: each code's keys go down for HOLD cycles, then up for
+    # GAP cycles. Codes it has no key for are skipped.
+    class MatrixTypist
+      HOLD = 100_000
+      GAP = 40_000
+
+      # The keys typed without SHIFT, by PETSCII code.
+      PLAIN = {
+        0x0d => :return, 0x20 => :space, 0x2a => :*, 0x2b => :+, 0x2c => :",", 0x2d => :-, 0x2e => :".",
+        0x2f => :/, 0x3a => :":", 0x3b => :";", 0x3d => :"=", 0x40 => :"@"
+      }.freeze
+
+      # The keys typed with SHIFT, by PETSCII code.
+      SHIFTED = {
+        0x21 => :"1", 0x22 => :"2", 0x23 => :"3", 0x24 => :"4", 0x25 => :"5", 0x26 => :"6", 0x27 => :"7",
+        0x28 => :"8", 0x29 => :"9", 0x3c => :",", 0x3e => :".", 0x3f => :/, 0x5b => :":", 0x5d => :";"
+      }.freeze
+
+      DIGITS = %i[0 1 2 3 4 5 6 7 8 9].freeze
+      LETTERS = %i[a b c d e f g h i j k l m n o p q r s t u v w x y z].freeze
+
+      # The keys that type the PETSCII code, SHIFT first, or none.
+      def self.keys(code)
+        return [DIGITS[code - 0x30]] if code.between?(0x30, 0x39)
+        return [LETTERS[code - 0x41]] if code.between?(0x41, 0x5a)
+        return [:lshift, LETTERS[code - 0xc1]] if code.between?(0xc1, 0xda)
+        return [PLAIN[code]] if PLAIN.key?(code)
+        return [:lshift, SHIFTED[code]] if SHIFTED.key?(code)
+
+        []
+      end
+
+      def initialize(keyboard)
+        @keyboard = keyboard
+        @held = []
+        @code = 0
+        @wait = 0
+        @typing = false
+      end
+
+      # Whether it is part way through codes: from the first key down until
+      # the last one is up and its gap has passed.
+      def typing? = @typing
+
+      # A cycle of typing +codes+, taking each code off its front as its keys
+      # go down.
+      def cycle!(codes)
+        @wait -= 1 if @wait.positive?
+        return unless @wait.zero?
+
+        if @held.empty?
+          press(codes)
+        else
+          @held.each { |key| @keyboard.release(key) }
+          @held = []
+          @wait = GAP
+        end
+      end
+
+      # Where it is in its typing, in a keyed snapshot module under `prefix`:
+      # the code whose keys are down, if any, the cycles left before they
+      # go up or the next code's go down, and whether it is part way
+      # through. The keys go down again on load.
+      def save_fields(out, prefix)
+        out.optional_int("#{prefix}code", @held.empty? ? nil : @code)
+        out.int("#{prefix}wait", @wait).bool("#{prefix}typing", @typing)
+      end
+
+      def load_fields(input, prefix)
+        @held.each { |key| @keyboard.release(key) }
+        code = input.optional_int("#{prefix}code")
+        @code = code || 0
+        @held = code.nil? ? [] : MatrixTypist.keys(code)
+        @held.each { |key| @keyboard.press(key) }
+        @wait = input.int("#{prefix}wait", @wait)
+        @typing = input.bool("#{prefix}typing", @typing)
+      end
+
+      private
+
+      def press(codes)
+        @typing = !codes.empty?
+        return unless @typing
+
+        @code = codes.shift
+        @held = MatrixTypist.keys(@code)
+        @held.each { |key| @keyboard.press(key) }
+        @wait = @held.empty? ? 1 : HOLD
+      end
+    end
+  end
+end

data/lib/badline/input.rb

@@ -1,4 +1,8 @@
 # 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"
+require "badline/input/matrix_typist"

data/lib/badline/kernal_trap/chrout.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # Observe-only PC trap on the KERNAL CHROUT routine ($FFD2). Records each
+    # character written while the layout finds the KERNAL mapped in, then lets execution fall
+    # through to the ROM, so the screen output is unaffected. Used for headless
+    # capture of program output.
+    class Chrout
+      ADDRESS = 0xffd2
+
+      attr_reader :output
+
+      # The KERNAL layout whose mapping the trap checks.
+      attr_writer :layout
+
+      def initialize(cpu:, bus:, layout:)
+        @cpu = cpu
+        @bus = bus
+        @layout = layout
+        @output = +""
+      end
+
+      def call
+        @output << ascii(@cpu.a) if @layout.kernal_mapped?(@bus)
+      end
+
+      def inspect
+        "#<#{self.class.name} output=#{@output.inspect}>"
+      end
+
+      private
+
+      def ascii(byte)
+        case byte
+        when 0x0d then "\n"
+        when 0x41..0x5a then (byte + 0x20).chr
+        when 0xc1..0xda then (byte - 0x80).chr
+        when 0x20..0x7e then byte.chr
+        else ""
+        end
+      end
+    end
+  end
+end

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

data/lib/badline/kernal_trap/dos/channel.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class DOS
+      # One open channel on the virtual drive, holding a file, a block buffer
+      # or the command channel's status message. It gives out one byte at a
+      # time and flags the last one, so the bus can raise EOI with it. A
+      # channel cut short by a read error never flags one, and holds the
+      # error for the drive to report once its bytes run out.
+      class Channel
+        attr_accessor :buffer
+        attr_reader :error, :pointer
+        attr_writer :lead
+
+        def initialize(bytes = [], error: nil, writable: false, base: 0)
+          @base = base
+          replace(bytes)
+          @error = error
+          @writable = writable
+        end
+
+        # A block buffer opened with "#", which reads and writes one of the
+        # drive's buffers in its RAM, so M-R and M-W reach the same bytes. It
+        # hands out the whole block unless a B-R sets a shorter end, and
+        # flags that byte as the last. The DOS opens it with the pointer at 1
+        # and the buffer's number as the byte to send, so the first read
+        # answers with the number and the next one moves on to the third
+        # byte.
+        def self.buffer(memory, number)
+          new(memory.ram, writable: true, base: Memory.buffer_address(number)).tap do |channel|
+            channel.buffer = number
+            channel.rewind(BLOCK_SIZE)
+            channel.pointer = 1
+            channel.lead = number
+          end
+        end
+
+        # A file's bytes, up to the first block its chain can't read. The
+        # drive reads a block ahead before sending the last byte of the one
+        # before, so a bad block holds that byte back too, and a bad first
+        # block or a missing file leaves nothing to send.
+        def self.for_file(storage, name, type)
+          data = storage.read_file(name, type:)
+          return new([], error: [FILE_NOT_FOUND]) unless data
+
+          failure = storage.respond_to?(:read_error) && storage.read_error(name, type:)
+          return new(data) unless failure
+
+          new(data[0, failure[:offset] - 1] || [], error: failure.values_at(:error, :track, :sector))
+        end
+
+        # The file an open names. The drive keeps the first block of the file
+        # a LOAD (secondary address 0) opens at $7E and $026F of its memory,
+        # and a LOAD of a name starting with "*" reopens that file rather than
+        # the first one on the disk. Loaders write the block there with M-W
+        # to load a file the directory doesn't list. A LOAD of "$" reads the
+        # directory as a BASIC program, which a pattern after a colon narrows
+        # to the files it names.
+        def self.for_name(storage, memory, secondary, name, type)
+          return new(storage.directory.bytes(name)) if listing?(storage, secondary, name)
+
+          file = Storage.parse_name(name).first
+          return for_file(storage, file, type) unless secondary.zero? && storage.respond_to?(:first_block)
+
+          last = memory.last_program if name.start_with?("*")
+          return at_block(storage, *last) if last
+
+          block = storage.first_block(file, type:)
+          memory.last_program = block if block
+          for_file(storage, file, type)
+        end
+
+        def self.listing?(storage, secondary, name)
+          secondary.zero? && name.start_with?("$") && storage.respond_to?(:directory)
+        end
+
+        # The file whose chain starts at the block.
+        def self.at_block(storage, track, sector)
+          data = storage.read_file_at(track, sector)
+          data ? new(data) : new([], error: [ILLEGAL_TRACK_OR_SECTOR, track, sector])
+        end
+
+        def replace(bytes, length = bytes.length)
+          @bytes = bytes
+          rewind(length)
+        end
+
+        def rewind(length)
+          @length = length
+          self.pointer = 0
+        end
+
+        def pointer=(position)
+          @pointer = position
+          @lead = nil
+        end
+
+        # A block read into the channel. A buffer channel takes it into its
+        # buffer, a file channel hands it out in place of the file.
+        def load(block, length)
+          return replace(block.dup, length) unless @writable
+
+          @bytes[@base, block.length] = block
+          rewind(length)
+        end
+
+        def writable? = @writable
+
+        # A buffer channel's block, as a block write puts it on the disk.
+        def block = @bytes[@base, BLOCK_SIZE]
+
+        def exhausted?
+          @pointer >= @length
+        end
+
+        # A file that holds nothing but its error never opened.
+        def failed?
+          exhausted? && !@error.nil?
+        end
+
+        # Each byte lands at the pointer, which wraps within the block.
+        def write(bytes)
+          @lead = nil
+          bytes.each do |byte|
+            @bytes[@base + @pointer] = byte
+            @pointer = (@pointer + 1) & 0xff
+          end
+        end
+
+        def read
+          return read_buffer if @writable
+          return if exhausted?
+
+          byte = @lead || @bytes[@base + @pointer]
+          @lead = nil
+          @pointer += 1
+          [byte, exhausted? && !@error]
+        end
+
+        private
+
+        # A buffer never runs out. Past its last byte, which goes out with
+        # EOI, the pointer wraps back to the second, and a pointer set past
+        # the end runs on around the block to it.
+        def read_buffer
+          byte = @lead || @bytes[@base + @pointer]
+          @lead = nil
+          last = @pointer == @length - 1
+          @pointer = last ? 1 : (@pointer + 1) & 0xff
+          [byte, last]
+        end
+      end
+    end
+  end
+end