badline 0.15.0 → 0.16.0

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

@@ -10,17 +10,29 @@ module Badline
     # wrong for the page to show.
     class MenuMedia
       attr_reader :problem
-      attr_writer :computer
 
       # Takes the disk set from the command line's `media_path` when it's a
-      # list.
-      def initialize(media_path, writable)
+      # list, and the names of the cartridges it and `cartridges`, the
+      # Plus/4's ROM images by slot (Options#cartridges), put in the first
+      # machine.
+      def initialize(media_path, writable, cartridges)
         @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
         @set = []
         @problem = ""
         @computer = nil
+        @command_line = cartridges.map { |slot, path| [slot, path] } + [["", media_path]]
+        @names = {}
+        @named = nil
+      end
+
+      def computer=(computer)
+        @computer = computer
+        return unless @named.nil?
+
+        @command_line.each { |slot, path| note_cartridge(computer, path.dup, slot) }
+        @named = computer
       end
 
       def writable? = @writable
@@ -87,26 +99,37 @@ 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)
-        succeeds? { Media.attach(@computer, path) }
+        attached = cartridge_succeeds? { Media.attach(@computer, path) }
+        note_cartridge(@computer, path, "") if attached
+        attached
       end
 
       # 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
@@ -122,26 +145,38 @@ module Badline
       end
 
       # The name the cartridge in the expansion port gives itself, or an
-      # empty one. A Plus/4's names the slots with a ROM in them.
+      # 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
-        return @computer.cartridge_slots.map(&:upcase).join(", ") if @computer.family == :plus4
-
-        cartridge = @computer.address_bus.cartridge
-        cartridge.nil? ? "" : cartridge.name
+        case @computer.family
+        when :plus4 then @computer.cartridge_slots.map { |slot| slot_name(slot) }.uniq.join(", ")
+        when :vic20 then @computer.cartridge_name
+        when :pet then ""
+        else
+          cartridge = @computer.address_bus.cartridge
+          cartridge.nil? ? "" : cartridge.name
+        end
       end
 
       # Takes the cartridge out with the power off.
-      def remove_cartridge = MediaSlots.remove_cartridge(@computer)
+      def remove_cartridge
+        @names = {}
+        MediaSlots.remove_cartridge(@computer)
+      end
 
       # A new machine started on `path`, as the command line would, or nil
       # when it won't start.
       def start(options, path)
         computer = nil
-        started = succeeds? do
-          computer = Frontend.start(options, path, @writable)
-          list(path)
+        if Media.kind(@computer, path) == :cartridge
+          cartridge_succeeds? { computer = started(options, path) }
+        else
+          succeeds? { computer = started(options, path) }
         end
-        started ? computer : nil
+        @problem.empty? ? computer : nil
       end
 
       private
@@ -153,6 +188,48 @@ module Badline
         @problem.empty?
       end
 
+      # Runs the block as #succeeds? does, keeping a cartridge's chip in a
+      # bank or slot the machine doesn't map as the problem too.
+      def cartridge_succeeds?(&)
+        @problem = Frontend.cartridge_problem(&)
+        @problem.empty?
+      end
+
+      # The machine Frontend.start started on `path`, with the names of
+      # the cartridges in it noted.
+      def started(options, path)
+        computer = Frontend.start(options, path, @writable)
+        list(path)
+        @names = {}
+        options.cartridges.each { |slot, image| note_cartridge(computer, image.dup, slot) }
+        note_cartridge(computer, path, "")
+        @named = computer
+        computer
+      end
+
+      def named? = @computer.equal?(@named)
+
+      def slot_name(slot) = named? ? @names.fetch(slot, slot.upcase) : slot.upcase
+
+      # 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)
+        return unless computer.family == :plus4 && 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
+      end
+
+      # A .crt's own name, or else the file's, without its extension.
+      def file_name(path)
+        name = Media::Extensions.kind(path) == :cartridge ? Storage::CRTFile.new(path, machine: nil).name : ""
+        name.empty? ? File.basename(path, File.extname(path)) : name
+      end
+
       # Keeps `path` as the list the set comes from, if it's a list.
       def list(path)
         return unless Media::DiskList.list?(path)

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

