badline 0.8.0 → 0.9.0

data/lib/badline/audio/jukebox.rb

@@ -7,9 +7,11 @@ module Badline
     # turn the queue's shuffle, loop and all-subtunes modes on and off, and
     # quit, and the status line follows along. Seeking runs the subtune
     # silently up to where it was asked to go: on from where it is to go
-    # forward, and from the start again to go back. A subtune that plays to
-    # its end moves on as Media::Queue#advance says. It stops at the end of
-    # the queue, on q, or on Ctrl-C.
+    # forward, and from the latest of its Checkpoints at or before there to
+    # go back, or to go forward when that checkpoint is further on than
+    # where the subtune is. A subtune that plays to its end moves on as
+    # Media::Queue#advance says. It stops at the end of the queue, on q, or
+    # on Ctrl-C.
     #
     # `renderer` builds the renderer for an entry's subtune at the sink's
     # rate, or returns nil for an entry that can't play, which is skipped
@@ -34,6 +36,9 @@ module Badline
         @backward = false
         @below_at = -BELOW_NOTE
         @from = 0.0
+        @entry = nil
+        @subtune = 0
+        @checkpoints = Checkpoints.new
       end
 
       # Returns the result of the last subtune's Playback#play, or :unplayable
@@ -77,6 +82,7 @@ module Badline
       end
 
       def play(entry, subtune)
+        @checkpoints = Checkpoints.new unless entry.equal?(@entry) && subtune == @subtune
         @entry = entry
         @subtune = subtune
         @elapsed = 0.0
@@ -84,6 +90,7 @@ module Badline
         return :unplayable if renderer.nil?
 
         renderer.from = @from
+        renderer.checkpoints = @checkpoints
         @streaming = renderer
         @from = 0.0
         @backward = false
@@ -127,7 +134,7 @@ module Badline
 
       def seek(seconds)
         target = seconds.clamp(0.0, [@length.call(@entry, @subtune) - 1.0, 0.0].max)
-        return @streaming.from = target if target > @elapsed
+        return @streaming.from = target if target > @elapsed && !@streaming.checkpoint_ahead?(target)
 
         @from = target
         skip

data/lib/badline/audio/machine_player.rb

@@ -39,6 +39,22 @@ module Badline
 
       def clock_hz = @computer.region.clock_hz
 
+      # The whole machine, as Computer#snapshot takes it, and the extra SIDs,
+      # once it plays.
+      def save_state(out)
+        @computer.save_state(out)
+        @extras.each { |sid| sid.save_state(out) }
+      end
+
+      # Takes a machine that hasn't started to where #save_state found one,
+      # in place of #start.
+      def load_state(input)
+        @computer.load_state(input)
+        @extras.each { |sid| sid.load_state(input) }
+        @stereo.synthesize!
+        @started = true
+      end
+
       # Advances one frame of the machine, or `budget` cycles if that is
       # shorter, then yields whatever the SIDs recorded over it, in stereo.
       # Returns the cycles advanced.

data/lib/badline/audio/renderer.rb

@@ -35,10 +35,15 @@ module Badline
 
       # Where #stream starts: the frames before it are rendered as fast as
       # they go and yielded without their samples, so the seconds rendered
-      # still count up to it. Set while streaming, it skips ahead from the
-      # frame rendered last.
+      # still count up to it. Rendering picks up from the latest of the
+      # checkpoints at or before it, without the frames before that. Set
+      # while streaming, it skips ahead from the frame rendered last.
       attr_writer :from
 
+      # The Checkpoints this subtune's renderers keep as they go and start
+      # from, for a player that seeks. Without them nothing is kept.
+      attr_writer :checkpoints
+
       def initialize(tune, seconds:, subtune: nil, rate: DEFAULT_RATE, sid_models: tune.sid_models)
         @tune = tune
         @seconds = seconds
@@ -52,6 +57,8 @@ module Badline
         @rendered = 0.0
         @observer = ->(_samples, _rendered) {}
         @from = 0.0
+        @played = 0
+        @checkpoints = nil
       end
 
       def silence=(seconds)
