badline 0.8.0 → 0.10.0

data/lib/badline/datasette.rb

@@ -3,14 +3,22 @@
 module Badline
   # The 1530 datasette. Plays a pulse stream into CIA 1's FLAG pin while the
   # motor runs with a key pressed, and reports the keys through the cassette
-  # sense line on the $01 port.
+  # sense line on the $01 port. With RECORD down too, it records the
+  # machine's write line onto the tape instead.
   class Datasette
+    # What inserting a tape raises on a machine without a cassette port.
+    class Missing < ArgumentError; end
+
     attr_reader :tape
     attr_writer :motor
 
     def initialize(tape = nil)
       @tape = tape
+      @connected = true
       @playing = false
+      @recording = false
+      @write_high = true
+      @since = 0
       @motor = false
       @countdown = 0
       @flag_handler = nil
@@ -27,7 +35,18 @@ module Badline
       @sense_handler = handler
     end
 
+    # Whether the machine has a datasette at its cassette port. The SX-64
+    # has none: its keys stay up and it takes no tape.
+    def connected? = @connected
+
+    def disconnect!
+      eject
+      @connected = false
+    end
+
     def insert(tape)
+      raise Missing, "this machine has no datasette" unless @connected
+
       @tape = tape
       rewind
     end
@@ -45,6 +64,30 @@ module Badline
     def play! = press(true)
     def stop! = press(false)
 
+    # Presses RECORD and PLAY together.
+    def record!
+      return if !@connected || @tape.nil?
+
+      press(true)
+      @recording = true
+      @since = 0
+    end
+
+    def recording? = @recording
+
+    # The machine's tape write line. While the deck records with its motor
+    # running, each rising edge ends a pulse on the tape, as long as the
+    # time since the edge before, and plays back as a falling edge on the
+    # read line.
+    def write_line=(high)
+      rose = high && !@write_high
+      @write_high = high
+      return unless rose && @recording && running?
+
+      @tape.record_pulse(@since)
+      @since = 0
+    end
+
     def playing? = @playing
 
     # Sense reads low while a key is down on the deck.
@@ -54,18 +97,19 @@ module Badline
 
     def running? = @playing && @motor && !@tape.nil?
 
-    # The keys, the motor, the countdown to the next pulse and the tape: its
-    # path and how far it has played.
+    # The keys, the motor, the countdown to the next pulse and the tape:
+    # its path, its bytes and how far it has played.
     def save_state(out)
       out.marker("DATASETTE")
       out.boolean(@playing).boolean(@motor).int(@countdown).boolean(!@tape.nil?)
       return unless @tape
 
-      out.string(@tape.path).int(@tape.position)
+      out.string(@tape.path).blob(@tape.bytes).int(@tape.position)
     end
 
-    # A tape from another file goes in from its path, and a detached
-    # reader leaves the tape out. The sense and flag handlers don't fire.
+    # The tape goes back in from the bytes the state holds, without its
+    # host file, unless the tape in is the same one. The sense and flag
+    # handlers don't fire.
     def load_state(input)
       input.marker("DATASETTE")
       @playing = input.boolean?
@@ -74,15 +118,15 @@ module Badline
       return @tape = nil unless input.boolean?
 
       path = input.string
+      bytes = input.blob
       position = input.int
-      return @tape = nil if input.detached?
-
-      @tape = Storage::TAP.new(path) unless @tape&.path&.b == path
+      @tape = Storage::TAP.new(path, bytes:) unless @tape&.path&.b == path && @tape.bytes == bytes
       @tape.position = position
     end
 
     def cycle!
       return unless running?
+      return @since += 1 if @recording
 
       @countdown = @tape.next_pulse.to_i if @countdown.zero?
       return if @countdown.zero?
@@ -99,10 +143,19 @@ module Badline
     private
 
     def press(down)
-      return if down == @playing
+      return if down == @playing || !@connected
 
+      finish_recording unless down
       @playing = down
       @sense_handler&.call
     end
