badline 0.8.0 → 0.10.0

data/lib/badline/frontend/drive_led.rb

@@ -8,8 +8,6 @@ module Badline
     class DriveLed
       WIDTH = 12
       HEIGHT = 4
-      LEFT = Screen::WIDTH - WIDTH - 8
-      TOP = Screen::HEIGHT - HEIGHT - 6
 
       LIT = [0xff, 0x20, 0x20].freeze
       DARK = [0x40, 0x00, 0x00].freeze
@@ -20,11 +18,12 @@ module Badline
         drive ? new(drive) : nil
       end
 
-      # Sets SDL.led_rect to where the LED goes.
-      def self.place
+      # Sets SDL.led_rect to where the LED goes on a screen `width` by
+      # `height`.
+      def self.place(width, height)
         rect = SDL.led_rect
-        SDL.rect_x(rect, LEFT)
-        SDL.rect_y(rect, TOP)
+        SDL.rect_x(rect, width - WIDTH - 8)
+        SDL.rect_y(rect, height - HEIGHT - 6)
         SDL.rect_w(rect, WIDTH)
         SDL.rect_h(rect, HEIGHT)
       end
@@ -37,10 +36,10 @@ module Badline
 
       def color = lit? ? LIT : DARK
 
-      # Fills the LED's rectangle in its colour, then puts back the black
-      # that RenderClear clears with.
-      def draw(renderer)
-        DriveLed.place
+      # Fills the LED's rectangle on a screen `width` by `height` in its
+      # colour, then puts back the black that RenderClear clears with.
+      def draw(renderer, width, height)
+        DriveLed.place(width, height)
         rgb = color
         SDL.SDL_SetRenderDrawColor(renderer, rgb[0], rgb[1], rgb[2], 255)
         SDL.SDL_RenderFillRect(renderer, SDL.led_rect)

data/lib/badline/frontend/frame_rate.rb

@@ -31,10 +31,10 @@ module Badline
 
       attr_reader :base_cycles, :seconds, :refresh, :trim
 
-      # One frame of the region's raster.
-      def self.machine(region)
-        cycles = region.cycles_per_line * region.lines_per_frame
-        new(cycles, cycles.to_f / region.clock_hz, 0, region.clock_hz)
+      # One frame of the machine's raster, from its Timing.
+      def self.machine(timing)
+        cycles = timing.cycles_per_line * timing.lines_per_frame
+        new(cycles, cycles.to_f / timing.clock_hz, 0, timing.clock_hz)
       end
 
       def self.display(refresh, clock_hz)

data/lib/badline/frontend/machine_window.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The emulator's SDL window, its renderer and the streaming texture a
+    # Screen's pixels go into. The renderer's logical size is the screen's,
+    # with each of its pixels `pixel_width` square pixels wide, so the
+    # picture keeps the machine's aspect while the menu and the drive LED
+    # draw in square pixels over it. The window opens at SCALE times that.
+    class MachineWindow
+      SCALE = 2
+      TITLE = "Badline"
+
+      # The logical size, in square pixels.
+      attr_reader :width, :height
+
+      attr_reader :renderer, :texture
+
+      # Opens the window for `screen`, presenting in step with the display
+      # when `vsync`.
+      def initialize(screen, pixel_width, vsync:)
+        abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
+
+        SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
+        SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
+        measure(screen, pixel_width)
+        @window = SDL.SDL_CreateWindow(
+          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED, @width * SCALE, @height * SCALE,
+          SDL::WINDOW_RESIZABLE
+        )
+        flags = SDL::RENDERER_ACCELERATED
+        flags |= SDL::RENDERER_PRESENTVSYNC if vsync
+        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
+        create_texture
+      end
+
+      # The refresh rate of the display the window is on, in Hz.
+      def refresh_rate
+        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
+        SDL.mode_refresh(SDL.display_mode)
+      end
+
+      # Fits the texture, the logical size and the window to another
+      # machine's screen, unless it measures the same.
+      def fit(screen, pixel_width)
+        before = [@width, @height, @texture_width]
+        measure(screen, pixel_width)
+        return if before == [@width, @height, @texture_width]
+
+        SDL.SDL_DestroyTexture(@texture)
+        create_texture
+        SDL.SDL_SetWindowSize(@window, @width * SCALE, @height * SCALE)
+      end
+
+      def upload(screen)
+        SDL.SDL_UpdateTexture(@texture, nil, screen.pixels, screen.row_bytes)
+      end
+
+      # Titles the window, TITLE followed by `tags` in brackets.
+      def title(tags)
+        SDL.SDL_SetWindowTitle(@window, ([TITLE] + tags.map { |tag| "[#{tag}]" }).join(" "))
+      end
+
+      def close
+        SDL.SDL_DestroyTexture(@texture)
+        SDL.SDL_DestroyRenderer(@renderer)
+        SDL.SDL_DestroyWindow(@window)
+        SDL.SDL_Quit
+      end
+
+      private
+
+      def measure(screen, pixel_width)
+        @texture_width = screen.width
+        @width = screen.width * pixel_width
+        @height = screen.height
+      end
+
+      def create_texture
+        SDL.SDL_RenderSetLogicalSize(@renderer, @width, @height)
+        @texture = SDL.SDL_CreateTexture(
+          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, @texture_width, @height
+        )
+      end
+    end
+  end
+end