@@ -65,7 +72,6 @@ module Badline
       # Yields the seconds rendered so far after every frame.
       def render(path)
         container = container_for(path)
-        player.start
         container.open(path, rate: @rate, channels: 2) do |writer|
           each_frame do |samples, seconds|
             samples.each { |sample| writer << sample }
@@ -76,9 +82,16 @@ module Badline
 
       # Starts the tune, then yields each frame's samples along with the
       # seconds rendered so far.
-      def stream(&)
-        player.start
-        each_frame(&)
+      def stream(&) = each_frame(&)
+
+      # Whether the latest checkpoint at or before `seconds` lies past the
+      # frame rendered last, so that a seek there gets there sooner from it
+      # than on from here.
+      def checkpoint_ahead?(seconds)
+        checkpoints = @checkpoints
+        return false if checkpoints.nil?
+
+        checkpoints.reach((seconds * player.clock_hz).round) > @played
       end
 
       private
@@ -101,19 +114,77 @@ module Badline
       end
 
       def each_frame
-        player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
+        clock_hz = player.clock_hz
         total = total_cycles
-        remaining = total
+        @played = start((@from * clock_hz).round)
+        remaining = total - @played
         while remaining.positive?
           samples = []
           remaining -= player.frame(remaining) { |sample| samples << sample }
-          @rendered = (total - remaining).fdiv(player.clock_hz)
+          played = total - remaining
+          @played = played
+          @rendered = played.fdiv(clock_hz)
           @observer.call(samples, @rendered)
           yield(@rendered < @from ? [] : samples, @rendered)
           break if fallen_silent?(samples)
+
+          save_checkpoint(played, clock_hz)
         end
       end
 
+      # Starts the player and its recording, from the latest checkpoint at
+      # or before `cycles` if there is one, and returns the cycles into the
+      # subtune it starts at.
+      def start(cycles)
+        state = @checkpoints&.latest(cycles)
+        return start_afresh if state.nil?
+
+        input = Snapshot::StateReader.new(state)
+        played = input.int
+        resume(input)
+        record
+        player.stereo.sids.each { |sid| sid.load_recording(input) }
+        @level = input.int
+        @still = input.int
+        played
+      end
+
+      def start_afresh
+        player.start
+        record
+        0
+      end
+
+      def record = player.stereo.record(rate: @rate, filter_chunk: @filter_chunk, clock_hz: player.clock_hz)
+
+      # Restores the player as it was, then puts back the SID models chosen
+      # for this renderer.
+      def resume(input)
+        sids = player.stereo.sids
+        chosen = sids.map(&:model)
+        sids.each { |sid| refit(sid, Snapshot::Setup::SID_MODELS.fetch(input.int)) }
+        player.load_state(input)
+        sids.each_with_index { |sid, index| refit(sid, chosen[index]) }
+      end
+
+      def refit(sid, model)
+        sid.model = model unless sid.model == model
+      end
+
+      def save_checkpoint(played, clock_hz)
+        checkpoints = @checkpoints
+        return if checkpoints.nil? || !checkpoints.due?(played, clock_hz)
+
+        sids = player.stereo.sids
+        out = Snapshot::StateWriter.new
+        out.int(played)
+        sids.each { |sid| out.int(Snapshot::Setup::SID_MODELS.index(sid.model) || 0) }
+        player.save_state(out)
+        sids.each { |sid| sid.save_recording(out) }
+        out.int(@level).int(@still)
+        checkpoints.keep(played, out.state)
+      end
+
       # Counts the samples since the output last strayed more than QUIET
       # from where it settled.
       def fallen_silent?(samples)

data/lib/badline/audio/stereo.rb

@@ -65,11 +65,9 @@ module Badline
       private
 
       def both(samples)
-        i = 0
-        while i < samples.size
-          yield samples[i]
-          yield samples[i]
-          i += 1
+        samples.each do |sample|
+          yield sample
+          yield sample
         end
       end
 

data/lib/badline/audio.rb

@@ -6,6 +6,7 @@ require "badline/audio/aiff"
 require "badline/audio/stereo"
 require "badline/audio/bare_player"
 require "badline/audio/machine_player"
