badline 0.9.0 → 0.10.0

data/lib/badline/computer/attachments.rb

@@ -22,11 +22,13 @@ module Badline
         return @drive.insert(storage) if @drive
 
         @drive = KernalTrap::Drive.new(storage)
-        load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive: @drive)
-        cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
-        @serial_trap = KernalTrap::Serial.new(cpu:, bus: address_bus, drive: @drive, device: serial_trap_device).install
-        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, drive: @drive)
-        cpu.install_trap(KernalTrap::Save::ADDRESS) { save_trap.call }
+        layout = KernalTrap::C64_LAYOUT
+        load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, layout:, drive: @drive)
+        cpu.install_trap(layout.load) { load_trap.call }
+        @serial_trap = KernalTrap::Serial.new(cpu:, bus: address_bus, layout:, drive: @drive,
+                                              device: serial_trap_device).install
+        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, layout:, drive: @drive)
+        cpu.install_trap(layout.save) { save_trap.call }
       end
 
       # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
@@ -35,8 +37,8 @@ module Badline
       def unmount
         return unless @drive
 
-        cpu.remove_trap(KernalTrap::Load::ADDRESS)
-        cpu.remove_trap(KernalTrap::Save::ADDRESS)
+        cpu.remove_trap(KernalTrap::C64_LAYOUT.load)
+        cpu.remove_trap(KernalTrap::C64_LAYOUT.save)
         @serial_trap.device = nil
         @serial_trap = nil
         @save_trap = nil
@@ -46,6 +48,24 @@ module Badline
       # Whether device 8 serves a disk or directory through the traps.
       def mounted? = !@drive.nil?
 
+      # 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
+
+      # Plugs in a Drive1541, which then runs alongside the C64 on its own
+      # clock and talks to it over the serial bus. The serial traps stop
+      # answering the drive's device number, so the KERNAL's TALK, LISTEN and
+      # 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 @drive1541
+        drive.host_clock_hz = region.clock_hz
+        @drive1541 = drive
+        drive.connect(iec_bus)
+        @serial_trap&.device = serial_trap_device
+      end
+
       # Unplugs the Drive1541, leaving the serial bus with nothing on it.
       def detach_drive1541
         return unless @drive1541
@@ -57,6 +77,26 @@ module Badline
 
       private
 
+      # The device number the serial traps answer: device 8, unless a true
+      # drive is on the bus as device 8.
+      def serial_trap_device
+        @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
+      end
+
+      # CIA 2's port A drives the serial bus, which reads CLK and DATA back
+      # into it.
+      def plug_serial_bus
+        @iec_bus = IECBus.new
+        @cia2.peripheral = @iec_bus
+        @cia2.on_port_a_write { push_serial_lines }
+        push_serial_lines
+      end
+
+      # Pushes the lines CIA 2's port A pulls into the serial bus.
+      def push_serial_lines
+        @iec_bus.host_lines = @cia2.port_a_lines
+      end
+
       def save_cartridge(out)
         cartridge = address_bus.cartridge
         out.boolean(!cartridge.nil?)

data/lib/badline/computer/saved_state.rb

@@ -97,6 +97,7 @@ module Badline
         @init_handlers_lost = [input.int - @init_handlers.length, 0].max
         load_cartridge(input)
         address_bus.load_state(input)
+        push_serial_lines
         @cpu.load_state(input)
         load_trap_drive(input)
         load_serial_bus(input)

data/lib/badline/computer.rb

@@ -12,6 +12,12 @@ module Badline
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
 
+    # The path of the disk or directory device 8 serves through the traps
+    # (Attachments), or an empty one.
+    def mounted_path = @drive.nil? ? "" : @drive.path
+
+    def family = :c64
+
     def region = address_bus.region
 
     def vic = address_bus.vic
@@ -70,7 +76,7 @@ module Badline
       @serial_trap = nil
       @save_trap = nil
       @drive1541 = nil
-      @iec_bus = IECBus.new(host: @cia2).tap(&:plug_in!)
+      plug_serial_bus
       @reu = reu ? plug_reu(reu) : nil
     end
 
@@ -98,6 +104,40 @@ module Badline
       @cycles += 1
     end
 