data/lib/badline/frontend/menu_dialogs.rb

@@ -3,43 +3,57 @@
 module Badline
   module Frontend
     # The pause menu's screens that take over its panel: the file browser
-    # INSERT and Quick open bring up, and the question before a cartridge
-    # or Quick open power cycles the machine. A disk or tape picked goes
-    # straight in.
+    # INSERT, Quick open and LOAD bring up, the question before a cartridge
+    # or Quick open power cycles the machine, and the prompt for a save's
+    # name. A disk or tape picked goes straight in, and a save loads.
     class MenuDialogs
       EXTENSIONS = {
-        disk: PauseMenu::DISKS, tape: %w[.tap], cartridge: %w[.crt],
-        program: %w[.d64 .d71 .d81 .g64 .t64 .tap .crt .prg .p00 .sid]
+        disk: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl], tape: %w[.tap], cartridge: %w[.crt],
+        program: %w[.d64 .d71 .d81 .g64 .t64 .m3u .vfl .tap .crt .prg .p00 .sid], snapshot: %w[.vsf]
       }.freeze
       TITLES = { disk: "INSERT A DISK", tape: "INSERT A TAPE", cartridge: "INSERT A CARTRIDGE",
-                 program: "QUICK OPEN" }.freeze
+                 program: "QUICK OPEN", snapshot: "LOAD A SAVE" }.freeze
 
       ESCAPE = 41
       RETURN = 40
       SPACE = 44
 
-      # The machine Quick open started.
+      # The machine Quick open started or a save loaded.
       attr_reader :computer
 
-      def initialize(painter, buttons, media, options)
+      def initialize(painter, buttons, media, options, snapshots)
         media_path = options.media_path.to_s
         @buttons = buttons
         @media = media
         @options = options
         @browser = FileBrowser.new(painter, buttons)
         @confirmation = Confirmation.new(painter, buttons)
+        @name_field = NameField.new(painter)
+        @snapshots = snapshots
         @browsing = nil
         @browse_from = media_path.empty? ? Dir.pwd : File.dirname(File.expand_path(media_path))
         @computer = nil
       end
 
-      def open? = !@browsing.nil? || @confirmation.open?
+      def open? = !@browsing.nil? || @confirmation.open? || @name_field.open?
 
-      # Opens the browser on the files for `kind`: :disk, :tape, :cartridge
-      # or :program.
+      # Opens the browser on the files for `kind`: :disk, :tape, :cartridge,
+      # :program, or :snapshot, which starts in the saves folder.
       def browse(kind)
         @browsing = kind
