badline 0.13.0 → 0.14.0

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,11 +38,16 @@ 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 = Input::Keyboard.new.matrix.flatten.find { |candidate| candidate.to_s == name }
+      # 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
 
@@ -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/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

@@ -5,3 +5,4 @@ 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/dos/channel.rb

@@ -81,33 +81,6 @@ module Badline
           data ? new(data) : new([], error: [ILLEGAL_TRACK_OR_SECTOR, track, sector])
         end
 
-        # Reads what save_state wrote after the flag that marks a file open
-        # for writing (Channels.channel_from_state). A buffer channel
-        # takes its block in `ram`, the drive's RAM, again.
-        def self.from_state(input, ram)
-          new.tap { |channel| channel.load_state(input, ram) }
-        end
-
-        # A buffer channel's bytes are the drive's RAM, which the drive
-        # writes itself.
-        def save_state(out)
-          out.boolean(false).boolean(@writable).int(@base).int(@length).int(@pointer)
-          out.optional_int(@lead).optional_int(@buffer).boolean(!@error.nil?)
-          out.ints(@error) if @error
-          out.blob(@bytes) unless @writable
-        end
-
-        def load_state(input, ram)
-          @writable = input.boolean?
-          @base = input.int
-          @length = input.int
-          @pointer = input.int
-          @lead = input.optional_int
-          @buffer = input.optional_int
-          @error = input.boolean? ? input.ints : nil
-          @bytes = @writable ? ram : input.blob
-        end
-
         def replace(bytes, length = bytes.length)
           @bytes = bytes
           rewind(length)

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

@@ -22,31 +22,6 @@ module Badline
 
         def clear = @channels.clear
 
-        # Each open channel with its secondary address, in the order they
-        # opened.
-        def save_state(out)
-          out.int(@channels.length)
-          @channels.each do |secondary, channel|
-            out.int(secondary)
-            channel.save_state(out)
-          end
-        end
-
-        # Buffer channels take their block in the drive's RAM again.
-        def load_state(input, memory)
-          @channels.clear
-          input.int.times do
-            secondary = input.int
-            @channels[secondary] = Channels.channel_from_state(input, memory.ram)
-          end
-        end
-
-        # A channel save_state wrote: a file open for writing, or a Channel
-        # whose buffer, if it has one, is in `ram`.
-        def self.channel_from_state(input, ram)
-          input.boolean? ? WriteFile.from_state(input) : Channel.from_state(input, ram)
-        end
-
         # Opens a buffer channel on the buffer a "#n" name asks for, or on
         # the highest free one. Returns nil when that buffer isn't free,
         # which leaves a channel asking again for its own buffer open.

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

@@ -62,15 +62,6 @@ module Badline
           load_buffer(Channels::BAM_BUFFER, block) if block
         end
 
-        def save_state(out)
-          out.blob(@ram).boolean(@bam)
-        end
-
-        def load_state(input)
-          input.blob_into(@ram)
-          @bam = input.boolean?
-        end
-
         # Whether the BAM has been read since the last reset.
         def bam? = @bam
 

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

@@ -37,14 +37,6 @@ module Badline
           nil
         end
 
-        def save_state(out)
-          @channel.save_state(out)
-        end
-
-        def load_state(input)
-          @channel = Channels.channel_from_state(input, [])
-        end
-
         def replace(bytes)
           @channel.replace(bytes)
         end

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

@@ -14,14 +14,6 @@ module Badline
         TYPES = %i[del seq prg usr rel].freeze
         MODES = %i[write replace append].freeze
 
-        # Reads what save_state wrote after the flag that marks a file
-        # open for writing.
-        def self.from_state(input)
-          name = input.string
-          type = TYPES.fetch(input.int).to_sym
-          new(name, type, mode: MODES.fetch(input.int).to_sym).tap { |file| file.load_state(input) }
-        end
-
         def initialize(name, type, mode: :write)
           @name = name
           @type = type
@@ -29,16 +21,6 @@ module Badline
           @bytes = []
         end
 