+    # Runs `count` cycles, one #cycle! after another.
+    def run_cycles(count)
+      i = 0
+      while i < count
+        cycle!
+        i += 1
+      end
+    end
+
+    # Runs cycles until the block returns true or the cycle count passes
+    # `limit`, checking before each cycle.
+    def run_until(limit)
+      cycle! until yield || @cycles > limit
+    end
+
+    # The cycle at which #on_init's handlers run, once the KERNAL has booted.
+    def init_threshold
+      INIT_THRESHOLD
+    end
+
+    # The clock, the raster and the crop of the machine's region, a pixel
+    # to a window pixel.
+    def timing
+      region = address_bus.region
+      Timing.new(clock_hz: region.clock_hz, cycles_per_line: region.cycles_per_line,
+                 lines_per_frame: region.lines_per_frame, crop: region.crop, pixel_width: 1)
+    end
+
+    # The chip whose #display a front end shows.
+    def video = @vic
+
+    # The chip a front end records the machine's sound from.
+    def sound_source = @sid
+
     def load_prg(data)
       uint16(data[0], data[1]).tap do |load_addr|
         ram.write(load_addr, data[2..])
@@ -159,26 +199,11 @@ module Badline
       @restore_pulse = true
     end
 
-    # Plugs in a Drive1541, which then runs alongside the C64 on its own
-    # clock and talks to it over the serial bus. The serial traps stop
-    # answering the drive's device number, so the KERNAL's TALK, LISTEN and
-    # 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 @drive1541
-      drive.host_clock_hz = region.clock_hz
-      @drive1541 = drive
-      drive.connect(iec_bus)
-      @serial_trap&.device = serial_trap_device
-    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
+    # The one-shot has pulsed already, so letting go does nothing.
+    def release_restore; end
 
     def capture_output
-      @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus).tap do |trap|
+      @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus, layout: KernalTrap::C64_LAYOUT).tap do |trap|
         cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
       end
     end
@@ -197,12 +222,6 @@ module Badline
 
     private
 
-    # The device number the serial traps answer: device 8, unless a true
-    # drive is on the bus as device 8.
-    def serial_trap_device
-      @drive1541&.device == KernalTrap::Routine::DEVICE ? nil : KernalTrap::Routine::DEVICE
-    end
-
     # The NMI line is wired-OR between CIA 2, the cartridge and the RESTORE
     # key, and the CPU takes an interrupt on its falling edge.
     def drive_nmi
@@ -258,9 +277,5 @@ module Badline
     def handle_init
       @init_handlers.each(&:call)
     end
-
-    def init_threshold
-      INIT_THRESHOLD
-    end
   end
 end

data/lib/badline/control_ports.rb

@@ -16,13 +16,19 @@ module Badline
   # resistances; close neither and the lines float high. Reading a pot asks the
   # CIA for the current select lines, since a program sets them and then goes
   # straight to SID without touching the ports again.
+  #
+  # A matrix may have rows beyond port A's eight. Their select lines come from
+  # outside the CIA and are pushed into +extra_rows+, bit 0 for the ninth row
+  # upwards, active low like port A; idle, every line is high and none of
+  # those rows is selected. They settle with port A's lines as rows 8 and up,
+  # so their keys reach port B, but port A reads only its own eight.
   class ControlPorts
     PORT1_POTS = 0x40
     PORT2_POTS = 0x80
     FIRE = 0x10
 
     attr_reader :keyboard, :joystick1, :joystick2
-    attr_accessor :device1, :device2, :port_a_source
+    attr_accessor :device1, :device2, :port_a_source, :extra_rows
 
     def initialize(keyboard:, joystick1:, joystick2:)
       @keyboard = keyboard
@@ -31,9 +37,10 @@ module Badline
       @device1 = nil
       @device2 = nil
       @port_a_source = nil
+      @extra_rows = 0xff
     end
 
-    def read_a(port_a, port_b) = scan(port_a, port_b).first
+    def read_a(port_a, port_b) = scan(port_a, port_b).first & 0xff
 
     def read_b(port_a, port_b) = scan(port_a, port_b).last
 
@@ -58,7 +65,7 @@ module Badline
     end
 
     def scan(port_a, port_b)