-        @browser.open(@browse_from, EXTENSIONS.fetch(kind))
+        @browser.open(kind == :snapshot ? Badline.data_folder("saves") : @browse_from, EXTENSIONS.fetch(kind))
+      end
+
+      # Asks for a save's name, starting from `name`.
+      def ask_name(name) = @name_field.open("SAVE AS", name)
+
+      # Loads the save at `path` into a new machine, and returns :swap, or
+      # nil when it won't load.
+      def load(path)
+        return nil unless @snapshots.load(path)
+
+        @computer = @snapshots.computer
+        :swap
       end
 
       def ask_remove = @confirmation.ask(:remove, @media.cartridge_name)
@@ -61,6 +75,9 @@ module Badline
       # answered yes, or nil.
       def key(scancode)
         return browsed(@browser.key(scancode)) unless @browsing.nil?
+        if @name_field.open? && !@confirmation.open?
+          return named(@name_field.key(scancode, SDL.event_mod(SDL.event).anybits?(SDL::KMOD_SHIFT)))
+        end
         return answer(:cancel) if scancode == ESCAPE
         return answer(@buttons.focus) if [RETURN, SPACE].include?(scancode)
 
@@ -77,8 +94,9 @@ module Badline
 
       def draw(left, top, width)
         return @browser.draw(left, top, width, TITLES.fetch(@browsing)) unless @browsing.nil?
+        return @confirmation.draw(left, top) if @confirmation.open?
 
-        @confirmation.draw(left, top)
+        @name_field.draw(left, top, width)
       end
 
       private
@@ -90,9 +108,10 @@ module Badline
         return nil if picked.nil?
 
         kind = @browsing
-        @browse_from = @browser.directory
+        @browse_from = @browser.directory unless kind == :snapshot
         @browsing = nil
         return nil if picked == :cancel
+        return load(picked) if kind == :snapshot
 
         if %i[disk tape].include?(kind)
           @media.insert(kind, picked)
@@ -102,6 +121,24 @@ module Badline
         nil
       end
 
+      # Saves the machine under the name typed once Return takes it, and
+      # asks first when a save has that name already.
+      def named(result)
+        name = @name_field.text.strip
+        if result == :cancel
+          @name_field.close
+        elsif result == :done && name.empty?
+          @name_field.refuse("TYPE A NAME")
+        elsif result == :done
+          @snapshots.named?(name) ? @confirmation.ask(:overwrite, name) : save_as(name)
+        end
+        nil
+      end
+
+      def save_as(name, replace: false)
+        @name_field.close if @snapshots.save_named(name, replace:)
+      end
+
       # Does what the question asked about if `action` is :confirm, and
       # returns :resume, or :swap for a new machine.
       def answer(action)
@@ -112,6 +149,7 @@ module Badline
         case question[0]
         when :cartridge then @media.attach_cartridge(path) ? :resume : nil
         when :remove then @media.remove_cartridge && :resume
+        when :overwrite then save_as(path, replace: true) && nil
         else
           @computer = @media.start(@options, path)
           @computer.nil? ? nil : :swap

data/lib/badline/frontend/menu_media.rb

@@ -4,14 +4,18 @@ module Badline
   module Frontend
     # What the pause menu puts in the machine and takes out: disks, tapes
     # and cartridges, whether disks are writable, which carries over from
-    # one disk to the next, and the disk's set, which PREVIOUS and NEXT step
-    # through. It keeps what last went wrong for the page to show.
+    # one disk to the next, and the set of the disk in device 8, which
+    # PREVIOUS and NEXT step through: the .m3u or .vfl list it came from,
+    # while that lists it, or the set DiskSet finds. It keeps what last went
+    # wrong for the page to show.
     class MenuMedia
-      attr_reader :disk_path, :problem
+      attr_reader :problem
       attr_writer :computer
 
-      def initialize(disk_path, writable)
-        @disk_path = disk_path
+      # Takes the disk set from the command line's `media_path` when it's a
+      # list.
+      def initialize(media_path, writable)
+        @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
         @set = []
@@ -21,24 +25,40 @@ module Badline
 
       def writable? = @writable
 
