badline 0.4.1 → 0.5.0

data/lib/badline/drive1541.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "badline/drive1541/bus"
+require "badline/drive1541/serial_port"
+require "badline/drive1541/gcr"
+require "badline/drive1541/track"
+require "badline/drive1541/disk"
+require "badline/drive1541/mechanism"
+require "badline/drive1541/disk_via"
+require "badline/drive1541/idle"
+
+module Badline
+  # The 1541 disk drive as a machine of its own: a 6502 running the DOS
+  # ROM at 1 MHz, with 2 KB of RAM and two VIAs on its bus. VIA 1 faces
+  # the serial bus and VIA 2 the disk mechanism.
+  #
+  # The drive runs on its own crystal, so it clocks against the host's
+  # clock through a fractional accumulator: each host cycle adds 1 MHz
+  # worth of phase, and every whole host period in it runs a drive cycle.
+  # Against the PAL C64's 985,248 Hz that's one drive cycle per host cycle
+  # and a second one about every 67. The host sets its clock on attaching
+  # the drive, and until then the drive runs one cycle per host cycle.
+  #
+  # VIA 2's port B runs the Mechanism, which reads a Disk put in with
+  # insert.
+  #
+  # While the DOS idles, host_cycle! skips the drive's cycles and catches
+  # up on them later, exactly (see Idle). The readers of the drive's parts
+  # catch up first, so they find the drive as running every cycle would
+  # have left it.
+  class Drive1541
+    include Idle
+
+    CLOCK_HZ = 1_000_000
+
+    attr_reader :device, :serial_bus
+
+    def cpu
+      settle!
+      @cpu
+    end
+
+    def bus
+      settle!
+      @bus
+    end
+
+    def via1
+      settle!
+      @via1
+    end
+
+    def via2
+      settle!
+      @via2
+    end
+
+    def mechanism
+      settle!
+      @mechanism
+    end
+
+    def cycles
+      settle!
+      @cycles
+    end
+
+    def ram = bus.ram
+
+    def host_clock_hz=(clock_hz)
+      settle!
+      @host_clock_hz = clock_hz
+    end
+
+    # +rom+ covers $C000-$FFFF, and defaults to the DOS image in the ROM
+    # path. +device+ is the number the jumpers on VIA 1's PB5 and PB6 set,
+    # 8 to 11.
+    def initialize(rom: nil, host_clock_hz: CLOCK_HZ, device: 8, debug: false)
+      @device = device
+      @serial_port = SerialPort.new(device:)
+      @via1 = VIA.new(start: 0x1800, peripheral: @serial_port)
+      @mechanism = Mechanism.new(self)
+      @via2 = DiskVIA.new(start: 0x1c00, mechanism: @mechanism)
+      @bus = Bus.new(rom: rom || ROM.load("dos1541.rom", 0xc000), via1: @via1, via2: @via2)
+      @cpu = CPU.new(@bus, debug:)
+      @host_clock_hz = host_clock_hz
+      @phase = 0
+      @cycles = 0
+      @so_pending = false
+      @serial_bus = nil
+      init_idle(debug)
+      # CA1 powers up at the level of a released ATN, without an edge.
+      @via1.ca1 = false
+      @via1.reset!
+      connect(IECBus.new)
+    end
+
+    # Plugs the drive into a serial bus, leaving the one it was on. A drive
+    # starts out on a bus of its own, with nothing else on it.
+    def connect(serial_bus)
+      settle!
+      @serial_bus&.detach(self)
+      @serial_bus = serial_bus
+      @serial_port.bus = serial_bus
+      serial_bus.attach(self)
+      @via1.ca1 = @serial_port.atn_low?
+    end
+
+    # Puts a Disk in the drive (Disk.from_d64 makes one from an image).
+    # Nil takes the disk out.
+    def insert(disk)
+      settle!
+      @mechanism.insert(disk)
+    end
+
+    def disk = mechanism.disk
+
+    # Whether the LED is lit. Reading it leaves the drive asleep: the LED
+    # is the same at the end of every pass the drive sleeps through.
+    def led_on? = @mechanism.led_on?
+
+    # VIA 1's port B as it drives the serial bus. It holds still while the
+    # drive sleeps, so reading it leaves the drive asleep.
+    def serial_output = @via1.port_b_output
+
+    # Stores what the head wrote since the motor last stopped in the
+    # disk's image, as the motor stopping does.
+    def flush
+      settle!
+      @mechanism.flush
+    end
+
+    # The serial bus's RESET line reaches the CPU and both VIAs. RAM keeps
+    # its contents.
+    def reset!
+      settle!
+      @via1.reset!
+      @via2.reset!
+      @cpu.reset!
+    end
+
+    # Runs the drive cycles that fall in one host cycle: none, one or two.
+    # 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).
+    def host_cycle!
+      return doze if @asleep
+
+      phase = @phase + CLOCK_HZ
+      while phase >= @host_clock_hz
+        @asleep ? @owed += 1 : run_cycle
+        phase -= @host_clock_hz
+      end
+      @phase = phase
+      settle! if @serial_port.atn_moved?
+      @serial_port.latch_host
+      plan_wake if @asleep
+    end
+
+    # Runs one drive cycle, catching up first on any the drive owes (see
+    # step).
+    def cycle!
+      settle!
+      step
+    end
+
+    def inspect
+      "#<#{self.class.name} cycles=#{cycles} cpu=(#{cpu.inspect})>"
+    end
+
+    # The read electronics signal a whole GCR byte. BYTE READY pulls VIA 2's
+    # CA1 low, a falling edge that sets its flag and, with latching on,
+    # latches port A. It reaches the CPU's SO pin while VIA 2's CA2 (SOE)
+    # is high, which lets the DOS spin on BVC for each byte. The CPU
+    # samples SO on the next cycle (see step).
+    def byte_ready!
+      @via2.ca1 = false
+      @so_pending = true if @via2.ca2_output
+    end
+
+    # BYTE READY lets go of CA1 with the next bit.
+    def byte_ready_ended!
+      @via2.ca1 = true
+    end
+
+    private
+
+    # A drive cycle from host_cycle!, which may find the idle loop.
+    def run_cycle
+      step
+      idle_loop_reached if @cpu.program_counter == IDLE_LOOP && @idle_skip
+    end
+
+    # One drive cycle. The VIAs clock ahead of the CPU, as the C64's chips
+    # do, and either one pulls IRQ. Nothing drives NMI on the 1541. The CPU
+    # runs whether or not the motor turns, since it answers ATN.
+    #
+    # The disk mechanism runs first, so BYTE READY lands on the VIA ahead
+    # of the CPU's cycle. The CPU samples SO a cycle late: BYTE READY sets
+    # V for the next cycle's instruction step.
+    #
+    # ATN reaches VIA 1's CA1 through the same inverter as PB7, so CA1 goes
+    # high as the C64 asserts ATN, as the serial port sees it: from the
+    # host cycle after the one that asserts it.
+    def step
+      so = @so_pending
+      @so_pending = false
+      @mechanism.cycle!
+      @via1.ca1 = @serial_port.atn_low?
+      @via1.cycle!
+      @via2.cycle!
+      @cpu.irq = @via1.irq? || @via2.irq?
+      @cpu.so! if so
+      @cpu.cycle!
+      @cycles += 1
+    end
+  end
+end

