badline 0.15.1 → 0.16.1

data/lib/badline/frontend/menu/menu_media.rb

@@ -99,13 +99,22 @@ module Badline
         insert(:disk, set[index + step])
       end
 
-      # The extensions of the cartridges the machine takes: .crt, and on
-      # the Plus/4 raw .bin ROM images too.
+      # The extensions of the cartridges the machine takes: .crt, on the
+      # Plus/4 raw .bin ROM images too, and none on the PET.
       def cartridge_extensions
-        extensions = Media::Extensions.of(%i[cartridge])
+        extensions = Media::Extensions.of(@computer.family == :pet ? %i[none] : %i[cartridge])
         @computer.family == :plus4 ? extensions + [Media::Plus4Media::ROM_IMAGE] : extensions
       end
 
+      # The extensions of what goes in device 8: on the PET the 8050's and
+      # 8250's disk images besides the others, and no raw GCR, which only
+      # a serial true drive reads.
+      def disk_extensions
+        return Media::Extensions.of(%i[disk ieee_disk archive disk_list]) if @computer.family == :pet
+
+        Media::Extensions::DEVICE8
+      end
+
       # Swaps the cartridge for the one at `path`, which power cycles the
       # machine, and says whether it went in.
       def attach_cartridge(path)
@@ -117,10 +126,10 @@ module Badline
       # What a save of the machine is named after: the cartridge, the disk,
       # the tape, or BASIC, without the bracketed parts of a file's name. A
       # VIC-20's are named after its disk, or else the machine, and a
-      # Plus/4's after its disk or tape.
+      # Plus/4's or a PET's after its disk or tape.
       def game_name
         vic20 = @computer.family == :vic20
-        name = vic20 || @computer.family == :plus4 ? "" : cartridge_name
+        name = vic20 || %i[plus4 pet].include?(@computer.family) ? "" : cartridge_name
         disk = disk_path
         name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
         name = tape_name if name.empty? && !vic20
@@ -136,14 +145,16 @@ module Badline
       end
 
       # The name the cartridge in the expansion port gives itself, or an
-      # empty one. A VIC-20's or a Plus/4's is the name of the file it came
-      # from: a .crt's own, or else the file's. A Plus/4 names each of its
+      # empty one. A VIC-20 keeps its own (Vic20#cartridge_name). A Plus/4's
+      # is the name of the file it came from: a .crt's own, or else the
+      # file's. It names each of its
       # cartridges with a ROM in, and a slot filled from elsewhere, such as
       # a snapshot, by the slot.
       def cartridge_name
         case @computer.family
         when :plus4 then @computer.cartridge_slots.map { |slot| slot_name(slot) }.uniq.join(", ")
-        when :vic20 then named? ? @names.fetch("", "") : ""
+        when :vic20 then @computer.cartridge_name
+        when :pet then ""
         else
           cartridge = @computer.address_bus.cartridge
           cartridge.nil? ? "" : cartridge.name
@@ -200,28 +211,16 @@ module Badline
 
       def slot_name(slot) = named? ? @names.fetch(slot, slot.upcase) : slot.upcase
 
-      # Keeps the name of the cartridge at `path` in `computer` by the
-      # slots it fills: a Plus/4's by xplus4's names, a raw image's in
-      # `slot` if it names one, and a VIC-20's in the one slot "". Other
-      # media, and other machines' cartridges, leave the names alone.
+      # Keeps the name of the cartridge at `path` in a Plus/4 by the slots
+      # it fills, by xplus4's names, a raw image's in `slot` if it names
+      # one. Other media, and other machines' cartridges, leave the names
+      # alone.
       def note_cartridge(computer, path, slot)
-        case computer.family
-        when :plus4
-          return unless Media.kind(computer, path) == :cartridge
-
-          name = file_name(path)
-          Media::Plus4Media.cartridge_chips(path, slot: slot.empty? ? nil : slot).each do |chip|
-            @names["c#{chip.bank + 1}#{chip.address < 0xc000 ? 'lo' : 'hi'}"] = name
-          end
-        when :vic20 then @names[""] = file_name(path) if vic20_cartridge?(path)
-        end
-      end
+        return unless computer.family == :plus4 && Media.kind(computer, path) == :cartridge
 