+
+    # Releasing the keys ends a recording, and writes the tape out.
+    def finish_recording
+      return unless @recording
+
+      @recording = false
+      @tape.save
+    end
   end
 end

data/lib/badline/drive1541/disk.rb

@@ -160,9 +160,9 @@ module Badline
       end
 
       # Whether the write-protect notch is covered: the disk's image won't
-      # take writes. A disk without an image takes them, and keeps them
-      # only in its tracks.
-      def write_protected? = !@image.nil? && !@image.writable?
+      # take writes, or a disk without an image was opened read-only. A
+      # disk without an image keeps what it takes only in its tracks.
+      def write_protected? = @image.nil? ? @read_only : !@image.writable?
 
       # A half track the head writes to, blank to begin with: no flux, and
       # as many bytes as a turn holds at the bit rate of the +zone+ it's

data/lib/badline/drive1541/disk_state.rb

@@ -5,7 +5,8 @@ module Badline
     class Disk
       # Saving and restoring a Disk for a snapshot: the image by its path,
       # and every half track as the head sees it, with those written since
-      # the last flush. The image itself is read again from its host file.
+      # the last flush. The image itself is read again from its host file,
+      # where there still is one.
       module State
         # The image's path, expanded, and whether it was opened read-only,
         # for a disk from Disk.open. Nil for a disk made another way.
@@ -25,18 +26,26 @@ module Badline
 
         # The disk a state from save_state describes: +current+ when it was
         # opened from the same image the same way, and otherwise a disk for
-        # the image at the path the state names, or one without an image,
-        # as a detached reader always gets. Either way its tracks come from
-        # the state.
+        # the image at the path the state names. Where no file is at that
+        # path, the disk has no image and is write-protected, and a
+        # detached reader always gets one without an image. Either way its
+        # tracks come from the state.
         def self.load(input, current)
           path = input.optional_string
           read_only = input.boolean?
           disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
-          disk ||= path && !input.detached? ? reopen(path, read_only) : Disk.new
+          disk ||= fresh(path, read_only, input.detached?)
           disk.load_tracks(input)
           disk
         end
 
+        def self.fresh(path, read_only, detached)
+          return Disk.new if path.nil? || detached
+          return Disk.new.opened(path, true) unless File.file?(path)
+
+          reopen(path, read_only)
+        end
+
         # Notes the image's path and how it was opened.
         def opened(path, read_only)
           @path = File.expand_path(path)

data/lib/badline/drive1541/serial_port.rb

@@ -27,7 +27,7 @@ module Badline
 
       attr_reader :bus
 
-      def initialize(device: 8, bus: nil)
+      def initialize(device: 8, bus: IECBus.new)
         @port_b = (0xff & ~(SERIAL_INPUTS | JUMPERS)) | (((device - 8) & 0x03) << 5)
         @host = 0
         self.bus = bus
@@ -38,10 +38,10 @@ module Badline
         latch_host
       end
 
-      # Takes the C64's lines as they stand, for the drive cycles of the
-      # next host cycle.
+      # Takes the C64's lines as the machine last pushed them into the bus,
+      # for the drive cycles of the next host cycle.
       def latch_host
-        @host = @bus ? @bus.host_lines : 0
+        @host = @bus.host_lines
       end
 
       # The C64's lines as last latched. The jumpers and the bus are the
@@ -55,10 +55,7 @@ module Badline
       end
 
       # Whether the C64 has moved ATN since the last latch_host.
-      def atn_moved?
-        lines = @bus ? @bus.host_lines : 0
-        (lines ^ @host).anybits?(IECBus::HOST_ATN_OUT)
-      end
+      def atn_moved? = (@bus.host_lines ^ @host).anybits?(IECBus::HOST_ATN_OUT)
 
       def atn_low? = @bus.atn_low?(@host)
 

data/lib/badline/drive1541/sleep.rb

@@ -8,9 +8,8 @@ module Badline
     # passes go in bulk, and the rest cycle by cycle, which may find the
     # idle loop and put the drive back to sleep.
     #