-        def save_state(out)
-          out.boolean(true).string(@name).int(TYPES.index(@type)).int(MODES.index(@mode))
-          out.blob(@bytes).optional_int(@buffer)
-        end
-
-        def load_state(input)
-          @bytes = input.blob
-          @buffer = input.optional_int
-        end
-
         def write(bytes) = @bytes.concat(bytes)
 
         def writable? = true

data/lib/badline/kernal_trap/dos.rb

@@ -147,25 +147,6 @@ module Badline
       # vector, as U: does.
       def reset! = reset(cold: true)
 
-      # The mounted storage's setup (Snapshot::StorageSetup), then the drive's
-      # RAM, its status and its open channels.
-      def save_state(out)
-        Snapshot::StorageSetup.write(@storage, out)
-        out.marker("TRAP DRIVE")
-        @memory.save_state(out)
-        @status.save_state(out)
-        @channels.save_state(out)
-      end
-
-      # Takes the state after the storage's setup, into a drive mounted on
-      # the reopened storage.
-      def load_state(input)
-        input.marker("TRAP DRIVE")
-        @memory.load_state(input)
-        @status.load_state(input)
-        @channels.load_state(input, @memory)
-      end
-
       # Returns the next byte and whether it is the channel's last, or nil
       # when there is nothing left to send.
       def read(secondary)

data/lib/badline/kernal_trap/file_routine.rb

@@ -6,17 +6,17 @@ module Badline
       private
 
       def active?
-        kernal_mapped? && @bus.peek(0xba) == DEVICE
+        kernal_mapped? && @bus.peek(zero_page.device) == DEVICE
       end
 
       def filename
         Storage.strip_drive_prefix(full_filename)
       end
 
-      # Filename pointer at $BB/$BC, length at $B7
+      # The file name FNADR points to, FNLEN bytes long.
       def full_filename
-        pointer = uint16(@bus.peek(0xbb), @bus.peek(0xbc))
-        bytes = Array.new(@bus.peek(0xb7)) do |i|
+        pointer = peek_word(zero_page.filename_address)
+        bytes = Array.new(@bus.peek(zero_page.filename_length)) do |i|
           @layout.filename_byte(@bus, (pointer + i) & 0xffff)
         end
         Storage.ascii(bytes)