-      keyboard.scan(port_a & port_bits(@joystick2, @device2),
+      keyboard.scan((port_a & port_bits(@joystick2, @device2)) | (@extra_rows << 8),
                     port_b & port_bits(@joystick1, @device1))
     end
 

data/lib/badline/core.rb

@@ -8,6 +8,7 @@
 require "badline/version"
 require "badline/integer_helper"
 require "badline/region"
+require "badline/timing"
 require "badline/model"
 require "badline/addressable"
 require "badline/memory"
@@ -40,9 +41,11 @@ require "badline/drive1541"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
 require "badline/computer"
+require "badline/vic20"
 require "badline/checkpoint"
 require "badline/storage"
 require "badline/cartridge"
 require "badline/kernal_trap"
 require "badline/chrout_trap"
 require "badline/media"
+require "badline/machine"

data/lib/badline/datasette.rb

@@ -3,7 +3,8 @@
 module Badline
   # The 1530 datasette. Plays a pulse stream into CIA 1's FLAG pin while the
   # motor runs with a key pressed, and reports the keys through the cassette
-  # sense line on the $01 port.
+  # sense line on the $01 port. With RECORD down too, it records the
+  # machine's write line onto the tape instead.
   class Datasette
     # What inserting a tape raises on a machine without a cassette port.
     class Missing < ArgumentError; end
@@ -15,6 +16,9 @@ module Badline
       @tape = tape
       @connected = true
       @playing = false
+      @recording = false
+      @write_high = true
+      @since = 0
       @motor = false
       @countdown = 0
       @flag_handler = nil
@@ -60,6 +64,30 @@ module Badline
     def play! = press(true)
     def stop! = press(false)
 
+    # Presses RECORD and PLAY together.
+    def record!
+      return if !@connected || @tape.nil?
+
+      press(true)
+      @recording = true
+      @since = 0
+    end
+
+    def recording? = @recording
+
+    # The machine's tape write line. While the deck records with its motor
+    # running, each rising edge ends a pulse on the tape, as long as the
+    # time since the edge before, and plays back as a falling edge on the
+    # read line.
+    def write_line=(high)
+      rose = high && !@write_high
+      @write_high = high
+      return unless rose && @recording && running?
+
+      @tape.record_pulse(@since)
+      @since = 0
+    end
+
     def playing? = @playing
 
     # Sense reads low while a key is down on the deck.
@@ -98,6 +126,7 @@ module Badline
 
     def cycle!
       return unless running?
+      return @since += 1 if @recording
 
       @countdown = @tape.next_pulse.to_i if @countdown.zero?
       return if @countdown.zero?
@@ -116,8 +145,17 @@ module Badline
     def press(down)
       return if down == @playing || !@connected
 
+      finish_recording unless down
       @playing = down
       @sense_handler&.call
     end
+
+    # Releasing the keys ends a recording, and writes the tape out.
+    def finish_recording
+      return unless @recording
+
+      @recording = false
+      @tape.save
+    end
   end
 end

data/lib/badline/drive1541/serial_port.rb

@@ -27,7 +27,7 @@ module Badline
 
       attr_reader :bus
 
-      def initialize(device: 8, bus: nil)
+      def initialize(device: 8, bus: IECBus.new)
         @port_b = (0xff & ~(SERIAL_INPUTS | JUMPERS)) | (((device - 8) & 0x03) << 5)
         @host = 0
         self.bus = bus
@@ -38,10 +38,10 @@ module Badline
         latch_host
       end
 
-      # Takes the C64's lines as they stand, for the drive cycles of the
-      # next host cycle.
+      # Takes the C64's lines as the machine last pushed them into the bus,
+      # for the drive cycles of the next host cycle.
       def latch_host
-        @host = @bus ? @bus.host_lines : 0
+        @host = @bus.host_lines
       end
 
       # The C64's lines as last latched. The jumpers and the bus are the
@@ -55,10 +55,7 @@ module Badline
       end
 
       # Whether the C64 has moved ATN since the last latch_host.
-      def atn_moved?
-        lines = @bus ? @bus.host_lines : 0
-        (lines ^ @host).anybits?(IECBus::HOST_ATN_OUT)
-      end
+      def atn_moved? = (@bus.host_lines ^ @host).anybits?(IECBus::HOST_ATN_OUT)
 
       def atn_low? = @bus.atn_low?(@host)
 

data/lib/badline/drive1541/sleep.rb

@@ -8,9 +8,8 @@ module Badline
     # passes go in bulk, and the rest cycle by cycle, which may find the
     # idle loop and put the drive back to sleep.
     #
-    # The drive looks at ATN only when the C64 may have moved it, on a
-    # bus that says when (IECBus#notifies?), and every host cycle on one
-    # that doesn't.
+    # The drive looks at ATN only when the machine may have moved it, as
+    # it pushes its lines into the bus (IECBus#host_lines=).
     module Sleep
       # Whether the drive is skipping its idle loop right now.
       def asleep? = @asleep
@@ -40,10 +39,10 @@ module Badline
         @wake_at = 0
       end
 
-      # A host cycle asleep that may wake the drive. The bus says whether
-      # the next ones need a look at ATN.
+      # A host cycle asleep that may wake the drive. The next ones need no
+      # look at ATN until the machine pushes its lines again.
       def doze
-        @host_still = @serial_bus.notifies?
+        @host_still = true
         if @serial_port.atn_moved?
           settle!
         elsif @slept == @wake_at

data/lib/badline/drive1541.rb

@@ -149,8 +149,8 @@ module Badline
     # The host has run this cycle already, and the drive sees what it did
     # from the next one on (see SerialPort). Asleep, the drive owes the
     # cycles instead, until ATN moves or its counters are due (see Idle).
-    # It looks at ATN only after the C64 wrote CIA 2's port A, on a bus
-    # that says so (see host_written!).
+    # It looks at ATN only after the machine pushed its lines into the bus
+    # (see host_written!).
     def host_cycle!
       if @asleep
         return if (@slept += 1) != @wake_at && @host_still
@@ -169,7 +169,7 @@ module Badline
       plan_wake if @asleep
     end
 
-    # The C64 wrote CIA 2's port A, so ATN may have moved.
+    # The machine pushed its lines into the bus, so ATN may have moved.
     def host_written!
       @host_still = false
     end

data/lib/badline/frontend/app.rb

@@ -3,12 +3,10 @@
 module Badline
   module Frontend
     # Opens the window, then runs the machine a frame at a time: poll
-    # events, clock the frame's cycles, queue the SID's samples, upload the
+    # events, clock the frame's cycles, queue the sound's samples, upload the
     # changed lines, present and wait. Pacer decides the cycles and the wait.
     class App
-      SCALE = 2
       DROPFILE = 0x1000
-      TITLE = "Badline"
 
       # Takes the frame limit, the pacing, the snapshot path, the sound and
       # the verbosity from Options, and runs the timeline's events.
@@ -16,17 +14,21 @@ module Badline
         @computer = computer
         @frame_limit = options.frames
         @verbose = options.verbose?
-        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, region: computer.region)
+        timing = computer.timing
+        @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, timing:)
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
-        @screen = Screen.new(computer.vic)
+        @screen = Screen.new(computer.video, timing.crop)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        open_window
-        @sound = Sound.new(computer.sid, computer.region.clock_hz, options.sound?, @verbose)
+        @window = MachineWindow.new(@screen, timing.pixel_width, vsync: @pacer.vsync?)
+        @pacer.fit(@window.refresh_rate) if @pacer.vsync?
+        @sound = Sound.new(computer.sound_source, timing.clock_hz, options.sound?, @verbose)
         @gamepads = Gamepads.new(computer, @verbose)
         @frame_report = FrameReport.new(@sound)