-    # The drive looks at ATN only when the C64 may have moved it, on a
-    # bus that says when (IECBus#notifies?), and every host cycle on one
-    # that doesn't.
+    # The drive looks at ATN only when the machine may have moved it, as
+    # it pushes its lines into the bus (IECBus#host_lines=).
     module Sleep
       # Whether the drive is skipping its idle loop right now.
       def asleep? = @asleep
@@ -40,10 +39,10 @@ module Badline
         @wake_at = 0
       end
 
-      # A host cycle asleep that may wake the drive. The bus says whether
-      # the next ones need a look at ATN.
+      # A host cycle asleep that may wake the drive. The next ones need no
+      # look at ATN until the machine pushes its lines again.
       def doze
-        @host_still = @serial_bus.notifies?
+        @host_still = true
         if @serial_port.atn_moved?
           settle!
         elsif @slept == @wake_at

data/lib/badline/drive1541.rb

@@ -149,8 +149,8 @@ module Badline
     # The host has run this cycle already, and the drive sees what it did
     # from the next one on (see SerialPort). Asleep, the drive owes the
     # cycles instead, until ATN moves or its counters are due (see Idle).
-    # It looks at ATN only after the C64 wrote CIA 2's port A, on a bus
-    # that says so (see host_written!).
+    # It looks at ATN only after the machine pushed its lines into the bus
+    # (see host_written!).
     def host_cycle!
       if @asleep
         return if (@slept += 1) != @wake_at && @host_still
@@ -169,7 +169,7 @@ module Badline
       plan_wake if @asleep
     end
 
-    # The C64 wrote CIA 2's port A, so ATN may have moved.
+    # The machine pushed its lines into the bus, so ATN may have moved.
     def host_written!
       @host_still = false
     end

data/lib/badline/frontend/app.rb

@@ -3,12 +3,10 @@
 module Badline
   module Frontend
     # Opens the window, then runs the machine a frame at a time: poll
-    # events, clock the frame's cycles, queue the SID's samples, upload the
+    # events, clock the frame's cycles, queue the sound's samples, upload the
     # changed lines, present and wait. Pacer decides the cycles and the wait.
     class App
-      SCALE = 2
       DROPFILE = 0x1000
-      TITLE = "Badline"
 
       # Takes the frame limit, the pacing, the snapshot path, the sound and
       # the verbosity from Options, and runs the timeline's events.
@@ -16,17 +14,21 @@ module Badline
         @computer = computer
         @frame_limit = options.frames
         @verbose = options.verbose?
-        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, region: computer.region)
+        timing = computer.timing
+        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, timing:)
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
-        @screen = Screen.new(computer.vic)
+        @screen = Screen.new(computer.video, timing.crop)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        open_window
-        @sound = Sound.new(computer.sid, options.sound?, @verbose)
+        @window = MachineWindow.new(@screen, timing.pixel_width, vsync: @pacer.vsync?)
+        @pacer.fit(@window.refresh_rate) if @pacer.vsync?
+        @sound = Sound.new(computer.sound_source, timing.clock_hz, options.sound?, @verbose)
         @gamepads = Gamepads.new(computer, @verbose)
         @frame_report = FrameReport.new(@sound)
-        @menu = PauseMenu.new(Painter.new(@renderer), options)
+        @menu = PauseMenu.new(Painter.new(@window.renderer), options, @snapshots)
+        @menu.center(@window.width, @window.height)
+        @scripted = false
       end
 
       def run
@@ -39,7 +41,7 @@ module Badline
         @computer.drive1541&.flush
         @gamepads.close
         @sound.close
-        close_window
+        @window.close
       end
 
       private
@@ -66,39 +68,24 @@ module Badline
         @frame_report.add(stamps) if @verbose
         @frames += 1
         @timeline.run(@computer, @frames)
+        @snapshots.tick(@frames)
         @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
         @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
         report(stamps.last) if (@frames % 50).zero?
