badline 0.8.0 → 0.9.0

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

@@ -5,13 +5,17 @@ module Badline
     # 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.
+    # 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_writer :computer
 
-      def initialize(disk_path, writable)
-        @disk_path = disk_path
+      # Starts on the disk the command line's `media_path` put in.
+      def initialize(media_path, writable)
+        @disk_path = PauseMenu.disk_path(media_path)
+        @list = Media::DiskList.list?(media_path) ? media_path : ""
         @writable = writable
         @set_path = ""
         @set = []
@@ -27,12 +31,14 @@ module Badline
       end
 
       # Puts a disk in device 8 or a tape in the datasette, `kind` :disk or
-      # :tape.
+      # :tape. 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)
+          @disk_path = disk
         else
           @computer.datasette.insert(Storage::TAP.new(path))
         end
@@ -70,7 +76,8 @@ module Badline
         return [] if @disk_path.empty?
 
         unless @set_path == @disk_path
-          @set = Media::DiskSet.around(@disk_path)
+          listed = @list.empty? ? [] : Media::DiskList.disks(@list)
+          @set = listed.include?(@disk_path) ? listed : Media::DiskSet.around(@disk_path)
           @set_path = @disk_path
         end
         @set
@@ -97,6 +104,17 @@ 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.
+      def game_name
+        name = cartridge_name
+        name = File.basename(@disk_path, File.extname(@disk_path)) if name.empty? && !@disk_path.empty?
+        tape = @computer.datasette.tape
+        name = File.basename(tape.path, File.extname(tape.path)) if name.empty? && !tape.nil?
+        name = name.sub(/\s*[(\[].*\z/, "").strip
+        name.empty? ? "BASIC" : name
+      end
+
       # The name the cartridge in the expansion port gives itself, or an
       # empty one.
       def cartridge_name
@@ -116,6 +134,7 @@ module Badline
         @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 +142,16 @@ 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
     end
   end
 end

data/lib/badline/frontend/menu_pages.rb

@@ -14,6 +14,7 @@ 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
@@ -23,10 +24,12 @@ module Badline
       # 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 +57,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)
@@ -141,6 +148,21 @@ module Badline
         toggle("SID", :sid, [%w[6581 8580], %i[sid6581 sid8580], @computer.sid.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
         row("RESET", :reset)
         row("POWER CYCLE", :power_cycle)

data/lib/badline/frontend/name_field.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's prompt for a name, typed with the keys by their
+    # place on a US keyboard: letters, with Shift for capitals, digits,
+    # space, - and _ and the full stop. Backspace deletes, Return takes the
+    # name and Esc leaves it.
+    class NameField
+      COLUMNS = 30
+      LETTERS = "abcdefghijklmnopqrstuvwxyz"
+      DIGITS = "1234567890"
+      OTHERS = { 44 => [" ", " "], 45 => ["-", "_"], 55 => [".", "."] }.freeze
+
+      RETURN = 40
+      ESCAPE = 41
+      BACKSPACE = 42
+
+      attr_reader :text
+
+      def initialize(painter)
+        @painter = painter
+        @open = false
+        @title = ""
+        @text = ""
+        @problem = ""
+      end
+
+      def open? = @open
+
+      def open(title, text)
+        @open = true
+        @title = title
+        @text = text
+        @problem = ""
+      end
+
+      def close
+        @open = false
+      end
+
+      # Says why the name won't do, under the field.
+      def refuse(problem)
+        @problem = problem
+      end
+
+      # Handles a key, and returns :done for Return, :cancel for Esc, or
+      # nil.
+      def key(scancode, shift)
+        return :done if scancode == RETURN
+        return :cancel if scancode == ESCAPE
+
+        @problem = ""
+        if scancode == BACKSPACE
+          @text = @text[0, @text.length - 1].to_s
+        else
+          char = character(scancode, shift)
+          @text += char unless char.empty? || @text.length >= COLUMNS
+        end
+        nil
+      end
+
+      def draw(left, top, width)
+        painter = @painter
+        painter.text(left, top, @title, PauseMenu::BRIGHT)
+        painter.box(left, top + 18, width, Buttons::HEIGHT + 4, PauseMenu::FILL)
+        painter.text(left + 4, top + 22, "#{@text}_", PauseMenu::TEXT)
+        painter.text(left, top + 42, @problem, MenuPages::WARNING) unless @problem.empty?
+        painter.text(left, top + 60, "RETURN: SAVE  ESC: CANCEL", PauseMenu::DIM)
+      end
+
+      private
+
+      def character(scancode, shift)
+        if scancode.between?(4, 29)
+          letter = LETTERS[scancode - 4]
+          shift ? letter.upcase : letter
+        elsif scancode.between?(30, 39)
+          DIGITS[scancode - 30]
+        elsif OTHERS.key?(scancode)
+          OTHERS[scancode][shift ? 1 : 0]
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/pause_menu.rb

@@ -14,8 +14,8 @@ module Badline
     # a cartridge going in or out ask first, as each power cycles the
     # machine.
     class PauseMenu
-      SECTIONS = ["DRIVE 8", "DATASETTE", "EXPANSION PORT", "PORTS", "SOUND", "POWER"].freeze
-      PAGES = %i[drive datasette expansion ports sound power].freeze
+      SECTIONS = ["SNAPSHOTS", "DRIVE 8", "DATASETTE", "EXPANSION PORT", "PORTS", "SOUND", "POWER"].freeze
+      PAGES = %i[snapshots drive datasette expansion ports sound power].freeze
       DISKS = %w[.d64 .d71 .d81 .g64 .t64].freeze
 
       PANEL = 0x1d2230
@@ -34,25 +34,28 @@ module Badline
       ESCAPE = 41
       RETURN = 40
       SPACE = 44
+      SNAPSHOT_ACTIONS = %i[quicksave_now save_as load_save].freeze
       ARROWS = { 79 => :right, 80 => :left, 81 => :down, 82 => :up }.freeze
       MOUSEWHEEL = 0x403
 
       # Takes the media, the REU and whether disks are writable from Options.
-      def initialize(painter, options)
+      def initialize(painter, options, snapshots)
         media_path = options.media_path.to_s
         @painter = painter
         @buttons = Buttons.new(painter, [TEXT, BRIGHT, PANEL, FILL])
-        @pages = MenuPages.new(painter, @buttons, PauseMenu.disk_path(media_path), options)
-        @dialogs = MenuDialogs.new(painter, @buttons, @pages.media, options)
+        @pages = MenuPages.new(painter, @buttons, media_path, options, snapshots)
+        @snapshots = snapshots
+        @dialogs = MenuDialogs.new(painter, @buttons, @pages.media, options, snapshots)
         @open = false
         @section = 0
       end
 
-      # The path of the disk the command line puts in device 8, or an empty
-      # one for other media.
+      # The path of the disk the command line puts in device 8, a list's
+      # first, or an empty one for other media.
       def self.disk_path(path)
         return "" if path.empty?
         return path if File.directory?(path)
+        return Media::DiskList.disks(path).first.to_s if Media::DiskList.list?(path)
 
         DISKS.include?(File.extname(path).downcase) ? path : ""
       end
@@ -165,6 +168,8 @@ module Badline
       end
 
       def menu_action(action)
+        return snapshot_action(action) if SNAPSHOT_ACTIONS.include?(action) || MenuPages::RECENT.include?(action)
+
         case action
         when :insert_disk then @dialogs.browse(:disk)
         when :insert_tape then @dialogs.browse(:tape)
@@ -176,6 +181,19 @@ module Badline
         nil
       end
 
+      # Saves now, asks for a name to save under, opens the saves folder,
+      # or loads one of the page's quicksaves and autosaves, returning
+      # :swap once a save has loaded.
+      def snapshot_action(action)
+        case action
+        when :quicksave_now then @snapshots.quicksave
+        when :save_as then @dialogs.ask_name(@snapshots.free_name(@pages.media.game_name))
+        when :load_save then @dialogs.browse(:snapshot)
+        else return @dialogs.load(@pages.recent(action))
+        end
+        nil
+      end
+
       # Moves the focus: down from RESUME to the sections, through them,
       # where each opens as it's reached, on to Quick open, right into a
       # page, up and down it, and left out of it again.

data/lib/badline/frontend/player_window.rb

@@ -45,7 +45,7 @@ module Badline
         @state = PlayerState.new
         @commands = PlayerCommands.new(@state)
         @next_draw = 0.0
-        @seek_left = 0
+        @seek_to = 0.0
         @dropped = []
         @credits = []
         @stil = []
@@ -55,7 +55,7 @@ module Badline
       end
 
       # The seconds into the subtune the last click on the bar asked for.
-      def seek_to = PlayerFooter.seek(@seek_left, @state.length)
+      attr_reader :seek_to
 
       # The files dropped on the window since it last said :drop.
       def dropped
@@ -175,7 +175,7 @@ module Badline
         action = @screen.buttons.action_at(left, SDL.event_y(SDL.event))
         return if action.nil?
 
-        @seek_left = left if action == :seek
+        @seek_to = PlayerFooter.seek(left, @state.length) if action == :seek
         return scroll_along if action == :scroll
 
         command(action, actions)

data/lib/badline/frontend/snapshots.rb

@@ -2,20 +2,26 @@
 
 module Badline
   module Frontend
-    # The window's snapshots: F11 saves the machine to a new
-    # badline-<date>-<time>.vsf in the working directory, and F12 goes back
-    # to the snapshot last saved or opened, in a new machine. --save-snapshot
-    # saves one after the last frame.
+    # The window's snapshots: F11 saves the machine to the next of five
+    # quicksave slots in the data folder, replacing the oldest, and F12
+    # restores the newest quicksave or named save in a new machine. A run
+    # without a frame limit also autosaves every AUTOSAVE_FRAMES frames to
+    # the next of three autosave slots, which only the pause menu loads.
+    # --save-snapshot saves one after the last frame.
     class Snapshots
       KEYS = [Keys::F11, Keys::F12].freeze
+      SLOTS = 5
+      AUTOSAVES = 3
+      AUTOSAVE_FRAMES = 6000
 
       # The machine running, which F12 replaces with the restored one.
       attr_accessor :computer
 
       def initialize(computer, options)
         @computer = computer
-        @last = options.snapshot? ? options.media_path.to_s : ""
         @at_finish = options.save_snapshot
+        @autosave = options.frames.zero?
+        @autosave_at = AUTOSAVE_FRAMES
       end
 
       # Saves or restores for F11 or F12, and says whether a restored
@@ -23,38 +29,160 @@ module Badline
       def key(scancode)
         return restore if scancode == Keys::F12
 
-        save if scancode == Keys::F11
+        quicksave if scancode == Keys::F11
         false
       end
 
-      # Saves the machine, and warns when it can't.
-      def save(path = "badline-#{Time.now.strftime('%Y%m%d-%H%M%S')}.vsf")
+      # Saves the machine to the first empty quicksave slot, or else to the
+      # one saved longest ago, and warns when it can't.
+      def quicksave
+        folder = Badline.data_folder("quicksaves")
+        slot = next_slot(folder, "quicksave", SLOTS)
+        save(slot_path(folder, "quicksave", slot), "quicksave #{slot}")
+      rescue SystemCallError => e
+        warn "badline: quicksave: #{e.message}"
+      end
+
+      # Saves the machine, and warns when it can't. Says whether it saved.
+      def save(path, name = "")
         @computer.save_snapshot(path)
-        @last = path
-        puts "Saved #{path}"
+        puts(name.empty? ? "Saved #{path}" : "Saved #{name} to #{path}")
+        true
       rescue Snapshot::FormatError, SystemCallError => e
         warn "badline: #{path}: #{e.message}"
+        false
       end
 
-      # Restores the snapshot last saved or opened into a new machine, and
+      # Restores the newest quicksave or named save into a new machine, and
       # warns when it fails, leaving the machine running as it was.
       def restore
-        if @last.empty?
-          puts "No snapshot to restore, F11 saves one"
+        path = newest
+        if path.empty?
+          puts "No quicksave to restore. F11: Quicksave"
           return false
         end
 
-        @computer = Snapshot.load(@last) { |line| puts line }
-        puts "Restored #{@last}"
-        true
+        restore_from(path)
+      rescue SystemCallError => e
+        warn "badline: quicksave: #{e.message}"
+        false
+      end
+
+      # Autosaves once the machine has run AUTOSAVE_FRAMES frames since the
+      # last, quietly. A machine that can't be saved stops autosaving after
+      # one warning.
+      def tick(frames)
+        return unless @autosave && frames >= @autosave_at
+
+        @autosave_at = frames + AUTOSAVE_FRAMES
+        folder = Badline.data_folder("autosaves")
+        @computer.save_snapshot(slot_path(folder, "autosave", next_slot(folder, "autosave", AUTOSAVES)))
       rescue Snapshot::FormatError, SystemCallError => e
-        warn "badline: #{@last}: #{e.message}"
+        @autosave = false
+        warn "badline: autosave: #{e.message}"
+      end
+
+      # The snapshots in one of the data folders, `quicksaves`, `autosaves`
+      # or `saves`, newest first.
+      def list(name)
+        folder = Badline.data_folder(name)
+        paths = Dir.children(folder).select { |child| File.extname(child).casecmp?(".vsf") }
+        paths.map { |child| File.join(folder, child) }.sort_by { |path| -modified(path) }
+      rescue SystemCallError
+        []
+      end
+
+      # Whether a save in the saves folder has the name.
+      def named?(name) = File.exist?(File.join(Badline.data_folder("saves"), "#{name}.vsf"))
+
+      # Saves the machine as `name` in the saves folder, and says whether it
+      # did: a name already taken is overwritten only with `replace`.
+      def save_named(name, replace: false)
+        path = File.join(Badline.data_folder("saves"), "#{name}.vsf")
+        return false if File.exist?(path) && !replace
+
+        save(path, name)
+      rescue SystemCallError => e
+        warn "badline: #{name}: #{e.message}"
         false
       end
 
+      # `base` and the lowest number no named save has yet.
+      def free_name(base)
+        folder = Badline.data_folder("saves")
+        number = 1
+        number += 1 while File.exist?(File.join(folder, "#{base} #{number}.vsf"))
+        "#{base} #{number}"
+      rescue SystemCallError
+        "#{base} 1"
+      end
+
+      # Restores the snapshot at `path` into a new machine, and says whether
+      # it did.
+      def load(path) = restore_from(path)
+
+      # When the snapshot at `path` was saved, as HH:MM:SS.
+      def time_of(path)
+        time = File.mtime(path)
+        format("%<hour>02d:%<minute>02d:%<second>02d", hour: time.hour, minute: time.min, second: time.sec)
+      end
+
       def finish
         save(@at_finish) unless @at_finish.empty?
       end
+
+      private
+
+      def restore_from(path)
+        @computer = Snapshot.load(path) { |line| puts line }
+        puts "Restored #{name_of(path)} from #{path}"
+        true
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+        false
+      end
+
+      def next_slot(folder, kind, count)
+        empty = (1..count).find { |slot| !File.exist?(slot_path(folder, kind, slot)) }
+        return empty unless empty.nil?
+
+        (1..count).min_by { |slot| modified(slot_path(folder, kind, slot)) }
+      end
+
+      def slot_path(folder, kind, slot) = File.join(folder, "#{kind}-#{slot}.vsf")
+
+      # The .vsf in quicksaves/ or saves/ written last, or "" when there's
+      # none.
+      def newest
+        found = ""
+        found_at = 0
+        %w[quicksaves saves].each do |name|
+          folder = Badline.data_folder(name)
+          Dir.children(folder).each do |child|
+            next unless File.extname(child).casecmp?(".vsf")
+
+            path = File.join(folder, child)
+            at = modified(path)
+            next unless found.empty? || at > found_at
+
+            found = path
+            found_at = at
+          end
+        end
+        found
+      end
+
+      def name_of(path)
+        folder = Badline.data_folder("quicksaves")
+        slot = (1..SLOTS).find { |n| slot_path(folder, "quicksave", n) == path }
+        slot.nil? ? File.basename(path, ".vsf") : "quicksave #{slot}"
+      end
+
+      # The modification time in nanoseconds.
+      def modified(path)
+        time = File.mtime(path)
+        (time.tv_sec * 1_000_000_000) + time.nsec
+      end
     end
   end
 end