data/lib/badline/gui/application.rb

@@ -28,14 +28,20 @@ module Badline
       }.freeze
       MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
 
-      # The media options (autostart:, song:, disk:) go to Media.attach.
-      def initialize(media_path: nil, sid_model: nil, sound: false, **media)
-        @computer = Computer.new(sid_model: sid_model || Media.sid_model(media_path))
+      # The machine options (sid_model:, reu:, true_drive:, ntsc:) build
+      # the machine: reu plugs in an REU of that many K, true_drive puts a
+      # true 1541 on device 8, and ntsc makes it an NTSC C64. The media
+      # options (autostart:, song:, disk:) go to Media.attach.
+      def initialize(media_path: nil, machine: {}, sound: false, verbose: false, **media)
+        @verbose = verbose
+        @computer = Computer.new(**machine_options(machine, media_path))
+        Media::TrueDrive.plug(@computer) if machine[:true_drive]
         puts Media.attach(@computer, media_path, **media) if media_path
 
         @mode = :keyboard
         @pot_device = nil
         @panes = [ScreenPane.new(@computer)]
+        @panes << DriveLedPane.new(@computer.drive1541, @panes.first) if @computer.drive1541
         @stream = open_stream if sound
         @paced = ENV["NOVSYNC"].nil?
         @window = Window.new(
@@ -44,7 +50,7 @@ module Badline
           vsync: @paced && !@stream
         )
         @gamepads = Gamepads.new(@computer)