-        @menu = PauseMenu.new(Painter.new(@renderer), options, @snapshots)
+        @menu = PauseMenu.new(Painter.new(@window.renderer), options, @snapshots)
+        @menu.center(@window.width, @window.height)
+        @scripted = false
       end
 
       def run
@@ -39,7 +41,7 @@ module Badline
         @computer.drive1541&.flush
         @gamepads.close
         @sound.close
-        close_window
+        @window.close
       end
 
       private
@@ -70,36 +72,20 @@ module Badline
         @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?
-      end
-
-      def open_window
-        abort "SDL_Init: #{SDL.SDL_GetError}" unless SDL.SDL_Init(SDL::INIT_VIDEO | SDL::INIT_EVENTS).zero?
-
-        SDL.SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "0")
-        SDL.SDL_SetHint("SDL_MOUSE_RELATIVE_SCALING", "0")
-        @window = SDL.SDL_CreateWindow(
-          TITLE, SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
-          Screen::WIDTH * SCALE, Screen::HEIGHT * SCALE, SDL::WINDOW_RESIZABLE
-        )
-        flags = SDL::RENDERER_ACCELERATED
-        flags |= SDL::RENDERER_PRESENTVSYNC if @pacer.vsync?
-        @renderer = SDL.SDL_CreateRenderer(@window, -1, flags)
-        fit_display if @pacer.vsync?
-        SDL.SDL_RenderSetLogicalSize(@renderer, Screen::WIDTH, Screen::HEIGHT)
-        create_texture
-      end
-
-      def create_texture
-        @texture = SDL.SDL_CreateTexture(
-          @renderer, SDL::PIXELFORMAT_RGB888, SDL::TEXTUREACCESS_STREAMING, Screen::WIDTH, Screen::HEIGHT
-        )
-      end
-
-      def close_window
-        SDL.SDL_DestroyTexture(@texture)
-        SDL.SDL_DestroyRenderer(@renderer)
-        SDL.SDL_DestroyWindow(@window)
-        SDL.SDL_Quit
+        menu_events
+      end
+
+      # Opens the menu at a menu event, on the page it names, and closes it
+      # at a resume. While the timeline holds it open, its frames count
+      # towards the events after it and --frames.
+      def menu_events
+        if @timeline.menu?(@frames)
+          @menu.section = @timeline.menu_section(@frames)
+          open_menu
+          @scripted = true
+        elsif @menu.open? && @timeline.resume?(@frames)
+          resume(false)
+        end
       end
 
       def handle_events
