badline 0.7.0 → 0.9.0

data/lib/badline/frontend/menu_dialogs.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's screens that take over its panel: the file browser
+    # 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: %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", snapshot: "LOAD A SAVE" }.freeze
+
+      ESCAPE = 41
+      RETURN = 40
+      SPACE = 44
+
+      # The machine Quick open started or a save loaded.
+      attr_reader :computer
+
+      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? || @name_field.open?
+
+      # 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(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)
+
+      # Puts a dropped disk or tape in its device, or asks before a
+      # cartridge or a program starts, and says whether it asks. Other
+      # files are left alone.
+      def drop(path)
+        extension = File.extname(path).downcase
+        return @media.insert(:disk, path) && false if EXTENSIONS[:disk].include?(extension)
+        return @media.insert(:tape, path) && false if EXTENSIONS[:tape].include?(extension)
+        return false unless EXTENSIONS[:program].include?(extension)
+
+        @confirmation.ask(extension == ".crt" ? :cartridge : :start, path)
+        true
+      end
+
+      # Handles a key, and returns :resume or :swap once a question is
+      # 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)
+
+        direction = PauseMenu::ARROWS[scancode]
+        @buttons.shift(direction == :up ? -1 : 1, 1) if %i[up down].include?(direction)
+        nil
+      end
+
+      # Handles a click on the browser's list at `top`, or on a question's
+      # answer, `action`.
+      def click(action, top) = action == :browse ? browsed(@browser.click(top)) : answer(action)
+
+      def scroll(rows) = @browser.scroll(rows)
+
+      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?
+
+        @name_field.draw(left, top, width)
+      end
+
+      private
+
+      # Puts the disk or tape picked in, or asks before a cartridge or
+      # Quick open power cycles the machine, and leaves the browser, as Esc
+      # does.
+      def browsed(picked)
+        return nil if picked.nil?
+
+        kind = @browsing
+        @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)
+        else
+          @confirmation.ask(kind == :cartridge ? :cartridge : :start, picked)
+        end
+        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)
+        question = @confirmation.close
+        return nil unless action == :confirm
+
+        path = question[1]
+        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
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/menu_media.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+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: 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
+
+      # 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 = []
+        @problem = ""
+        @computer = nil
+      end
+
+      def writable? = @writable
+
+      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. A list puts its first disk in.
+      def insert(kind, path)
+        @problem = ""
+        if kind == :disk
+          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
+      rescue ArgumentError, SystemCallError, Storage::TAP::FormatError, Storage::T64::FormatError,
+             Storage::G64Image::FormatError => e
+        @problem = e.message
+      end
+
+      # Does what the Drive page's :eject_disk, :previous_disk, :next_disk,
+      # :protect or :unprotect asks.
+      def drive(action)
+        case action
+        when :eject_disk then eject_disk
+        when :previous_disk then step_disk(-1)
+        when :next_disk then step_disk(1)
+        else writable(action == :unprotect)
+        end
+      end
+
+      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?
+      end
+
+      # The disks of the set the disk in the drive belongs to.
+      def disk_set
+        return [] if @disk_path.empty?
+
+        unless @set_path == @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
+      end
+
+      # Puts the disk `step` before or after this one in its set in the
+      # drive, if there is one.
+      def step_disk(step)
+        set = disk_set
+        index = set.index(@disk_path)
+        return if index.nil? || !(index + step).between?(0, set.size - 1)
+
+        insert(:disk, set[index + step])
+      end
+
+      # Swaps the cartridge for the one at `path`, which power cycles the
+      # machine, and says whether it went in.
+      def attach_cartridge(path)
+        @problem = ""
+        Media.attach(@computer, path)
+        true
+      rescue ArgumentError, SystemCallError, Storage::CRTFile::FormatError, Cartridge::UnsupportedTypeError => e
+        @problem = e.message
+        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
+        cartridge = @computer.address_bus.cartridge
+        cartridge.nil? ? "" : cartridge.name
+      end
+
+      # Takes the cartridge out with the power off.
+      def remove_cartridge
+        @computer.address_bus.detach_cartridge
+        @computer.power_cycle!
+      end
+
+      # A new machine started on `path`, as the command line would, or nil
+      # when it won't start.
+      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,
+             Storage::G64Image::FormatError, Cartridge::UnsupportedTypeError => e
+        @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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The pause menu's sections, each showing a part of the machine's
+    # hardware as it stands, in one column: what's there, and under it a
+    # row for each thing to do, a setting showing its value on the right,
+    # which a press steps on.
+    class MenuPages
+      TEXT = PauseMenu::TEXT
+      DIM = PauseMenu::DIM
+      LINE = 12
+      COLUMNS = 25
+      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
+
+      # The disks, tapes and cartridges the pages put in and take out.
+      attr_reader :media
+
+      def initialize(painter, buttons, media_path, options, snapshots)
+        @snapshots = snapshots
+        @recent = []
+        @painter = painter
+        @buttons = buttons
+        @media = MenuMedia.new(media_path, options.writable?)
+        @reu_kb = options.reu
+        @computer = nil
+        @controls = nil
+        @sound = nil
+        @left = 0
+        @top = 0
+      end
+
+      # The machine the pages show and change.
+      def machine(computer, controls, sound)
+        @computer = computer
+        @media.computer = computer
+        @controls = controls
+        @sound = sound
+      end
+
+      def draw(page, left, top)
+        problem = @media.problem
+        @painter.text(left, top + 186, problem[0, COLUMNS], WARNING) unless problem.empty?
+        @left = left
+        @top = top
+        case page
+        when :drive then draw_drive
+        when :datasette then draw_datasette
+        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)
+        when :tape_stop then @computer.datasette.stop!
+        when :tape_down then @computer.datasette.play!
+        when :tape_rewind then @computer.datasette.rewind
+        when :tape_eject then @computer.datasette.eject
+        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 :reset then @computer.reset!
+        when :power_cycle then @computer.power_cycle!
+        else pick_port(action)
+        end
+      end
+
+      private
+
+      def draw_drive
+        media = @media
+        inserted = media.inserted?
+        set = inserted ? media.disk_set : []
+        place = set.size < 2 ? "" : " #{set.index(media.disk_path).to_i + 1} OF #{set.size}"
+        info("DISK#{place}", inserted ? File.basename(media.disk_path) : "")
+        row("INSERT...", :insert_disk)
+        row("EJECT", :eject_disk)
+        unless set.size < 2
+          row("PREVIOUS DISK", :previous_disk)
+          row("NEXT DISK", :next_disk)
+        end
+        toggle("WRITABLE", :writable, [%w[OFF ON], %i[protect unprotect], media.writable? ? 1 : 0])
+        skip
+        info("DEVICE", @computer.drive1541.nil? ? "FAST LOADING" : "1541, TRUE DRIVE")
+      end
+
+      def draw_datasette
+        datasette = @computer.datasette
+        tape = datasette.tape
+        info("TAPE", tape.nil? ? "" : File.basename(tape.path))
+        row("INSERT...", :insert_tape)
+        row("EJECT", :tape_eject)
+        toggle("PLAY", :tape_play, [%w[UP DOWN], %i[tape_stop tape_down], datasette.playing? ? 1 : 0])
+        row("REWIND", :tape_rewind)
+        skip
+        info("MOTOR", datasette.motor? ? "ON" : "OFF")
+      end
+
+      def draw_expansion
+        cartridge = @computer.address_bus.cartridge
+        info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
+        row("INSERT...", :insert_cartridge)
+        row("REMOVE", :remove_cartridge)
+        row("FREEZE", :freeze) if !cartridge.nil? && cartridge.freezer?
+        return if @reu_kb.nil?
+
+        skip
+        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
+
+      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])
+      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)
+        skip
+        row("QUIT", :quit)
+      end
+
+      # A label, and its value under it, or NONE in the dim colour when the
+      # value is empty.
+      def info(label, value)
+        @painter.text(@left, @top, label, DIM)
+        if value.empty?
+          @painter.text(@left, @top + LINE, "NONE", DIM)
+        else
+          @painter.text(@left, @top + LINE, Painter.fit(value, COLUMNS), TEXT)
+        end
+        @top += (LINE * 2) + 6
+      end
+
+      def row(label, action, value = "")
+        @buttons.row([@left, @top, ROW_WIDTH], label, action, value)
+        @top += Buttons::HEIGHT + 2
+      end
+
+      def toggle(label, action, choices)
+        @buttons.toggle([@left, @top, ROW_WIDTH], label, action, choices)
+        @top += Buttons::HEIGHT + 2
+      end
+
+      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/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/painter.rb

@@ -95,6 +95,16 @@ module Badline
 
       def self.width(string, scale: 1) = string.length * GLYPH * scale
 
+      # The string cut to `columns` characters in its middle, so both its
+      # start and its end show.
+      def self.fit(string, columns)
+        return string if string.length <= columns
+
+        head = (columns - 3) / 2
+        tail = columns - 3 - head
+        "#{string[0, head]}...#{string[string.length - tail, tail]}"
+      end
+
       def icon(name, left, top, rgb, scale: 1)
         tint(rgb)
         place(top, GLYPH * scale)