-      end
-
-      def open_window
-        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")
-        @window = SDL.SDL_CreateWindow(
-          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
-          Screen::WIDTH * SCALE, Screen::HEIGHT * SCALE, SDL::WINDOW_RESIZABLE
-        )
-        flags = SDL::RENDERER_ACCELERATED
-        flags |= SDL::RENDERER_PRESENTVSYNC if @pacer.vsync?
-        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
-        fit_display if @pacer.vsync?
-        SDL.SDL_RenderSetLogicalSize(@renderer, Screen::WIDTH, Screen::HEIGHT)
-        create_texture
-      end
-
-      def create_texture
-        @texture = SDL.SDL_CreateTexture(
-          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
-        )
-      end
-
-      def close_window
-        SDL.SDL_DestroyTexture(@texture)
-        SDL.SDL_DestroyRenderer(@renderer)
-        SDL.SDL_DestroyWindow(@window)
-        SDL.SDL_Quit
+        menu_events
+      end
+
+      # Opens the menu at a menu event, on the page it names, and closes it
+      # at a resume. While the timeline holds it open, its frames count
+      # towards the events after it and --frames.
+      def menu_events
+        if @timeline.menu?(@frames)
+          @menu.section = @timeline.menu_section(@frames)
+          open_menu
+          @scripted = true
+        elsif @menu.open? && @timeline.resume?(@frames)
+          resume(false)
+        end
       end
 
       def handle_events
@@ -136,11 +123,14 @@ module Badline
       # it.
       def swap(computer)
         @computer = computer
-        @screen = Screen.new(computer.vic)
+        timing = computer.timing
+        @screen = Screen.new(computer.video, timing.crop)
+        @window.fit(@screen, timing.pixel_width)
+        @menu.center(@window.width, @window.height)
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.sid = computer.sid
+        @sound.switch(computer.sound_source, timing.clock_hz)
         @snapshots.computer = computer
       end
 
@@ -161,6 +151,7 @@ module Badline
       # pressing the cartridge's freeze button if asked.
       def resume(freeze)
         @menu.close
+        @scripted = false
         SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
         @timeline.press_freeze(@computer, @frames) if freeze
         @reported = now
@@ -169,50 +160,58 @@ module Badline
       end
 
       # Runs a frame of the menu, which has the keys and the mouse while the
-      # machine stands still.
+      # machine stands still. A menu the timeline opened counts its frames
+      # and takes their screenshots.
       def paused_frame
-        action = @menu.frame(@renderer, @texture, @controls)
+        scripted = @scripted
+        action = @menu.frame(@window.renderer, @window.texture, @controls)
+        present_menu(scripted)
         if action == :quit
           @running = false
         elsif !action.nil?
           swap(@menu.computer) if action == :swap
           resume(action == :freeze)
         end
+        finish_paused_frame if scripted && @running
       end
 
-      def update_title
-        title = TITLE
-        title += " [#{@controls.tag}]" unless @controls.tag.empty?
-        title += " [MUTED]" if @sound.muted?
-        SDL.SDL_SetWindowTitle(@window, title)
+      def present_menu(scripted)
+        renderer = @window.renderer
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) } if scripted
+        SDL.SDL_RenderPresent(renderer)
+        SDL.SDL_Delay(10)
+      end
+
+      def finish_paused_frame
+        @frames += 1
+        @timeline.run(@computer, @frames)
+        @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
+        menu_events
       end
 
-      def fit_display
-        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
-        @pacer.fit(SDL.mode_refresh(SDL.display_mode))
+      def update_title
+        tags = []
+        tags << @controls.tag unless @controls.tag.empty?
+        tags << "MUTED" if @sound.muted?
+        @window.title(tags)
       end
 
       def emulate
-        computer = @computer
-        cycles = @pacer.cycles(@sound)
-        i = 0
-        while i < cycles
-          computer.cycle!
-          i += 1
-        end
+        @computer.run_cycles(@pacer.cycles(@sound))
       end
 
       def upload
         @screen.update
-        SDL.SDL_UpdateTexture(@texture, nil, @screen.pixels, Screen::ROW_BYTES)
+        @window.upload(@screen)
       end
 
       def draw