+      # The expanded path of the disk in device 8, however it went in, or
+      # an empty one.
+      def disk_path
+        drive = @computer.drive1541
+        unless drive.nil?
+          disk = drive.disk
+          return disk.nil? ? "" : disk.path.to_s
+        end
+
+        path = @computer.mounted_path
+        path.empty? ? path : File.expand_path(path)
+      end
+
       def inserted?
         drive = @computer.drive1541
         drive.nil? ? @computer.mounted? : !drive.disk.nil?
       end
 
       # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
-      # :tape.
+      # :tape, and says whether it went in. A list puts its first disk in.
       def insert(kind, path)
         @problem = ""
         if kind == :disk
-          Media.insert_disk(@computer, path, read_only: !@writable)
-          @disk_path = path
+          disk = Media::DiskList.disk(path)
+          Media.insert_disk(@computer, disk, read_only: !@writable)
+          list(path)
         else
           @computer.datasette.insert(Storage::TAP.new(path))
         end
+        true
       rescue ArgumentError, SystemCallError, Storage::TAP::FormatError, Storage::T64::FormatError,
              Storage::G64Image::FormatError => e
         @problem = e.message
+        false
       end
 
       # Does what the Drive page's :eject_disk, :previous_disk, :next_disk,
@@ -55,23 +75,25 @@ module Badline
       def eject_disk
         drive = @computer.drive1541
         drive.nil? ? @computer.unmount : drive.insert(nil)
-        @disk_path = ""
       end
 
       # Sets whether disks are writable, for the disk in the drive too,
       # which goes in again as the notch now says.
       def writable(writable)
         @writable = writable
-        insert(:disk, @disk_path) if inserted? && !@disk_path.empty?
+        path = disk_path
+        insert(:disk, path) if inserted? && !path.empty?
       end
 
       # The disks of the set the disk in the drive belongs to.
       def disk_set
-        return [] if @disk_path.empty?
+        path = disk_path
+        return [] if path.empty?
 
-        unless @set_path == @disk_path
-          @set = Media::DiskSet.around(@disk_path)
-          @set_path = @disk_path
+        unless @set_path == path
+          listed = @list.empty? ? [] : expanded(Media::DiskList.disks(@list))
+          @set = listed.include?(path) ? listed : expanded(Media::DiskSet.around(path))
+          @set_path = path
         end
         @set
       end
@@ -80,7 +102,7 @@ module Badline
       # drive, if there is one.
       def step_disk(step)
         set = disk_set
-        index = set.index(@disk_path)
+        index = set.index(disk_path)
         return if index.nil? || !(index + step).between?(0, set.size - 1)
 
         insert(:disk, set[index + step])
@@ -97,6 +119,26 @@ module Badline
         false
       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.