+require "badline/audio/checkpoints"
 require "badline/audio/renderer"
 require "badline/audio/playback"
 require "badline/audio/terminal"

data/lib/badline/computer/attachments.rb

@@ -50,7 +50,7 @@ module Badline
       def detach_drive1541
         return unless @drive1541
 
-        @iec_bus&.detach(@drive1541)
+        @iec_bus.detach(@drive1541)
         @drive1541 = nil
         @serial_trap&.device = serial_trap_device
       end
@@ -95,10 +95,10 @@ module Badline
         @save_trap.load_state(input)
       end
 
-      # The serial bus, whose presence decides what CIA 2's port A reads,
-      # and a true 1541 on it.
+      # A true 1541 on the serial bus. The leading flag is the bus itself,
+      # which every machine now has, kept so older snapshots still load.
       def save_serial_bus(out)
-        out.boolean(!@iec_bus.nil?).boolean(!@drive1541.nil?)
+        out.boolean(true).boolean(!@drive1541.nil?)
         return unless @drive1541
 
         out.int(@drive1541.device)
@@ -106,7 +106,7 @@ module Badline
       end
 
       def load_serial_bus(input)
-        iec_bus if input.boolean?
+        input.boolean?
         return detach_drive1541 unless input.boolean?
 
         device = input.int

data/lib/badline/computer.rb

@@ -42,9 +42,13 @@ module Badline
     # TOD clocks count. The KERNAL tells PAL from NTSC by the raster, so
     # every region boots the same ROMs. reu plugs an REU of that many K
     # into the expansion port, where it drives the IRQ line and takes the
-    # bus for its transfers.
-    def initialize(debug: false, reu: nil, **machine)
+    # bus for its transfers. kernal: names the KERNAL ROM
+    # (AddressBus::ROMs::KERNALS), and datasette: false leaves the cassette port
+    # empty, as on the SX-64.
+    def initialize(debug: false, reu: nil, kernal: :c64, datasette: true, **machine)
       @address_bus = AddressBus.new(**machine)
+      @address_bus.kernal = kernal unless kernal == :c64
+      @address_bus.datasette.disconnect! unless datasette
       @cpu = CPU.new(@address_bus, debug:)
       @vic = @address_bus.vic
       @vic.open_bus = -> { @address_bus.ram.peek(@cpu.program_counter) }
@@ -66,7 +70,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
-      @iec_bus = nil
+      @iec_bus = IECBus.new(host: @cia2).tap(&:plug_in!)
       @reu = reu ? plug_reu(reu) : nil
     end
 
@@ -161,19 +165,17 @@ module Badline
     # byte transfers reach the drive. The LOAD and SAVE traps stay, and
     # still serve a mounted image.
     def attach_drive1541(drive)
-      @iec_bus.detach(@drive1541) if @iec_bus && @drive1541
+      @iec_bus.detach(@drive1541) if @drive1541
       drive.host_clock_hz = region.clock_hz
       @drive1541 = drive
       drive.connect(iec_bus)
       @serial_trap&.device = serial_trap_device
     end
 
-    # The serial bus. CIA 2's port A joins it the first time it's asked
-    # for, which plugging in a drive does. Until then port A's serial
-    # inputs float high.
-    def iec_bus
-      @iec_bus ||= IECBus.new(host: @cia2).tap(&:plug_in!)
-    end
+    # The serial bus, which CIA 2's port A drives through the C64's own
+    # inverters and reads back on PA6 and PA7, with or without a drive on
+    # it.
+    attr_reader :iec_bus
 
     def capture_output
       @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus).tap do |trap|