-        SDL.SDL_RenderClear(@renderer)
-        SDL.SDL_RenderCopy(@renderer, @texture, nil, nil)
-        @led&.draw(@renderer)
-        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
-        SDL.SDL_RenderPresent(@renderer)
+        renderer = @window.renderer
+        SDL.SDL_RenderClear(renderer)
+        SDL.SDL_RenderCopy(renderer, @window.texture, nil, nil)
+        @led&.draw(renderer, @window.width, @window.height)
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) }
+        SDL.SDL_RenderPresent(renderer)
       end
 
       def report(at)

data/lib/badline/frontend/boot.rb

@@ -20,7 +20,8 @@ module Badline
         computer = boot(options)
       rescue Media::TrueDrive::Error, Storage::SIDFile::FormatError, Storage::T64::FormatError,
              Storage::TAP::FormatError, Storage::CRTFile::FormatError, Storage::G64Image::FormatError,
-             Cartridge::UnsupportedTypeError, Snapshot::FormatError => e
+             Cartridge::UnsupportedTypeError, Snapshot::FormatError, Media::DiskList::Error,
+             Datasette::Missing, Unsupported => e
         warn "#{options.program}: #{options.media_path}: #{e.message}"
         return 1
       end
@@ -44,10 +45,11 @@ module Badline
 
     # A new machine built from the options, with `media`, if not nil,
     # attached and started as the command line does, its disk writable if
-    # `writable`.
+    # `writable`. The family and model give the machine, and a .sid tune
+    # or --sid the SID. The VIC-20 raises Unsupported for a .sid
+    # tune.
     def self.start(options, media, writable)