data/lib/badline/kernal_trap/keyed_state.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class DOS
+      class Channel
+        # A channel's fields under `prefix`: whether it is a buffer in the
+        # drive's RAM, where it starts and ends, the pointer, the byte it
+        # leads with and its buffer's number, the error it reports once its
+        # bytes run out, and a file's bytes.
+        def save_fields(out, prefix)
+          out.text("#{prefix}kind", "channel").bool("#{prefix}writable", @writable).int("#{prefix}base", @base)
+          out.int("#{prefix}length", @length).int("#{prefix}pointer", @pointer).optional_int("#{prefix}lead", @lead)
+          out.optional_int("#{prefix}buffer", @buffer)
+          error = @error
+          out.ints("#{prefix}error", error) if error
+          out.bytes("#{prefix}bytes", @bytes) unless @writable
+        end
+
+        # A buffer channel's bytes are the drive's `ram`.
+        def load_fields(input, prefix, ram)
+          @writable = input.bool("#{prefix}writable", false)
+          @base = input.int("#{prefix}base", 0)
+          @length = input.int("#{prefix}length", 0)
+          @pointer = input.int("#{prefix}pointer", 0)
+          @lead = input.optional_int("#{prefix}lead")
+          @buffer = input.optional_int("#{prefix}buffer")
+          error = input.ints("#{prefix}error", [])
+          @error = error.empty? ? nil : error.dup
+          @bytes = @writable ? ram : input.bytes("#{prefix}bytes", "".b).bytes
+          self
+        end
+      end
+
+      class WriteFile
+        # A file open for writing, under `prefix`: its name, type and mode,
+        # the bytes written so far and the byte held back.
+        def save_fields(out, prefix)
+          out.text("#{prefix}kind", "write_file").bytes("#{prefix}name", @name.b).text("#{prefix}type", @type.to_s)
+          out.text("#{prefix}mode", @mode.to_s).bytes("#{prefix}bytes", @bytes).optional_int("#{prefix}held", @buffer)
+        end
+
+        def self.from_fields(input, prefix)
+          type = input.choice("#{prefix}type", TYPES.map(&:to_s), "prg")
+          mode = input.choice("#{prefix}mode", MODES.map(&:to_s), "write")
+          new(input.bytes("#{prefix}name", "".b), TYPES.find { |each| each.to_s == type } || :prg,
+              mode: MODES.find { |each| each.to_s == mode } || :write).tap do |file|
+            file.load_fields(input, prefix)
+          end
+        end
+
+        def load_fields(input, prefix)
+          @bytes = input.bytes("#{prefix}bytes", "".b).bytes
+          @buffer = input.optional_int("#{prefix}held")
+        end
+      end
+
+      class Channels
+        # The channels open, by secondary address, each under channel<SA>.
+        def save_fields(out)
+          out.ints("channels", @channels.keys)
+          @channels.each { |secondary, channel| channel.save_fields(out, "channel#{secondary}.") }
+        end
+
+        def load_fields(input, ram)
+          @channels.clear
+          input.ints("channels", []).each do |secondary|
+            @channels[secondary] = Channels.channel_from_fields(input, "channel#{secondary}.", ram)
+          end
+        end
+
+        def self.channel_from_fields(input, prefix, ram)
+          return WriteFile.from_fields(input, prefix) if input.text("#{prefix}kind", "channel") == "write_file"
+
+          Channel.new.load_fields(input, prefix, ram)
+        end
+      end
+
+      class Status
+        # The error channel, under status.
+        def save_fields(out) = @channel.save_fields(out, "status.")
+
+        def load_fields(input)
+          input.choice("status.kind", ["channel"], "channel")
+          @channel = Channel.new.load_fields(input, "status.", [])
+        end
+      end
+
+      class Memory
+        # The drive's RAM, and whether the BAM has been read.
+        def save_fields(out)
+          out.bytes("ram", @ram).bool("bam", @bam)
+        end
+
+        def load_fields(input)
+          input.bytes_into("ram", @ram)
+          @bam = input.bool("bam", @bam)
+        end
+      end
+
+      # The storage device 8 serves.
+      attr_reader :storage
+
+      # The DOS's fields in a keyed snapshot module (BL-TRAPDOS), after the
+      # storage's under storage.*: its RAM, the error channel and the
+      # channels open.
+      def save_fields(out)
+        @memory.save_fields(out)
+        @status.save_fields(out)
+        @channels.save_fields(out)
+      end
+
+      def load_fields(input)
+        @memory.load_fields(input)
+        @status.load_fields(input)
+        @channels.load_fields(input, @memory.ram)
+      end
+    end
+
+    class Serial
+      # The serial trap's fields under `prefix`: whether device 8 listens
+      # or talks, on which channel, the frame it is in and the bytes it has
+      # gathered.
+      def save_fields(out, prefix)
+        out.bool("#{prefix}listening", @listening).bool("#{prefix}talking", @talking)
+        out.optional_int("#{prefix}listen_channel", @listen_channel)
+        out.optional_int("#{prefix}talk_channel", @talk_channel).int("#{prefix}frame", @frame)
+        out.bytes("#{prefix}buffer", @buffer)
+      end
+
+      def load_fields(input, prefix)
+        @listening = input.bool("#{prefix}listening", @listening)
+        @talking = input.bool("#{prefix}talking", @talking)
+        @listen_channel = input.optional_int("#{prefix}listen_channel")
+        @talk_channel = input.optional_int("#{prefix}talk_channel")
+        @frame = input.int("#{prefix}frame", @frame)
+        @buffer = input.bytes("#{prefix}buffer", "".b).bytes
+      end
+    end
+
+    class Save
+      # Whether a SAVE is under way, under `prefix`.
+      def save_fields(out, prefix) = out.bool("#{prefix}saving", @saving)
+
+      def load_fields(input, prefix)
+        @saving = input.bool("#{prefix}saving", @saving)
+      end
+    end
+  end
+end