-        @gamepads.names.each { |name| puts "Gamepad: #{name}" }
+        @gamepads.names.each { |name| report "Gamepad: #{name}" }
         fit_frame
       end
 
@@ -59,10 +65,11 @@ module Badline
           @stream.pace(@frame_seconds) if @stream && @paced
         end
       ensure
+        @computer.drive1541&.flush
         @stream&.close
         @gamepads.close
         @window.close
-        puts @computer.cpu.inspect
+        report @computer.cpu.inspect
       end
 
       private
@@ -155,19 +162,29 @@ module Badline
 
       def open_stream
         sink = Audio::SDLSink.new(rate: Audio::Renderer::DEFAULT_RATE)
-        puts "Sound at #{sink.rate} Hz, F10 mutes"
+        report "Sound at #{sink.rate} Hz, F10 mutes"
         Audio::Stream.new(sink, @computer.sid,
                           on_underrun: -> { puts "Running below real time, so the sound will stutter." })
       rescue Audio::SDLSink::Error => e
         warn "badline: no sound, can't open the audio device: #{e.message}"
       end
 
+      def machine_options(machine, media_path)
+        options = { sid_model: machine[:sid_model] || Media.sid_model(media_path), **machine.slice(:reu) }
+        options[:region] = Region::NTSC if machine[:ntsc]
+        options
+      end
+
       def fit_frame
         rate = @window.refresh_rate
         clock_hz = @computer.region.clock_hz
         @cycles_per_frame = clock_hz / rate
         @frame_seconds = @cycles_per_frame.fdiv(clock_hz)
-        puts "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
+        report "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
+      end
+
+      def report(line)
+        puts line if @verbose
       end
 
       def attach_pot_device

data/lib/badline/gui/drive_led_pane.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  module GUI
+    # The true drive's red LED, in the bottom right corner of the screen
+    # pane's border: bright while the DOS lights it, as it does while a file
+    # is open or after an error, and dim otherwise.
+    class DriveLedPane < Pane
+      WIDTH = 12
+      HEIGHT = 4
+
+      LIT = [0xff, 0x20, 0x20].freeze
+      DARK = [0x40, 0x00, 0x00].freeze
+
+      def initialize(drive, screen)
+        super(width: WIDTH, height: HEIGHT,
+              left: screen.left + screen.width - WIDTH - 8, top: screen.top + screen.height - HEIGHT - 6)
+        @drive = drive
+      end
+
+      def color = @drive.led_on? ? LIT : DARK
+
+      def render(renderer)
+        SDL::SetRenderDrawColor.call(renderer, *color, 0xff)
+        SDL::RenderFillRect.call(renderer, @rect)
+      end
+    end
+  end
+end

data/lib/badline/gui.rb

@@ -8,5 +8,6 @@ require "badline/gui/joy_map"
 require "badline/gui/gamepads"
 require "badline/gui/pane"
 require "badline/gui/screen_pane"
+require "badline/gui/drive_led_pane"
 require "badline/gui/window"
 require "badline/gui/application"