+      def game_name
+        vic20 = @computer.family == :vic20
+        name = vic20 ? "" : cartridge_name
+        disk = disk_path
+        name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
+        name = tape_name if name.empty? && !vic20
+        name = name.sub(/\s*[(\[].*\z/, "").strip
+        return name unless name.empty?
+
+        vic20 ? "VIC-20" : "BASIC"
+      end
+
+      def tape_name
+        tape = @computer.datasette.tape
+        tape.nil? ? "" : File.basename(tape.path, File.extname(tape.path))
+      end
+
       # The name the cartridge in the expansion port gives itself, or an
       # empty one.
       def cartridge_name
@@ -115,7 +157,7 @@ module Badline
       def start(options, path)
         @problem = ""
         computer = Frontend.start(options, path, @writable)
-        @disk_path = PauseMenu.disk_path(path)
+        list(path)
         computer
       rescue ArgumentError, SystemCallError, Media::TrueDrive::Error, Storage::SIDFile::FormatError,
              Storage::T64::FormatError, Storage::TAP::FormatError, Storage::CRTFile::FormatError,
@@ -123,6 +165,18 @@ module Badline
         @problem = e.message
         nil
       end
+
+      private
+
+      # Keeps `path` as the list the set comes from, if it's a list.
+      def list(path)
+        return unless Media::DiskList.list?(path)
+
+        @list = path
+        @set_path = ""
+      end
+
+      def expanded(paths) = paths.map { |path| File.expand_path(path) }
     end
   end
 end

data/lib/badline/frontend/menu_pages.rb

@@ -7,6 +7,8 @@ module Badline
     # row for each thing to do, a setting showing its value on the right,
     # which a press steps on.
     class MenuPages
+      include MenuPorts
+
       TEXT = PauseMenu::TEXT
       DIM = PauseMenu::DIM
       LINE = 12
@@ -14,19 +16,23 @@ module Badline
       ROW_WIDTH = 200
 
       WARNING = 0xff7a6b
+      RECENT = %i[recent0 recent1 recent2 recent3 recent4 recent5 recent6 recent7].freeze
 
-      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
+      SID_MODELS = %i[mos6581 mos8580].freeze
+      RAM_NAMES = {
+        unexpanded: "", "3k": "3K", "8k": "8K", "16k": "16K", "24k": "24K", "32k": "32K",
+        all: "35K, ALL BLOCKS"
+      }.freeze
 
       # The disks, tapes and cartridges the pages put in and take out.
       attr_reader :media
 
-      def initialize(painter, buttons, disk_path, options)
+      def initialize(painter, buttons, media_path, options, snapshots)
+        @snapshots = snapshots
+        @recent = []
         @painter = painter
         @buttons = buttons
-        @media = MenuMedia.new(disk_path, options.writable?)
+        @media = MenuMedia.new(media_path, options.writable?)
         @reu_kb = options.reu
         @computer = nil
         @controls = nil
@@ -54,10 +60,14 @@ module Badline
         when :expansion then draw_expansion
         when :ports then draw_ports
         when :sound then draw_sound
+        when :snapshots then draw_snapshots
         else draw_power
         end
       end
 
+      # The path of the quicksave or autosave a RECENT action stands for.
+      def recent(action) = @recent[RECENT.index(action)].to_s
+
       def perform(action)
         case action
         when :eject_disk, :previous_disk, :next_disk, :protect, :unprotect then @media.drive(action)
@@ -68,7 +78,7 @@ module Badline
         when :keys_c64, :keys_joystick then keys(action == :keys_c64 ? :keyboard : :joystick)
         when :swap then @controls.swap_ports
         when :sound_on, :mute then @sound.toggle_mute unless @sound.muted? == (action == :mute)
-        when :sid6581, :sid8580 then @computer.sid.model = action == :sid8580 ? :mos8580 : :mos6581
+        when :sid6581, :sid8580 then @computer.sound_source.model = action == :sid8580 ? :mos8580 : :mos6581
         when :reset then @computer.reset!
         when :power_cycle then @computer.power_cycle!
         else pick_port(action)
@@ -77,6 +87,14 @@ module Badline
 
       private
 
+      def vic20? = @computer.family == :vic20
+
+      # Says in the dim colour that the VIC-20 hasn't got what the page
+      # shows.
+      def note
+        @painter.text(@left, @top, "NOT ON THE VIC-20 YET", DIM)
+      end
+
       def draw_drive
         media = @media
         inserted = media.inserted?
@@ -107,6 +125,8 @@ module Badline
       end
 
       def draw_expansion
+        return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
+
         cartridge = @computer.address_bus.cartridge
         info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
         row("INSERT...", :insert_cartridge)
@@ -118,27 +138,32 @@ module Badline
         info("RAM EXPANSION", "REU, #{@reu_kb} KB")
       end
 
-      def draw_ports
-        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))])
-        joystick = @controls.joystick_mode?
-        toggle("KEYS", :keys, [%w[C64 JOYSTICK], %i[keys_c64 keys_joystick], joystick ? 1 : 0])
-        return unless joystick
-
-        row("SWAP JOYSTICKS", :swap)
-        skip
-        arrows = @controls.arrows_port
-        info("ARROWS, SPACE", "PORT #{arrows}")
-        info("WASD, LEFT SHIFT", "PORT #{3 - arrows}")
-      end
-
+      # The SID's model is a setting, 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])
         else
           info("OUTPUT", "OFF")
         end
