badline 0.7.0 → 0.8.0

data/lib/badline/frontend/menu_media.rb

@@ -0,0 +1,128 @@
+# 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. 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
+        @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.
+      def insert(kind, path)
+        @problem = ""
+        if kind == :disk
+          Media.insert_disk(@computer, path, read_only: !@writable)
+          @disk_path = path
+        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
+          @set = 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
+
+      # 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)
+        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
+    end
+  end
+end

data/lib/badline/frontend/menu_pages.rb

@@ -0,0 +1,198 @@
+# 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
+
+      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, disk_path, options)
+        @painter = painter
+        @buttons = buttons
+        @media = MenuMedia.new(disk_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
+        else draw_power
+        end
+      end
+
+      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
+
+      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/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)

data/lib/badline/frontend/pause_menu.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The emulator's pause menu, which F9 opens over the frozen picture.
+    # The machine stands still while it's open. Its sections follow the
+    # machine's hardware: the drive, the datasette, the expansion port, the
+    # control ports, the sound and the power. It's drawn in colours outside
+    # the C64's palette, so it reads as the emulator's and not the
+    # machine's, and F9 or Esc closes it again.
+    #
+    # INSERT on a page opens the file browser for that device. Quick open
+    # starts a file as the command line does, in a new machine, and it and
+    # 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
+      DISKS = %w[.d64 .d71 .d81 .g64 .t64].freeze
+
+      PANEL = 0x1d2230
+      EDGE = 0x3a4256
+      TEXT = 0xc9d1e0
+      BRIGHT = 0xffc66d
+      DIM = 0x6b7489
+      FILL = 0x343c50
+
+      LEFT = 16
+      TOP = 16
+      WIDTH = Screen::WIDTH - 32
+      HEIGHT = Screen::HEIGHT - 32
+      BODY = 154
+
+      ESCAPE = 41
+      RETURN = 40
+      SPACE = 44
+      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)
+        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)
+        @open = false
+        @section = 0
+      end
+
+      # The path of the disk the command line puts in device 8, or an empty
+      # one for other media.
+      def self.disk_path(path)
+        return "" if path.empty?
+        return path if File.directory?(path)
+
+        DISKS.include?(File.extname(path).downcase) ? path : ""
+      end
+
+      def open? = @open
+
+      # The machine Quick open started, which the app runs in place of the
+      # one before once #frame returns :swap.
+      def computer = @dialogs.computer
+
+      def show(computer, controls, sound)
+        @open = true
+        @buttons.focus = PAGES[@section]
+        @pages.machine(computer, controls, sound)
+        SDL.SDL_SetRelativeMouseMode(0)
+        draw
+      end
+
+      def close
+        @open = false
+      end
+
+      # Opens on the file the SDL event says was dropped on the window,
+      # and says whether the menu stays open to ask about it: a disk or tape
+      # goes straight in, and anything else asks first.
+      def drop(computer, controls, sound)
+        show(computer, controls, sound)
+        file = SDL.event_file(SDL.event)
+        asks = @dialogs.drop(LibC.strstr(file, ""))
+        LibC.free(file)
+        asks
+      end
+
+      # Handles a key pressed while the menu is open: the arrows move
+      # between the buttons, and a section opens as they reach it, Return
+      # or Space presses the button, and F9 or Esc closes the menu. While
+      # the file browser or a question is open, the keys go to it, and Esc
+      # goes back to the page. Returns the action the app has to take on,
+      # as #click does.
+      def key(scancode)
+        return :resume if scancode == Keys::F9
+        return @dialogs.key(scancode) if @dialogs.open?
+        return :resume if scancode == ESCAPE
+        return choose(@buttons.focus) if [RETURN, SPACE].include?(scancode)
+
+        direction = ARROWS[scancode]
+        move(direction) unless direction.nil?
+        nil
+      end
+
+      # Handles a click, and returns the action the app has to take on, if
+      # any: :resume, :quit, :freeze or :swap.
+      def click(left, top)
+        action = @buttons.action_at(left, top)
+        return @dialogs.click(action, top) if %i[browse confirm cancel].include?(action)
+
+        choose(action)
+      end
+
+      # Handles the events that came in, draws the menu over the frozen
+      # picture, dimmed, and returns the action the app has to take on, if
+      # any, leaving the events after one for the machine. Key releases
+      # still reach the machine, so no key stays held down while it stands
+      # still.
+      def frame(renderer, texture, controls)
+        action = nil
+        action = event(SDL.event_type(SDL.event), controls) while action.nil? && SDL.SDL_PollEvent(SDL.event) != 0
+        SDL.SDL_SetTextureColorMod(texture, 96, 96, 96)
+        SDL.SDL_RenderClear(renderer)
+        SDL.SDL_RenderCopy(renderer, texture, nil, nil)
+        SDL.SDL_SetTextureColorMod(texture, 255, 255, 255)
+        draw
+        SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
+        SDL.SDL_RenderPresent(renderer)
+        SDL.SDL_Delay(10)
+        action
+      end
+
+      def draw
+        painter = @painter
+        @buttons.forget
+        painter.box(LEFT, TOP, WIDTH, HEIGHT, PANEL)
+        painter.box(LEFT, TOP + 24, WIDTH, 1, EDGE)
+        painter.text(LEFT + 8, TOP + 9, "PAUSED", BRIGHT)
+        resume = "RESUME"
+        @buttons.plain(LEFT + WIDTH - 8 - Painter.width(resume) - (Buttons::PAD * 2), TOP + 7, resume, :resume)
+        return @dialogs.draw(LEFT + 8, TOP + 34, WIDTH - 16) if @dialogs.open?
+
+        painter.box(BODY - 8, TOP + 32, 1, HEIGHT - 56, EDGE)
+        draw_sections
+        @buttons.plain(LEFT + 6, TOP + HEIGHT - 28, "QUICK OPEN...", :quick_open)
+        painter.text(LEFT + 8, TOP + HEIGHT - 12, "F9/ESC: RESUME", DIM)
+        @pages.draw(PAGES[@section], BODY, TOP + 34)
+      end
+
+      private
+
+      def choose(pressed)
+        return nil if pressed.nil?
+
+        action = @buttons.resolve(pressed)
+        index = PAGES.index(action)
+        unless index.nil?
+          @section = index
+          return nil
+        end
+        return action if %i[resume quit freeze].include?(action)
+
+        menu_action(action)
+      end
+
+      def menu_action(action)
+        case action
+        when :insert_disk then @dialogs.browse(:disk)
+        when :insert_tape then @dialogs.browse(:tape)
+        when :insert_cartridge then @dialogs.browse(:cartridge)
+        when :quick_open then @dialogs.browse(:program)
+        when :remove_cartridge then @dialogs.ask_remove
+        else @pages.perform(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.
+      def move(direction)
+        focus = @buttons.focus
+        section = focus == :quick_open ? PAGES.size : PAGES.index(focus)
+        if focus == :resume
+          @buttons.focus = PAGES[@section] if %i[down left].include?(direction)
+        elsif section.nil?
+          move_in_page(direction)
+        else
+          move_in_sections(section, direction)
+        end
+      end
+
+      # Up and down go through the page's rows, and left goes back to its
+      # section.
+      def move_in_page(direction)
+        case direction
+        when :up, :down then @buttons.shift(direction == :up ? -1 : 1, PAGES.size + 2)
+        when :left then @buttons.focus = PAGES[@section]
+        end
+      end
+
+      def move_in_sections(section, direction)
+        case direction
+        when :up then section.zero? ? @buttons.focus = :resume : open_section(section - 1)
+        when :down then section < PAGES.size - 1 ? open_section(section + 1) : @buttons.focus = :quick_open
+        when :right then @buttons.focus = @buttons.action(PAGES.size + 2) || @buttons.focus if section < PAGES.size
+        end
+      end
+
+      # Opens a section, laid out at once, so keys that come before the next
+      # frame find its rows.
+      def open_section(index)
+        @section = index
+        @buttons.focus = PAGES[index]
+        draw
+      end
+
+      def event(type, controls)
+        event = SDL.event
+        case type
+        when SDL::QUIT then :quit
+        when SDL::KEYDOWN then key_down(SDL.event_scancode(event), SDL.event_repeat(event))
+        when SDL::KEYUP then controls.key(SDL.event_scancode(event), false) && nil
+        when SDL::MOUSEMOTION then @buttons.point(SDL.event_x(event), SDL.event_y(event)) && nil
+        when SDL::MOUSEBUTTONDOWN
+          SDL.event_button(event) == 1 ? click(SDL.event_x(event), SDL.event_y(event)) : nil
+        when MOUSEWHEEL then @dialogs.scroll(-3 * SDL.event_x(event)) && nil
+        end
+      end
+
+      # A key held down repeats only the arrows.
+      def key_down(scancode, repeat)
+        repeat.zero? || ARROWS.key?(scancode) ? key(scancode) : nil
+      end
+
+      def draw_sections
+        top = TOP + 32
+        SECTIONS.each_with_index do |name, index|
+          @buttons.plain(LEFT + 6, top, name.ljust(14), PAGES[index], on: index == @section)
+          top += Buttons::HEIGHT + 2
+        end
+      end
+    end
+  end
+end

data/lib/badline/frontend/snapshots.rb

@@ -10,7 +10,7 @@ module Badline
       KEYS = [Keys::F11, Keys::F12].freeze
 
       # The machine running, which F12 replaces with the restored one.
-      attr_reader :computer
+      attr_accessor :computer
 
       def initialize(computer, options)
         @computer = computer

data/lib/badline/frontend/sound.rb

@@ -145,7 +145,6 @@ module Badline
 
       def underrun!
         @underruns += 1
-        puts "Running below real time, so the sound will stutter." if @underruns == 1
         halt
       end
     end

data/lib/badline/frontend/timeline.rb

@@ -15,7 +15,7 @@ module Badline
         unless options.screenshot.empty? || options.frames.zero?
           @events += [Options::Event.new(options.frames, "screenshot", options.screenshot)]
         end
-        @read_only = options.read_only?
+        @read_only = !options.writable?
         @program = options.program
         @releases = []
         @failed = false
@@ -63,6 +63,10 @@ module Badline
                .map { |event| Timeline.path(event.argument, frame) }
       end
 
+      # Presses the freeze button after `frame`, and lets go of it as the
+      # events do.
+      def press_freeze(computer, frame) = freeze(computer, Options::Event.new(frame, "freeze", ""))
+
       # Whether the run ends at the frame: at a quit, or once an event failed.
       def quit?(frame) = @failed || @events.any? { |event| event.frame == frame && event.action == "quit" }
 

data/lib/badline/frontend.rb

@@ -11,6 +11,7 @@ require "badline/frontend/screenshot"
 require "badline/frontend/timeline"
 require "badline/frontend/sound"
 require "badline/frontend/pacer"
+require "badline/frontend/frame_report"
 require "badline/frontend/controls"
 require "badline/frontend/pad_port"
 require "badline/frontend/gamepads"
@@ -30,3 +31,9 @@ require "badline/frontend/info_view"
 require "badline/frontend/player_commands"
 require "badline/frontend/player_screen"
 require "badline/frontend/player_window"
+require "badline/frontend/pause_menu"
+require "badline/frontend/file_browser"
+require "badline/frontend/confirmation"
+require "badline/frontend/menu_dialogs"
+require "badline/frontend/menu_media"
+require "badline/frontend/menu_pages"