@@ -29,7 +29,7 @@ module Badline
         @recent = []
         @painter = painter
         @buttons = buttons
-        @media = MenuMedia.new(media_path, options.writable?)
+        @media = MenuMedia.new(media_path, options.writable?, options.cartridges)
         @reu_kb = options.reu
         @computer = nil
         @controls = nil
@@ -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,9 +125,11 @@ module Badline
       end
 
       def draw_expansion
-        return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
+        return draw_pet_memory if pet?
 
         info("CARTRIDGE", @media.cartridge_name)
+        return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
+
         row("INSERT...", :insert_cartridge)
         row("REMOVE", :remove_cartridge)
         return if plus4?
@@ -137,7 +142,8 @@ module Badline
         info("RAM EXPANSION", "REU, #{@reu_kb} KB")
       end
 
-      # The SID's model is a setting, and other sound chips have none.
+      # The SID's model is a setting, the C64's SID's or a Plus/4's SID
+      # card's, and other sound chips have none.
       def draw_sound
         if @sound.on?
           toggle("OUTPUT", :output, [%w[ON MUTED], %i[sound_on mute], @sound.muted? ? 1 : 0])
@@ -147,7 +153,13 @@ module Badline
         model = @computer.sound_source.model
         return unless SID_MODELS.include?(model)
 
-        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
+        toggle(plus4? ? "SID CARD" : "SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
+      end
+
+      # The PET's memory: its RAM, and the 8096's 64K board.
+      def draw_pet_memory
+        info("RAM", "#{@computer.ram_kb}K")
+        info("EXPANSION RAM", @computer.model.expansion ? "64K BOARD" : "")
       end
 
       # Saving now and by name, loading a named save, and the quicksaves
@@ -165,11 +177,17 @@ module Badline
         end
       end
 
-      # The C128 names its model and the mode it runs in first, and the
-      # Plus/4 its model and RAM.
+      # 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 plus4?
+        info("MACHINE", @computer.model_label) if pet?
+        if plus4?
+          info("MACHINE", @computer.model_label)
+          expansion = @computer.ram_expansion_label
+          info("RAM EXPANSION", expansion) if expansion
+        end
         row("RESET", :reset)
         row("POWER CYCLE", :power_cycle)
         skip

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/player/player_controller.rb

@@ -15,7 +15,8 @@ module Badline
     # way: #wait handles the window's clicks, keys and drops between frames
     # and redraws it at the display's pace. The SID model buttons switch
     # the chips playing on the spot, and each tune after it starts on the
-    # same choice. AUTO gives each of a tune's SIDs its own model.
+    # same choice. AUTO gives each of a tune's SIDs its own model. It
+    # quits once it has drawn `frames` frames (--frames), unless that's 0.
     class PlayerController < Audio::Terminal
       FRAME = 1.0 / 50
 
@@ -30,8 +31,10 @@ module Badline
         Keys::TAB => :view, 6 => :chip
       }.freeze
 
-      def initialize(input:, output:)
-        super
+      def initialize(input:, output:, frames: 0)
+        super(input:, output:)
+        @frame_limit = frames
+        @frames = 0
         @screen = PlayerScreen.new
         @player = nil
         @tune_file = nil
@@ -73,7 +76,10 @@ module Badline
         actions = poll
         deadline = now + seconds
         loop do
-          draw if now >= @next_draw
+          if now >= @next_draw
+            draw
+            actions << :quit if @frames == @frame_limit
+          end
           left = deadline - now
           break if left <= 0 || !actions.empty?
 
@@ -211,6 +217,7 @@ module Badline
 
       def draw
         @next_draw = now + FRAME
+        @frames += 1
         @screen.draw(@state, @player, @history, @tune_file, SIDTune::STIL::Credit.at(@credits, @state.played))
       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