@@ -137,11 +123,14 @@ module Badline
       # it.
       def swap(computer)
         @computer = computer
-        @screen = Screen.new(computer.vic)
+        timing = computer.timing
+        @screen = Screen.new(computer.video, timing.crop)
+        @window.fit(@screen, timing.pixel_width)
+        @menu.center(@window.width, @window.height)
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.switch(computer.sid, computer.region.clock_hz)
+        @sound.switch(computer.sound_source, timing.clock_hz)
         @snapshots.computer = computer
       end
 
@@ -162,6 +151,7 @@ module Badline
       # pressing the cartridge's freeze button if asked.
       def resume(freeze)
         @menu.close
+        @scripted = false
         SDL.SDL_SetRelativeMouseMode(@controls.pot_device? ? 1 : 0)
         @timeline.press_freeze(@computer, @frames) if freeze
         @reported = now
@@ -170,50 +160,58 @@ module Badline
       end
 
       # Runs a frame of the menu, which has the keys and the mouse while the
-      # machine stands still.
+      # machine stands still. A menu the timeline opened counts its frames
+      # and takes their screenshots.
       def paused_frame
-        action = @menu.frame(@renderer, @texture, @controls)
+        scripted = @scripted
+        action = @menu.frame(@window.renderer, @window.texture, @controls)
+        present_menu(scripted)
         if action == :quit
           @running = false
         elsif !action.nil?
           swap(@menu.computer) if action == :swap
           resume(action == :freeze)
         end
+        finish_paused_frame if scripted && @running
       end
 
-      def update_title
-        title = TITLE
-        title += " [#{@controls.tag}]" unless @controls.tag.empty?
-        title += " [MUTED]" if @sound.muted?
-        SDL.SDL_SetWindowTitle(@window, title)
+      def present_menu(scripted)
+        renderer = @window.renderer
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) } if scripted
+        SDL.SDL_RenderPresent(renderer)
+        SDL.SDL_Delay(10)
+      end
+
+      def finish_paused_frame
+        @frames += 1
+        @timeline.run(@computer, @frames)
+        @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
+        menu_events
       end
 
-      def fit_display
-        SDL.SDL_GetWindowDisplayMode(@window, SDL.display_mode)
-        @pacer.fit(SDL.mode_refresh(SDL.display_mode))
+      def update_title
+        tags = []
+        tags << @controls.tag unless @controls.tag.empty?
+        tags << "MUTED" if @sound.muted?
+        @window.title(tags)
       end
 
       def emulate
-        computer = @computer
-        cycles = @pacer.cycles(@sound)
-        i = 0
-        while i < cycles
-          computer.cycle!
-          i += 1
-        end
+        @computer.run_cycles(@pacer.cycles(@sound))
       end
 
       def upload
         @screen.update
-        SDL.SDL_UpdateTexture(@texture, nil, @screen.pixels, Screen::ROW_BYTES)
+        @window.upload(@screen)
       end
 
       def draw
-        SDL.SDL_RenderClear(@renderer)
-        SDL.SDL_RenderCopy(@renderer, @texture, nil, nil)
-        @led&.draw(@renderer)
-        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(@renderer, path) }
-        SDL.SDL_RenderPresent(@renderer)
+        renderer = @window.renderer
+        SDL.SDL_RenderClear(renderer)
+        SDL.SDL_RenderCopy(renderer, @window.texture, nil, nil)
+        @led&.draw(renderer, @window.width, @window.height)
+        @timeline.screenshots(@frames + 1).each { |path| Screenshot.write(renderer, path) }
+        SDL.SDL_RenderPresent(renderer)
       end
 
       def report(at)