badline 0.7.0 → 0.9.0

data/lib/badline/frontend/pause_menu.rb

@@ -0,0 +1,264 @@
+# 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 = ["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
+      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
+      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, snapshots)
+        media_path = options.media_path.to_s
+        @painter = painter
+        @buttons = Buttons.new(painter, [TEXT, BRIGHT, PANEL, FILL])
+        @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, 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
+
+      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)
+        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)
+        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
+
+      # 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.
+      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/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_reader :computer
+      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

data/lib/badline/frontend/sound.rb

@@ -13,6 +13,8 @@ module Badline
     # only happens unpaced.
     #
     # Each frame's samples go to SDL through an IO::Buffer of 16-bit values.
+    # The SID's cycles are converted at `clock_hz`, the machine's clock, so
+    # an NTSC or Drean machine plays at its own pitch.
     class Sound
       RATE = 44_100
       AHEAD = 0.08
@@ -20,8 +22,9 @@ module Badline
 
       attr_reader :rate, :underruns, :dropped, :queued, :low, :high
 
-      def initialize(sid, wanted, verbose)
+      def initialize(sid, clock_hz, wanted, verbose)
         @sid = sid
+        @clock_hz = clock_hz
         @verbose = verbose
         @device = 0
         @rate = RATE
@@ -37,10 +40,11 @@ module Badline
 
       def on? = @device != 0
 
-      # Plays another machine's SID from here on.
-      def sid=(sid)
+      # Plays another machine's SID from here on, at that machine's clock.
+      def switch(sid, clock_hz)
         @sid = sid
-        sid.record(rate: @rate) if on?
+        @clock_hz = clock_hz
+        record if on?
       end
 
       def muted? = @muted
@@ -102,10 +106,12 @@ module Badline
         return puts "No sound: #{SDL.SDL_GetError}" unless on?
 
         @rate = SDL.read_i32(SDL.obtained)
-        @sid.record(rate: @rate)
+        record
         puts "Sound at #{@rate} Hz" if @verbose
       end
 
+      def record = @sid.record(rate: @rate, clock_hz: @clock_hz)
+
       def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
 
       def play(samples, level)
@@ -145,7 +151,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,10 @@ 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/name_field"
+require "badline/frontend/menu_dialogs"
+require "badline/frontend/menu_media"
+require "badline/frontend/menu_pages"

data/lib/badline/kernal_trap/load.rb

@@ -79,15 +79,25 @@ module Badline
       def finish(data, complete)
         if data.empty?
           @bus.poke(0x90, EOI | READ_TIMEOUT)
+          leave_bus(ACPTR_TIMEOUT)
           continue_with(SEARCHING_MESSAGE, FILE_NOT_FOUND_EXIT)
         else
           deliver(data)
           @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
+          leave_bus(ISOUR_TIMEOUT)
           continue_with(SEARCHING_MESSAGE, LOADING_MESSAGE, complete ? LOAD_DONE : BYTE_LOOP)
         end
         @bus.poke(0xb9, LOAD_SECONDARY)
       end
 
+      # A load ends with the UNLISTEN that closes the file, a byte sent,
+      # and a missing file with the ACPTR that timed out. Either way it
+      # releases ATN, the clock and the data line on CIA 2's port A.
+      def leave_bus(timer_high)
+        time_serial_byte(timer_high)
+        release_serial_lines
+      end
+
       def low_memory?(data)
         load? && data.length > 2 && load_address(data) < 0x0334
       end

data/lib/badline/kernal_trap/routine.rb

@@ -10,6 +10,12 @@ module Badline
 
       DEVICE = 8
 
+      # Timer B's latch high byte as ISOUR and ACPTR set it, and the
+      # control value both start it with: force load, one-shot, start.
+      ISOUR_TIMEOUT = 0x04
+      ACPTR_TIMEOUT = 0x01
+      TIMER_ONE_SHOT_START = 0x19
+
       def initialize(cpu:, bus:)
         @cpu = cpu
         @bus = bus
@@ -21,6 +27,28 @@ module Badline
         @bus.io_port.kernal?
       end
 
+      # The ROM times each byte on the serial bus with CIA 1's timer B,
+      # started one-shot with the high byte of its latch set: ISOUR_TIMEOUT
+      # for a byte sent, ACPTR_TIMEOUT for one received.
+      def time_serial_byte(timer_high)
+        @bus.poke(0xdc07, timer_high)
+        @bus.poke(0xdc0f, TIMER_ONE_SHOT_START)
+      end
+
+      # The ROM's release of the serial bus ($EE03): ATN ($EDBE), then the
+      # clock ($EE85), then the data line ($EE97), each a read of CIA 2's
+      # port A, a mask and a write back, so the input bits written back
+      # follow the lines as each one is let go. Returns the last value
+      # written, which the ROM leaves in A.
+      def release_serial_lines
+        value = 0
+        [0xf7, 0xef, 0xdf].each do |mask|
+          value = @bus.peek(0xdd00) & mask
+          @bus.poke(0xdd00, value)
+        end
+        value
+      end
+
       def return_to_caller
         @cpu.program_counter = (uint16(pull_byte, pull_byte) + 1) & 0xffff
       end