-        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], @computer.sid.model == :mos8580 ? 1 : 0])
+        model = @computer.sound_source.model
+        return unless SID_MODELS.include?(model)
+
+        toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], model == :mos8580 ? 1 : 0])
+      end
+
+      # Saving now and by name, loading a named save, and the quicksaves
+      # and autosaves, newest first, which a press loads.
+      def draw_snapshots
+        row("QUICKSAVE", :quicksave_now)
+        row("SAVE...", :save_as)
+        row("LOAD...", :load_save)
+        skip
+        saves = (@snapshots.list("quicksaves") + @snapshots.list("autosaves")).sort_by { |path| -File.mtime(path).to_f }
+        @recent = saves.first(RECENT.size)
+        @recent.each_with_index do |path, index|
+          kind = File.basename(path).start_with?("autosave") ? "AUTOSAVE" : "QUICKSAVE"
+          row(kind, RECENT[index], @snapshots.time_of(path))
+        end
       end
 
       def draw_power
@@ -173,26 +198,6 @@ module Badline
       def skip
         @top += LINE
       end
-
-      def keys(mode) = @controls.joystick_mode = mode == :joystick
-
-      def port_device(port)
-        index = POTS[port - 1].index(@controls.pot)
-        index.nil? ? :joystick : PORT_DEVICES[index]
-      end
-
-      # Plugs the device a choice such as :port1_mouse names into its port.
-      def pick_port(action)
-        index = PORT_ACTIONS[0].include?(action) ? 0 : 1
-        choice = PORT_ACTIONS[index].index(action)
-        plug_device(index + 1, choice) unless choice.nil? || choice == PORT_DEVICES.index(port_device(index + 1))
-      end
-
-      # Plugs PORT_DEVICES[choice] into the port. A joystick there takes out
-      # the pot device.
-      def plug_device(port, choice)
-        @controls.plug(POTS[port - 1][choice])
-      end
     end
   end
 end

data/lib/badline/frontend/menu_ports.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # 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.
+    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
+
+      private
+
+      def draw_ports
+        return draw_vic20_port if @computer.family == :vic20
+
+        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))])
+        return unless draw_keys("C64")
+
+        row("SWAP JOYSTICKS", :swap)
+        skip
+        arrows = @controls.arrows_port
+        info("ARROWS, SPACE", "PORT #{arrows}")
+        info("WASD, LEFT SHIFT", "PORT #{3 - arrows}")
+      end
+
+      # The VIC-20's one joystick, which both sets of keys drive.
+      def draw_vic20_port
+        return unless draw_keys("VIC-20")
+
+        skip
+        info("ARROWS, SPACE", "JOYSTICK")
+        info("WASD, LEFT SHIFT", "JOYSTICK")
+      end
+
+      # The toggle between the keyboard named and the joysticks, and
+      # whether the keys drive the joysticks.
+      def draw_keys(keyboard)
+        joystick = @controls.joystick_mode?
+        toggle("KEYS", :keys, [[keyboard, "JOYSTICK"], %i[keys_c64 keys_joystick], joystick ? 1 : 0])
+        joystick
+      end
+
+      def keys(mode) = @controls.joystick_mode = mode == :joystick
+
+      def port_device(port)
+        index = POTS[port - 1].index(@controls.pot)
+        index.nil? ? :joystick : PORT_DEVICES[index]
+      end
+
+      # Plugs the device a choice such as :port1_mouse names into its port.
+      def pick_port(action)
+        index = PORT_ACTIONS[0].include?(action) ? 0 : 1
+        choice = PORT_ACTIONS[index].index(action)
+        plug_device(index + 1, choice) unless choice.nil? || choice == PORT_DEVICES.index(port_device(index + 1))
+      end
+
+      # Plugs PORT_DEVICES[choice] into the port. A joystick there takes out
+      # the pot device.
+      def plug_device(port, choice)
+        @controls.plug(POTS[port - 1][choice])
+      end
+    end
+  end
+end