-      def vic20_cartridge?(path)
-        case Media::Extensions.kind(path)
-        when :cartridge then true
-        when :program then File.file?(path) && !Media::Vic20Cartridge.chips(path, Media.program_bytes(path)).nil?
-        else false
+        name = file_name(path)
+        Media::Plus4Media.cartridge_chips(path, slot: slot.empty? ? nil : slot).each do |chip|
+          @names["c#{chip.bank + 1}#{chip.address < 0xc000 ? 'lo' : 'hi'}"] = name
         end
       end
 

data/lib/badline/frontend/menu/menu_pages.rb

@@ -85,6 +85,9 @@ module Badline
       # Whether the machine is a C128, whose F8 switches its screens.
       def c128? = @computer.family == :c128
 
+      # Whether the machine is a PET, whose ports page shows its keyboard.
+      def pet? = @computer.family == :pet
+
       private
 
       def vic20? = @computer.family == :vic20
@@ -122,6 +125,8 @@ module Badline
       end
 
       def draw_expansion
+        return draw_pet_memory if pet?
+
         info("CARTRIDGE", @media.cartridge_name)
         return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
 
@@ -151,6 +156,21 @@ module Badline
         toggle(plus4? ? "SID CARD" : "SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
       end
 
+      # The PET's memory: its RAM, the 8096's 64K board, and the 8296's
+      # 128K with the jumpers that put RAM under its ROMs.
+      def draw_pet_memory
+        model = @computer.model
+        return draw_8296_memory if model.cbm8296?
+
+        info("RAM", "#{@computer.ram_kb}K")
+        info("EXPANSION RAM", model.expansion ? "64K BOARD" : "")
+      end
+
+      def draw_8296_memory
+        info("RAM", "128K, 64K OF IT BANKED")
+        info("JUMPERS", @computer.jumpers.join(", ").upcase)
+      end
+
       # Saving now and by name, loading a named save, and the quicksaves
       # and autosaves, newest first, which a press loads.
       def draw_snapshots
@@ -166,10 +186,12 @@ module Badline
         end
       end
 
-      # The C128 names its model and the mode it runs in first, and the
-      # Plus/4 its model and RAM, and its RAM expansion if it has one.
+      # The C128 names its model and the mode it runs in first, the Plus/4
+      # and the PET their model and RAM, and the Plus/4 its RAM expansion if
+      # it has one.
       def draw_power
         info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
+        info("MACHINE", @computer.model_label) if pet?
         if plus4?
           info("MACHINE", @computer.model_label)
           expansion = @computer.ram_expansion_label

data/lib/badline/frontend/menu/menu_ports.rb

@@ -5,18 +5,28 @@ module Badline
     # The pause menu's PORTS page, which MenuPages draws: what each C64
     # control port has plugged in, a joystick or a pot device, and whether
     # the keys type or drive the joysticks. The VIC-20 has one port, a
-    # joystick's, and the Plus/4 two joysticks and no pot devices.
+    # joystick's, and the Plus/4 two joysticks and no pot devices. The PET
+    # has no ports, and the page, KEYBOARD there, says where its keys are
+    # instead.
     module MenuPorts
       PORT_DEVICES = %i[joystick mouse paddles].freeze
       PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
       PORT_ACTIONS = [%i[port1_joystick port1_mouse port1_paddles], %i[port2_joystick port2_mouse port2_paddles]].freeze
       POTS = [%i[none mouse1 paddles1], %i[none mouse2 paddles2]].freeze
 
+      # Where the PET's keys without a character of their own are, on both
+      # keyboards, and then on the graphics one and on the business one.
+      PET_KEYS = ["PAGE DOWN: RUN/STOP", "HOME: CLR/HOME", "BACKSPACE: INST/DEL", "CTRL: RVS",
+                  "ARROWS: CURSOR", "^: UP ARROW", "_: LEFT ARROW"].freeze
+      PET_GRAPHICS_KEYS = ["ESC: RUN/STOP", "SHIFT+LETTER: GRAPHIC", "ALT+SYMBOL: GRAPHIC"].freeze
+      PET_BUSINESS_KEYS = ["ESC: ESC", "TAB: TAB", "PAGE UP: REPEAT", "KEYPAD: KEYPAD", "ALT+KEY: SHIFT+KEY"].freeze
+
       private
 
       def draw_ports
         return draw_vic20_port if @computer.family == :vic20
         return draw_plus4_ports if @computer.family == :plus4
+        return draw_pet_keys if @computer.family == :pet
 
         toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
         toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
@@ -49,6 +59,17 @@ module Badline
         info("WASD, LEFT SHIFT", "JOYSTICK #{3 - arrows}")
       end
 
+      # The PET's keyboard, whose keys type the characters on the host's
+      # (PETKeyboard), and the keys that stand for the rest of its keys.
+      def draw_pet_keys
+        business = @computer.model.keyboard == :business
+        info("KEYBOARD", business ? "BUSINESS" : "GRAPHICS")
+        (PET_KEYS + (business ? PET_BUSINESS_KEYS : PET_GRAPHICS_KEYS)).each do |line|
+          @painter.text(@left, @top, line, MenuTheme::TEXT)
+          @top += MenuPages::LINE
+        end
+      end
+
       # The toggle between the keyboard named and the joysticks, and
       # whether the keys drive the joysticks.
       def draw_keys(keyboard)

data/lib/badline/frontend/menu/pause_menu.rb

@@ -238,6 +238,7 @@ module Badline
       def draw_sections
         top = @top + 32
         SECTIONS.each_with_index do |name, index|
+          name = "KEYBOARD" if PAGES[index] == :ports && @pages.pet?
           @buttons.plain(@left + 6, top, name.ljust(14), PAGES[index], on: index == @section)
           top += Buttons::HEIGHT + 2
         end

data/lib/badline/frontend/pet_keyboard.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The host's keys on a PET's key matrix, by the character each types
+    # (Keys.pet_key), so the host's " types the PET's " on either keyboard.
+    #
+    # The PET's SHIFT follows the host's, except while a key down needs it
+    # one way to type its character: then it is held that way until the
+    # key goes up, the last such key deciding.
+    #
+    # With either Alt down, a key that types a character presses the PET
+    # key its unshifted character is on with the PET's SHIFT, so the
+    # graphics on the graphics keyboard's symbol keys can be typed.
+    class PETKeyboard
+      LSHIFT = 225
+      RSHIFT = 229
+      LALT = 226
+      RALT = 230
+
+      # +layout+ is the PET's keyboard, :graphics or :business.
+      def initialize(keyboard, layout)
+        @keyboard = keyboard
+        @layout = layout
+        @held = {}
+        @left_shift = false
+        @right_shift = false
+        @left_alt = false
+        @right_alt = false
+        @forced = -1
+        @forced_shift = false
+      end
+
+      def key(scancode, down)
+        if [LSHIFT, RSHIFT].include?(scancode)
+          shift_key(scancode, down)
+        elsif [LALT, RALT].include?(scancode)
+          alt_key(scancode, down)
+        elsif down
+          key_down(scancode)
+        else
+          key_up(scancode)
+        end
+      end
+
+      # Lets go of every key, SHIFT among them.
+      def release_all
+        @held.each_value { |key| @keyboard.release(key) }
+        @held = {}
+        @left_shift = false
+        @right_shift = false
+        @left_alt = false
+        @right_alt = false
+        @forced = -1
+        sync_shift
+      end
+
+      private
+
+      def key_down(scancode)
+        key_up(scancode) if @held.key?(scancode)
+        key, shift = alt? ? shifted_key(scancode) : Keys.pet_key(scancode, shifted?, @layout)
+        return if key == :none
+
+        unless shift == :host
+          @forced = scancode
+          @forced_shift = shift == :on
+        end
+        sync_shift
+        @held[scancode] = key
+        @keyboard.press(key)
+      end
+
+      def key_up(scancode)
+        key = @held.delete(scancode)
+        return if key.nil?
+
+        @keyboard.release(key)
+        return unless @forced == scancode
+
+        @forced = -1
+        sync_shift
+      end
+
+      def shift_key(scancode, down)
+        if scancode == LSHIFT
+          @left_shift = down
+        else
+          @right_shift = down
+        end
+        sync_shift
+      end
+
+      def alt_key(scancode, down)
+        if scancode == LALT
+          @left_alt = down
+        else
+          @right_alt = down
+        end
+      end
+
+      # The PET key for the scancode with Alt down: for a letter or a key
+      # that types a character, the key its unshifted character is on, with
+      # SHIFT, and for any other key the one it presses without Alt.
+      def shifted_key(scancode)
+        key, shift = Keys.pet_key(scancode, false, @layout)
+        return [key, shift] if key == :none
+        return [key, shift] unless scancode.between?(4, 29) || Keys::US_CHARACTERS.key?(scancode)
+
+        [key, :on]
+      end
+
+      def shifted? = @left_shift || @right_shift
+
+      def alt? = @left_alt || @right_alt
+
+      def sync_shift
+        shift = @forced == -1 ? shifted? : @forced_shift
+        @keyboard.release(:lshift)
+        @keyboard.press(:lshift) if shift
+      end
+    end
+  end
+end

data/lib/badline/frontend/screens.rb

@@ -71,7 +71,8 @@ module Badline
         else
           timing = @computer.timing
           @screen = Screen.new(@computer.video, timing.crop,
-                               pixel_width: timing.pixel_width, frame_lines: timing.lines_per_frame)
+                               pixel_width: timing.pixel_width, dots: timing.dots,
+                               frame_lines: timing.lines_per_frame)
         end
       end
 