data/lib/badline/iec_bus.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Badline
+  # The serial bus between the C64 and its drives: ATN, CLK and DATA, each
+  # an open-collector line with a pull-up. A line is low while any device
+  # pulls it (wired-AND), and high otherwise. The bus holds no state of its
+  # own: every read works the levels out from what each side drives now.
+  #
+  # The C64 drives the lines from CIA 2's port A through 7406 inverters, so
+  # an output bit of 1 pulls its line low: PA3 ATN, PA4 CLK and PA5 DATA.
+  # PA6 and PA7 read CLK and DATA directly, 1 for a released line. The bus
+  # stands in as CIA 2's peripheral for those two inputs.
+  #
+  # A drive drives CLK and DATA from VIA 1's PB3 and PB1, the same way. It
+  # also pulls DATA while ATN IN differs from its ATN acknowledge on PB4
+  # (an XOR gate), which answers ATN in hardware before the DOS gets to it.
+  # SerialPort reads the lines back into VIA 1.
+  class IECBus
+    # CIA 2 port A
+    HOST_ATN_OUT = 0x08
+    HOST_CLK_OUT = 0x10
+    HOST_DATA_OUT = 0x20
+    HOST_CLK_IN = 0x40
+    HOST_DATA_IN = 0x80
+
+    # VIA 1 port B
+    DRIVE_DATA_OUT = 0x02
+    DRIVE_CLK_OUT = 0x08
+    DRIVE_ATNA = 0x10
+
+    # The lines pulled low, as ATN, CLK and DATA bits
+    ATN = 0x01
+    CLK = 0x02
+    DATA = 0x04
+
+    attr_reader :host, :drives
+
+    # +host+ is CIA 2, or nil for a bus with only drives on it.
+    def initialize(host: nil)
+      @host = host
+      @drives = []
+    end
+
+    def attach(drive)
+      @drives << drive unless @drives.include?(drive)
+    end
+
+    def detach(drive)
+      @drives.delete(drive)
+    end
+
+    # One pass over everything on the bus, for a reader that wants more
+    # than one line. +host+ is the C64's port A lines as the reader sees
+    # them, which a drive takes a cycle late (see Drive1541::SerialPort).
+    def low_lines(host = host_lines)
+      atn = host.anybits?(HOST_ATN_OUT)
+      low = atn ? ATN : 0
+      low |= CLK if host.anybits?(HOST_CLK_OUT)
+      low |= DATA if host.anybits?(HOST_DATA_OUT)
+      i = 0
+      while i < @drives.length
+        drive = @drives[i].serial_output
+        low |= CLK if drive.anybits?(DRIVE_CLK_OUT)
+        low |= DATA if drive.anybits?(DRIVE_DATA_OUT) || atn != drive.anybits?(DRIVE_ATNA)
+        i += 1
+      end
+      low
+    end
+
+    def atn_low?(host = host_lines) = host.anybits?(HOST_ATN_OUT)
+
+    def clk_low? = low_lines.anybits?(CLK)
+
+    def data_low? = low_lines.anybits?(DATA)
+
+    # CIA 2's port A pins as the bus leaves them: CLK IN and DATA IN low
+    # while their lines are.
+    def read_a(_port_a, _port_b)
+      low = low_lines
+      value = 0xff
+      value &= ~HOST_CLK_IN if low.anybits?(CLK)
+      value &= ~HOST_DATA_IN if low.anybits?(DATA)
+      value
+    end
+
+    # Port B goes to the user port, not the serial bus.
+    def read_b(_port_a, _port_b) = 0xff
+
+    # What the C64 pulls, as port A bits: its output bits, with input bits
+    # floating high as the 7406 inputs see them.
+    def host_lines = @host ? @host.port_a_lines : 0
+  end
+end

data/lib/badline/kernal_trap/channel.rb

@@ -53,8 +53,12 @@ module Badline
       # a LOAD (secondary address 0) opens at $7E and $026F of its memory,
       # and a LOAD of a name starting with "*" reopens that file rather than
       # the first one on the disk. Loaders write the block there with M-W
-      # to load a file the directory doesn't list.
+      # to load a file the directory doesn't list. A LOAD of "$" reads the
+      # directory as a BASIC program, which a pattern after a colon narrows
+      # to the files it names.
       def self.for_name(storage, memory, secondary, name, type)
+        return new(storage.directory.bytes(name)) if listing?(storage, secondary, name)
+
         file = Storage.parse_name(name).first
         return for_file(storage, file, type) unless secondary.zero? && storage.respond_to?(:first_block)
 
@@ -66,6 +70,10 @@ module Badline
         for_file(storage, file, type)
       end
 
+      def self.listing?(storage, secondary, name)
+        secondary.zero? && name.start_with?("$") && storage.respond_to?(:directory)
+      end
+
       # The file whose chain starts at the block.
       def self.at_block(storage, track, sector)
         data = storage.read_file_at(track, sector)