data/lib/badline/core.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# The emulator core: the machine, its chips, media and traps, and the
+# snapshot state Computer saves and restores with, without the options,
+# the rest of the snapshot code, audio or front end. lib/badline.rb and
+# the Spinel harnesses in spinel/ load it, so a file the core needs is
+# added here.
+require "badline/version"
+require "badline/integer_helper"
+require "badline/region"
+require "badline/model"
+require "badline/addressable"
+require "badline/memory"
+require "badline/color_memory"
+require "badline/rom"
+require "badline/ram_expansion"
+require "badline/address_bus"
+require "badline/instruction"
+require "badline/instruction_set"
+require "badline/status"
+require "badline/keyboard"
+require "badline/joystick"
+require "badline/control_ports"
+require "badline/input"
+require "badline/cycleable"
+require "badline/datasette"
+require "badline/time_of_day"
+require "badline/cia"
+require "badline/via"
+require "badline/sid"
+require "badline/debug_register"
+require "badline/reu"
+require "badline/interrupts"
+require "badline/traps"
+require "badline/cpu"
+require "badline/vic"
+require "badline/keyboard_buffer"
+require "badline/iec_bus"
+require "badline/drive1541"
+require "badline/snapshot/state"
+require "badline/snapshot/setup"
+require "badline/computer"
+require "badline/checkpoint"
+require "badline/storage"
+require "badline/cartridge"
+require "badline/kernal_trap"
+require "badline/chrout_trap"
+require "badline/media"

data/lib/badline/data_path.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Badline
+  class << self
+    attr_writer :data_path
+
+    # The per-user folder badline keeps its own files in. Defaults to
+    # $BADLINE_DATA_PATH, then to the platform's folder for application
+    # data. Assigning nil restores the default. Nothing is created until
+    # data_folder is asked for a subfolder.
+    def data_path
+      @data_path ||= ENV.fetch("BADLINE_DATA_PATH", nil) || default_data_path(RUBY_PLATFORM)
+    end
+
+    # ~/Library/Application Support/badline on macOS, and
+    # $XDG_DATA_HOME/badline or ~/.local/share/badline elsewhere.
+    def default_data_path(platform)
+      return File.join(Dir.home, "Library", "Application Support", "badline") if platform.include?("darwin")
+
+      xdg = ENV.fetch("XDG_DATA_HOME", nil)
+      xdg = File.join(Dir.home, ".local", "share") if xdg.nil? || !xdg.start_with?("/")
+      File.join(xdg, "badline")
+    end
+
+    # The quicksaves, autosaves or saves subfolder of data_path, created
+    # along with data_path if it doesn't exist yet.
+    def data_folder(name)
+      raise ArgumentError, "unknown data folder: #{name}" unless %w[quicksaves autosaves saves].include?(name)
+
+      path = File.join(data_path, name)
+      FileUtils.mkdir_p(path)
+      path
+    end
+  end
+end

data/lib/badline/datasette.rb

@@ -5,11 +5,15 @@ module Badline
   # motor runs with a key pressed, and reports the keys through the cassette
   # sense line on the $01 port.
   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
       @motor = false
       @countdown = 0
@@ -27,7 +31,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
@@ -54,18 +69,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,10 +90,9 @@ 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
 
@@ -99,7 +114,7 @@ module Badline
     private
 
     def press(down)
-      return if down == @playing
+      return if down == @playing || !@connected
 
       @playing = down
       @sense_handler&.call

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/frontend/app.rb

@@ -23,10 +23,10 @@ module Badline
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
         open_window
-        @sound = Sound.new(computer.sid, options.sound?, @verbose)
+        @sound = Sound.new(computer.sid, computer.region.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(@renderer), options, @snapshots)
       end
 
       def run
@@ -66,6 +66,7 @@ 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?
@@ -140,7 +141,7 @@ module Badline
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.sid = computer.sid
+        @sound.switch(computer.sid, computer.region.clock_hz)
         @snapshots.computer = computer
       end
 

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 => e
         warn "#{options.program}: #{options.media_path}: #{e.message}"
         return 1
       end
@@ -44,10 +45,14 @@ 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 model gives the chips, and a .sid tune or --sid the
+    # SID.
     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)
+      model = Model.named(options.model)
+      computer = Computer.new(vic_model: model.vic_model, cia_model: model.cia_model,
+                              sid_model: options.sid_model || Media.sid_model(media, otherwise: model.sid_model),
+                              region: model.region, reu: options.reu, kernal: model.kernal,
+                              datasette: model.datasette)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,

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