data/lib/badline/frontend/timeline.rb

@@ -39,19 +39,22 @@ module Badline
       def self.page?(name) = name.empty? || PauseMenu::PAGES.any? { |page| page.to_s == name }
 
       # Whether the family's machine has a key of the name. The Plus/4 has
-      # no RESTORE.
+      # no RESTORE, and the PET neither that nor joysticks.
       def self.key?(name, family)
-        (name == "restore" && family != :plus4) || (family == :c128 && LOCKS.include?(name)) ||
-          !keyboard_key(name, family).nil? || !joystick_direction(name).nil?
+        pet = family == :pet
+        (name == "restore" && !pet && family != :plus4) || (family == :c128 && LOCKS.include?(name)) ||
+          !keyboard_key(name, family).nil? || (!pet && !joystick_direction(name).nil?)
       end
 
       # The family's Keyboard key for a name such as space, return or a,
-      # on the C128 esc or keypad1, or on the Plus/4 help or crsr_up. The
-      # shifted cursor keys, such as cursor_up, are the C64's and the
-      # C128's.
+      # on the C128 esc or keypad1, on the Plus/4 help or crsr_up, or on
+      # the PET rvs or kp1, of either of its keyboards. The shifted cursor
+      # keys, such as cursor_up, are the C64's and the C128's.
       def self.keyboard_key(name, family)