data/lib/badline/kernal_trap/serial.rb

@@ -6,7 +6,12 @@ module Badline
     # device 8 go to a virtual drive instead of out over the IEC lines, so
     # OPEN/CHKIN/CHRIN reach a CBM DOS, and so do the block reads that
     # loaders make through them. Other devices fall through to the ROM.
+    #
+    # With +device+ nil the traps answer no device, and every frame goes
+    # out over the bus, to a true drive if one is plugged in.
     class Serial < Routine
+      attr_accessor :device
+
       ROUTINES = {
         0xed09 => :talk,
         0xed0c => :listen,
@@ -29,9 +34,10 @@ module Badline
 
       NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
 
-      def initialize(cpu:, bus:, drive:)
+      def initialize(cpu:, bus:, drive:, device: DEVICE)
         super(cpu:, bus:)
         @drive = drive
+        @device = device
         @listening = false
         @talking = false
         @listen_channel = nil
@@ -66,13 +72,13 @@ module Badline
       # in the secondary address that follows.
       def talk
         @talk_channel = nil
-        @talking = @cpu.a == DEVICE
+        @talking = @cpu.a == @device
         return_to_caller if @talking
       end
 
       def listen
         @listen_channel = nil
-        @listening = @cpu.a == DEVICE
+        @listening = @cpu.a == @device
         return_to_caller if @listening
       end
 

data/lib/badline/media/true_drive.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # Device 8 as a true 1541 instead of the KERNAL traps. Once a Drive1541
+    # is plugged in as device 8, disk media go into it rather than into the
+    # traps, so a LOAD runs the DOS and every byte crosses the serial bus.
+    # A .g64 holds the disk's raw GCR, which only a true drive reads, so it
+    # plugs one in when there's none yet. The 1541 reads only .d64 and .g64
+    # images, so the traps' other disk media, a .d71, .d81 or .t64 or a host
+    # directory, raise Error.
+    module TrueDrive
+      class Error < ArgumentError; end
+
+      class << self
+        # Plugs a Drive1541 in as device 8, unless one is there already, and
+        # returns it.
+        def plug(computer)
+          drive(computer) || Drive1541.new.tap { |drive| computer.attach_drive1541(drive) }
+        end
+
+        # The Drive1541 on device 8, or nil.
+        def drive(computer)
+          drive = computer.drive1541
+          drive if drive && drive.device == KernalTrap::Routine::DEVICE
+        end
+
+        # Whether the path goes in a true drive: a .g64 always, and other
+        # disk media, which the traps would mount, when a true drive is
+        # device 8.
+        def takes?(computer, path)
+          return true if File.extname(path).casecmp?(".g64")
+
+          !drive(computer).nil? && (File.directory?(path) || MOUNT_TYPES.key?(File.extname(path).downcase))
+        end
+
+        # Puts the .d64 or .g64 in the drive on device 8, plugging one in
+        # when there's none, and takes out what was mounted through the
+        # traps, so LOAD and SAVE reach the drive too. `read_only` puts it
+        # in write-protected.
+        def insert(computer, path, read_only: false)
+          unless %w[.d64 .g64].include?(File.extname(path).downcase)
+            raise Error, "#{path} is not a .d64 or .g64 image, which the 1541 reads"
+          end
+
+          disk = Drive1541::Disk.open(path, read_only:)
+          computer.unmount
+          plug(computer).insert(disk)
+          "Inserted #{path} in the 1541 as device 8"
+        end
+      end
+    end
+  end
+end

data/lib/badline/media.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/media/true_drive"
+
 module Badline
   module Media
     AUTOSTART = %(lO"*",8,1\rrun\r)
@@ -19,8 +21,14 @@ module Badline
       # the Retro Replay's flash mode, and `disk: { read_only: true }` mounts
       # a disk image write-protected, so nothing the program does writes to
       # its file. Media they don't apply to ignore them.
+      #
+      # A .g64 plugs in a true drive as device 8 (TrueDrive), and with one
+      # there, a .d64 goes into it instead of the KERNAL traps too. The
+      # autostart then loads through it.
       def attach(computer, path, autostart: true, song: nil, **options)
-        if File.directory?(path)
+        if TrueDrive.takes?(computer, path)
+          attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
+        elsif File.directory?(path)
           computer.mount(Storage::HostDirectory.new(path))
           "Mounted #{path} as device 8"
         elsif File.extname(path).downcase == ".crt"
@@ -40,7 +48,14 @@ module Badline
       # while the machine runs, without loading anything. The drive keeps
       # its RAM and its status. `read_only` inserts a disk image
       # write-protected.
+      #
+      # A .g64 goes in a true 1541, which is plugged in as device 8 when
+      # there's none yet (TrueDrive). Once a true 1541 is device 8, a .d64
+      # goes in its drive as well, and other disks, which a 1541 can't
+      # read, raise TrueDrive::Error, an ArgumentError.
       def insert_disk(computer, path, read_only: false)
+        return TrueDrive.insert(computer, path, read_only:) if TrueDrive.takes?(computer, path)
+
         raise ArgumentError, "#{path} is not a disk image or a directory" unless disk?(path)
 
         computer.mount(open_storage(path, { read_only: }))
@@ -98,6 +113,12 @@ module Badline
         "Inserted #{path} in the datasette"
       end
 
+      def attach_true_drive(computer, path, disk, autostart:)
+        message = TrueDrive.insert(computer, path, read_only: disk.fetch(:read_only, false))
+        computer.type_text(AUTOSTART) if autostart
+        message
+      end
+
       def attach_storage(computer, path, disk, autostart:)
         computer.mount(open_storage(path, disk))
         computer.type_text(AUTOSTART) if autostart

data/lib/badline/options.rb

@@ -21,9 +21,13 @@ module Badline
              badline-ruby --headless [options] tune.sid
              badline-ruby [options] tune.sid --audio-out FILE
 
-      Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image,
-      a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid tune, or
-      a directory to mount as device 8. It opens in the emulator window.
+      Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
+      .g64 disk image for the true 1541, a .t64 tape archive, a .tap
+      tape, a .crt cartridge, a .sid tune, or a directory to mount as
+      device 8. It opens in the emulator window. Device 8 answers through
+      traps on the KERNAL's disk routines, unless --true-drive puts an
+      emulated 1541 there, which runs its own DOS and reads .d64 and .g64
+      images only.
 
       --headless plays a .sid tune on the host's audio device without the
       window, and --audio-out renders it to 16-bit PCM instead. The
@@ -43,7 +47,7 @@ module Badline
 
     BANNER
 
-    attr_reader :media_path, :audio_out, :song, :seconds, :songlengths, :sid_model, :filter_chunk
+    attr_reader :media_path, :audio_out, :song, :seconds, :songlengths, :sid_model, :filter_chunk, :reu
 
     alias tune_path media_path
 
@@ -53,6 +57,9 @@ module Badline
       @autostart = true
       @read_only = false
       @sound = false
+      @verbose = false
+      @true_drive = false
+      @ntsc = false
       @headless = false
       @jit = true
       @quiet = false
@@ -96,6 +103,12 @@ module Badline
 
     def sound? = @sound
 
+    def verbose? = @verbose
+
+    def true_drive? = @true_drive
+
+    def ntsc? = @ntsc
+
     def quiet? = @quiet
 
     def tui? = @tui
@@ -165,6 +178,19 @@ module Badline
       opts.on("--sound", "Play the SID through the host's audio device (F10 mutes)") do
         window_only("--sound") { @sound = true }
       end
+      opts.on("--true-drive", "Put a true 1541 on device 8 instead of the KERNAL traps") do
+        window_only("--true-drive") { @true_drive = true }
+      end
+      opts.on("--reu SIZE", %w[128 256 512 1024 2048 4096 8192 16384],
+              "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384") do |size|
+        window_only("--reu") { @reu = size.to_i }
+      end
+      opts.on("--ntsc", "Run an NTSC C64, with the 6567R8 VIC-II, instead of a PAL one") do
+        window_only("--ntsc") { @ntsc = true }
+      end
+      opts.on("--verbose", "Print the display, sound and gamepad setup and the frame timing") do
+        window_only("--verbose") { @verbose = true }
+      end
     end
 
     def define_headless_options(opts)