-      computer = Computer.new(sid_model: options.sid_model || Media.sid_model(media), reu: options.reu,
-                              region: options.ntsc? ? Region::NTSC : Region::PAL)
+      computer = options.family == :vic20 ? vic20(options, media) : c64(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
@@ -55,5 +57,33 @@ module Badline
       end
       computer
     end
+
+    def self.c64(options, media)
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
+    end
+
+    # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
+    # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
+    # media a VIC-20 doesn't take.
+    def self.vic20(options, media)
+      ram = options.ram
+      unless media.nil?
+        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
+        raise Unsupported, "doesn't go in a VIC-20" if unsupported
+
+        ram ||= vic20_ram(media)
+      end
+      Machine.build(:vic20, model: options.model, ram:)
+    end
+
+    def self.vic20_ram(media)
+      ram = Media::Vic20Media.ram_for(media)
+      puts "RAM expansion: #{ram}"
+      ram
+    end
+
+    # Media the machine the options name doesn't take.
+    class Unsupported < ArgumentError; end
   end
 end

data/lib/badline/frontend/confirmation.rb

@@ -2,14 +2,19 @@
 
 module Badline
   module Frontend
-    # The pause menu's question before something power cycles the machine:
-    # a cartridge going in or out, or Quick open starting a file. CANCEL
-    # has the focus, so Return alone changes nothing.
+    # The pause menu's question before something power cycles the machine
+    # or replaces a file: a cartridge going in or out, Quick open starting a
+    # file, or a save overwriting one of the same name. CANCEL has the
+    # focus, so Return alone changes nothing.
     class Confirmation
-      TITLES = { cartridge: "INSERT A CARTRIDGE", remove: "REMOVE THE CARTRIDGE", start: "QUICK OPEN" }.freeze
-      WARNINGS = { cartridge: "INSERTING IT POWER CYCLES THE MACHINE.", remove: "REMOVING IT POWER CYCLES THE MACHINE.",
-                   start: "THIS STARTS A NEW MACHINE." }.freeze
-      ANSWERS = { cartridge: "INSERT", remove: "REMOVE", start: "START" }.freeze
+      TITLES = { cartridge: "INSERT A CARTRIDGE", remove: "REMOVE THE CARTRIDGE", start: "QUICK OPEN",
+                 overwrite: "SAVE AS" }.freeze
+      LOST = "ANYTHING NOT SAVED IS LOST."
+      WARNINGS = { cartridge: ["INSERTING IT POWER CYCLES THE MACHINE.", LOST],
+                   remove: ["REMOVING IT POWER CYCLES THE MACHINE.", LOST],
+                   start: ["THIS STARTS A NEW MACHINE.", LOST],
+                   overwrite: ["OVERWRITE EXISTING SAVE?", ""] }.freeze
+      ANSWERS = { cartridge: "INSERT", remove: "REMOVE", start: "START", overwrite: "OVERWRITE" }.freeze
 
       def initialize(painter, buttons)
         @painter = painter
@@ -21,8 +26,8 @@ module Badline
 
       def open? = @open
 
-      # Asks about `kind`, :cartridge, :remove or :start, for the file at
-      # `path`.
+      # Asks about `kind`, :cartridge, :remove, :start or :overwrite, for the
+      # file at `path`, or the save named so.
       def ask(kind, path)
         @kind = kind
         @path = path
@@ -40,8 +45,9 @@ module Badline
         painter = @painter
         painter.text(left, top, TITLES.fetch(@kind), PauseMenu::BRIGHT)
         painter.text(left, top + 20, Painter.fit(File.basename(@path), 40), PauseMenu::TEXT) unless @path.empty?
-        painter.text(left, top + 44, WARNINGS.fetch(@kind), PauseMenu::TEXT)
-        painter.text(left, top + 56, "ANYTHING NOT SAVED IS LOST.", PauseMenu::TEXT)
+        warning = WARNINGS.fetch(@kind)
+        painter.text(left, top + 44, warning[0], PauseMenu::TEXT)
+        painter.text(left, top + 56, warning[1], PauseMenu::TEXT) unless warning[1].empty?
         @buttons.row([left, top + 80, MenuPages::ROW_WIDTH], "CANCEL", :cancel)
         @buttons.row([left, top + 80 + Buttons::HEIGHT + 2, MenuPages::ROW_WIDTH], ANSWERS.fetch(@kind), :confirm)
       end

data/lib/badline/frontend/controls.rb

@@ -4,11 +4,11 @@ module Badline
   module Frontend
     # Routes host input to the machine. Two settings decide where it goes:
     #
-    # - The keys: every host key goes to the C64 keyboard, or, as Tab
+    # - The keys: every host key goes to the machine's keyboard, or, as Tab
     #   switches, the arrow cluster and space drive one joystick and WASD
     #   and left shift the other. The arrows start on joystick 2, and
-    #   #swap_ports swaps them.
-    # - A pot device the pause menu plugs into a control port: a 1351
+    #   #swap_ports swaps them. The VIC-20's one joystick takes both.
+    # - A pot device the pause menu plugs into a C64 control port: a 1351
     #   mouse or a pair of paddles, which the host mouse drives. Motion
     #   turns the paddles or moves the mouse, and the host's left and right
     #   buttons go to whichever lines the device puts them on.
@@ -65,7 +65,7 @@ module Badline
       # The title bar's tag for the settings, empty for the keyboard alone.
       def tag
         tags = []
-        tags << "JOY #{@arrows_port}" if @joystick
+        tags << (@computer.family == :vic20 ? "JOY" : "JOY #{@arrows_port}") if @joystick
         tags << TAGS[POTS.index(@pot)] if pot_device?
         tags.join(", ")
       end
@@ -105,7 +105,7 @@ module Badline
       # RESTORE isn't in the key matrix, so it goes to the machine instead.
       def c64_key(key, down)
         if key == :restore
-          @computer.press_restore if down
+          down ? @computer.press_restore : @computer.release_restore
         else
           down ? @computer.keyboard.press(key) : @computer.keyboard.release(key)
         end
@@ -113,9 +113,15 @@ module Badline
 
       def paddles? = POTS.index(@pot) >= 3
 
-      # A fresh pot device on its port, and none on the other.
+      # A fresh pot device on its port, and none on the other. A machine
+      # without the ports takes none.
       def attach_pot_device
         ports = @computer.control_ports
+        if ports.nil?
+          @pot = :none
+          return
+        end
+
         ports.device1 = nil
         ports.device2 = nil
         return unless pot_device?