+        return nil if name == "none"
+
         key = keyboard_matrix(family).flatten.find { |candidate| candidate.to_s == name }
-        return key unless key.nil? && family != :plus4
+        return key unless key.nil? && !%i[plus4 pet].include?(family)
 
         Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name }
       end
@@ -60,6 +63,7 @@ module Badline
         case family
         when :c128 then C128::KEYBOARD_MATRIX
         when :plus4 then Plus4::KeyboardPort::MATRIX
+        when :pet then PET::KeyboardPorts::GRAPHICS_MATRIX + PET::KeyboardPorts::BUSINESS_MATRIX
         else Input::Keyboard::C64_MATRIX
         end
       end
@@ -223,8 +227,11 @@ module Badline
         puts "Ejected the #{what}"
       end
 
-      # Whether there's one in to eject. A VIC-20 has no cartridge to take out yet.
-      def ejectable?(computer, what) = (computer.family != :vic20 || what != "cartridge") && inserted?(computer, what)
+      # Whether there's one in to eject. A VIC-20 has no cartridge to take
+      # out yet, and a PET no expansion port.
+      def ejectable?(computer, what)
+        (what != "cartridge" || !%i[vic20 pet].include?(computer.family)) && inserted?(computer, what)
+      end
 
       def inserted?(computer, what)
         return !computer.datasette.tape.nil? if what == "tape"

data/lib/badline/frontend.rb

@@ -15,6 +15,7 @@ require "badline/frontend/audio_device"
 require "badline/frontend/sound"
 require "badline/frontend/pacer"
 require "badline/frontend/frame_report"
+require "badline/frontend/pet_keyboard"
 require "badline/frontend/controls"
 require "badline/frontend/pad_port"
 require "badline/frontend/gamepads"

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

@@ -19,7 +19,7 @@ module Badline
             @channels.close(secondary)
             return report(FILE_EXISTS)
           end
-          return refuse_write(secondary) unless writable_disk?
+          return refuse_write(secondary) unless writable_disk? || channel_save?(secondary)
 
           open_writer(secondary, WriteFile.new(file, type || :seq, mode: replace ? :replace : :write))
         end
@@ -41,6 +41,8 @@ module Badline
 
         def writable_disk? = @storage.respond_to?(:writable?) && @storage.writable?
 
+        def channel_save?(secondary) = @channel_saves && secondary == 1 && saves?
+
         # Runs a write to the disk and reports how it went. Returns whether
         # the disk took it.
         def writing

data/lib/badline/kernal_trap/dos.rb

@@ -68,7 +68,12 @@ module Badline
 
       # A drive powers on reporting its DOS version, as a reset does. It
       # can take the RAM of a drive it replaces, and initializes its disk.
-      def initialize(storage, memory = Memory.new)
+      # With +channel_saves+, SAVE's channel, secondary address 1, takes a
+      # program for storage that saves only whole files, such as a host
+      # directory, and saves it when the channel closes: a PET's SAVE sends
+      # it through the bus with no trap of its own.
+      def initialize(storage, memory = Memory.new, channel_saves: false)
+        @channel_saves = channel_saves
         @channels = Channels.new
         @status = Status.new
         @memory = memory

data/lib/badline/kernal_trap/frames.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # The frames a drive takes and sends through the traps on a KERNAL's
+    # eight bus primitives, shared by the serial bus's (Serial) and the
+    # IEEE-488 bus's (IEEE): the traps going in and out, the bytes a
+    # listener gathers into a frame for the DOS, the bytes a talker sends,
+    # and the status they leave. The class that includes it, with Steps,
+    # answers each primitive and keeps @dos, @listening, @talking,
+    # @listen_channel, @talk_channel, @frame and @buffer.
+    module Frames
+      # Frame type in the high nibble of the secondary address
+      OPEN = 0xf0
+      CLOSE = 0xe0
+
+      # ST bits
+      DEVICE_NOT_PRESENT = 0x80
+      EOI = 0x40
+      READ_TIMEOUT = 0x02
+
+      NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
+
+      def install
+        routines.each do |address, routine|
+          @cpu.install_trap(address) { call_routine(routine) if kernal_mapped? }
+        end
+        self
+      end
+
+      # Takes the traps out again, so the KERNAL's own routines run.
+      def uninstall
+        routines.each_key { |address| @cpu.remove_trap(address) }
+      end
+
+      private
+
+      def routines
+        {
+          @layout.talk => :talk,
+          @layout.listen => :listen,
+          @layout.second => :second,
+          @layout.tksa => :tksa,
+          @layout.ciout => :ciout,
+          @layout.untalk => :untalk,
+          @layout.unlisten => :unlisten,
+          @layout.acptr => :acptr
+        }
+      end
+
+      def call_routine(routine)
+        case routine
+        when :talk then talk
+        when :listen then listen
+        when :second then second
+        when :tksa then tksa
+        when :ciout then ciout
+        when :untalk then untalk
+        when :unlisten then unlisten
+        when :acptr then acptr
+        end
+      end
+
+      # CIOUT holds each byte back until the next one, or the UNLISTEN,
+      # comes, so the first byte of a frame sends nothing.
+      def ciout
+        return unless @listening
+
+        time_serial_byte(Routine::ISOUR_TIMEOUT) if !@buffer.empty? && accepted?
+        @buffer << @cpu.a
+        update_status(DEVICE_NOT_PRESENT) unless accepted?
+        @cpu.status.carry = false
+        return_to_caller
+      end
+
+      # The drive acknowledges every byte of an open or close frame, but
+      # takes data only on a channel it has open. Otherwise nothing holds
+      # the data line when a byte starts, so the KERNAL finds no device.
+      def accepted?
+        [OPEN, CLOSE].include?(@frame) || @dos.listening?(@listen_channel)
+      end
+
+      # UNLSN and UNTLK end by releasing the bus, and leave the port's last
+      # read in the accumulator.
+      def release_bus
+        @cpu.a = @layout.release_serial_lines(@bus)
+        @cpu.status.negative = @cpu.a.anybits?(0x80)
+        @cpu.status.zero = @cpu.a.zero?
+        return_to_caller
+      end
+
+      def deliver_frame
+        return unless @listen_channel
+
+        case @frame
+        when OPEN then @dos.open(@listen_channel, @buffer.pack("C*"))
+        when CLOSE then @dos.close(@listen_channel)
+        else @dos.write(@listen_channel, @buffer)
+        end
+        @buffer = []
+      end
+
+      def received
+        byte, eoi = @dos.read(@talk_channel)
+        return NO_DATA unless byte
+
+        [byte, eoi ? EOI : 0]
+      end
+
+      def update_status(bits)
+        return if bits.zero?
+
+        @bus.poke(zero_page.status, @bus.peek(zero_page.status) | bits)
+      end
+    end
+  end
+end