badline 0.10.0 → 0.11.0

data/lib/badline/c128.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require "badline/c128/model"
+require "badline/c128/mmu"
+require "badline/c128/vdc"
+require "badline/c128/mmu_pages"
+require "badline/c128/color_lines"
+require "badline/c128/banks"
+require "badline/c128/bus_state"
+require "badline/c128/bus"
+require "badline/c128/cpu"
+require "badline/c128/saved_state"
+require "badline/c128/keys"
+require "badline/c128/modes"
+
+module Badline
+  # The Commodore 128: the 8502 on the VIC-IIe's clock, two CIAs, the SID,
+  # the VDC and its 80 column display, and 128K of RAM, which the 8722 MMU
+  # maps (C128::Bus).
+  #
+  # Built for C128 mode, it runs BASIC 7.0 and the C128 KERNAL from reset.
+  # The C128's Z80 runs first and hands the bus to the 8502, but here the
+  # 8502 starts at its reset vector, with the MMU as the Z80 leaves it.
+  # The KERNAL goes to C64 mode as on the C128, with C= held at reset, a
+  # C64 cartridge or GO64.
+  #
+  # Built for C64 mode, the default, it powers on in C64 mode, the state
+  # the C128 KERNAL reaches when C= is held at power-on, and a reset comes
+  # back there. It runs the C64's BASIC and KERNAL, so the C64's KERNAL
+  # traps, the keyboard buffer and CHROUT capture work unchanged.
+  #
+  # Where a C64 program sees it differ from a C64C: the 8502's P6 senses CAPS
+  # LOCK, $D02F drives the extra keyboard rows, $D030's FAST bit runs the
+  # CPU at 2 MHz and its TEST bit races the raster counter, the SID has no
+  # mirrors, and $D500-$D7FF holds the hidden MMU, the VDC and open bus.
+  class C128
+    include IntegerHelper
+    include KeyboardBuffer
+    include Computer::Attachments
+    include Computer::KernalTraps
+    include Keys
+    include Modes
+
+    # The C64's 8x8 matrix and the three rows K0-K2 select, in port B
+    # column order.
+    KEYBOARD_MATRIX = (Keyboard::C64_MATRIX + [
+      %i[help keypad8 keypad5 tab keypad2 keypad4 keypad7 keypad1],
+      %i[esc keypad_plus keypad_minus line_feed keypad_enter keypad6 keypad9 keypad3],
+      %i[alt keypad0 keypad_period crsr_up crsr_down crsr_left crsr_right no_scroll]
+    ]).freeze
+
+    # The cycle at which #on_init's handlers run, once the KERNAL of the
+    # mode the machine is built for has booted: the C64's as on a C64, or
+    # BASIC 7.0's, which is READY by then.
+    C128_INIT_THRESHOLD = 2_000_000
+
+    # The C128 KERNAL's keyboard buffer and its count.
+    C128_KEYBOARD_BUFFER = 0x034a
+    C128_KEYBOARD_COUNT = 0xd0
+
+    attr_reader :cpu, :cycles, :drive1541, :model, :init_threshold
+
+    # The path of the disk or directory device 8 serves through the traps
+    # (Computer::Attachments), or an empty one.
+    def mounted_path = @drive.nil? ? "" : @drive.path
+
+    def family = :c128
+
+    def address_bus = @bus
+
+    def region = @bus.region
+
+    def vic = @bus.vic
+
+    def cia1 = @bus.cia1
+
+    def cia2 = @bus.cia2
+
+    def sid = @bus.sid
+
+    def vdc = @bus.vdc
+
+    def mmu = @bus.mmu
+
+    def ram = @bus.ram
+
+    def keyboard = @bus.keyboard
+
+    def joystick1 = @bus.joystick1
+
+    def joystick2 = @bus.joystick2
+
+    def control_ports = @bus.control_ports
+
+    def datasette = @bus.datasette
+
+    # :c64 or :c128, the mode the MMU is in.
+    def mode = @bus.mmu.mode
+
+    def install_debug_register(&) = @bus.install_debug_register(&)
+
+    # +model+ names one of Model::ALL, and +sid_model+, when not nil, the
+    # SID in place of the model's. +mode+, :c64 or :c128, is the mode it
+    # powers on and resets into.
+    def initialize(model: "c128", sid_model: nil, mode: :c64, debug: false)
+      raise ArgumentError, "no C128 mode named #{mode}" unless %i[c64 c128].include?(mode)
+
+      @model = Model.named(model)
+      @c64_built = mode == :c64
+      @init_threshold = @c64_built ? Computer::INIT_THRESHOLD : C128_INIT_THRESHOLD
+      @holding_commodore = false
+      @bus = Bus.new(@model, sid_model: sid_model || @model.sid_model, mode:)
+      @cpu = CPU.new(@bus, debug:)
+      @vic = @bus.vic
+      @vic.open_bus = -> { @bus.ram.peek(@cpu.program_counter) }
+      @cia1 = @bus.cia1
+      @cia2 = @bus.cia2
+      @sid = @bus.sid
+      @vdc = @bus.vdc
+      @datasette = @bus.datasette
+      @cycles = 0
+      @clock_bits = 0
+      @nmi_asserted = false
+      @cartridge_nmi = false
+      @restore_pulse = false
+      @init_handlers = []
+      @pending_keys = nil
+      @drive = nil
+      @serial_trap = nil
+      @save_trap = nil
+      @drive1541 = nil
+      @capture_output = nil
+      plug_serial_bus
+      enter_c64_mode if @c64_built
+      @bus.on_mode_change { mode_changed }
+    end
+
+    # The chips clock ahead of the CPU, as on the C64. $D030's FAST and
+    # TEST bits take hold a cycle after the write that sets them: in FAST
+    # mode the CPU runs in both halves of the cycle (#clock_fast), and the
+    # TEST bit steps the raster counter in every cycle.
+    def cycle!
+      handle_init if @cycles == @init_threshold
+      feed_keyboard if @pending_keys
+
+      clock_bits = @clock_bits
+      @clock_bits = @vic.clock_bits
+      @vic.test_step! if clock_bits >= 0x02
+
+      @vic.cycle!
+      @cia1.cycle!
+      @cia2.cycle!
+      @sid.cycle!
+      @datasette.cycle!
+      @vdc.cycle!
+
+      @cpu.irq = @cia1.interrupted? || @vic.interrupted?
+
+      drive_nmi
+      clock_bits.odd? ? clock_fast : clock_cpu
+      @drive1541&.host_cycle!
+
+      @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
+
+    def on_init(&block)
+      if @cycles < init_threshold
+        @init_handlers << block
+      else
+        block.call
+      end
+    end
+
+    # The clock, the raster and the crop of the VIC-IIe's region.
+    def timing
+      region = @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: the VIC-IIe, or with
+    # :vdc the VDC, whose display paints only while its #render is on.
+    def video(chip = :vic) = chip == :vdc ? @vdc : @vic
+
+    # Renders the VDC's display, and not the VIC-IIe's, while a front end
+    # shows it, or with false the other way round.
+    def vdc_shown=(shown)
+      @vdc.render = shown
+      @vic.render = !shown
+    end
+
+    # 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..])
+      end
+    end
+
+    # A cartridge goes in with the power off.
+    def attach_cartridge(cartridge)
+      connect_cartridge(cartridge)
+      power_cycle!
+    end
+
+    # RAM, the VIC and the VDC start from their power-on state, and the RES
+    # line resets everything else.
+    def power_cycle!
+      @vic.power_on!
+      @vdc.power_on!
+      @bus.power_on!
+      reset!
+      enter_c64_mode if @c64_built
+    end
+
+    # The RES line reaches the CPU and its port, the MMU, both CIAs, the
+    # SID, the cartridge port and, through the serial bus, the drive.
+    def reset!
+      @bus.reset!
+      @cia1.reset!
+      @cia2.reset!
+      @sid.reset!
+      @bus.cartridge&.reset
+      @drive&.reset!
+      @drive1541&.reset!
+      @nmi_asserted = false
+      @cpu.reset!
+    end
+
+    # CHROUT is at $FFD2 in both KERNALs, and the trap follows the mode.
+    def capture_output
+      @capture_output ||= ChroutTrap.new(cpu:, bus: @bus, layout: trap_layout).tap do |trap|
+        cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
+    end
+
+    private
+
+    # The C128 KERNAL leaves $D02F at $FF, every extra keyboard row
+    # deselected, before it jumps to the C64's reset.
+    def enter_c64_mode
+      @vic.poke(0xd02f, 0xff)
+      @bus.control_ports.extra_rows = 0xff
+    end
+
+    # The NMI line is wired-OR between CIA 2, the cartridge and RESTORE,
+    # and the CPU takes an interrupt on its falling edge.
+    def drive_nmi
+      nmi = @cia2.interrupted? || @cartridge_nmi || @restore_pulse
+      @restore_pulse = false
+      @cpu.nmi = true if nmi && !@nmi_asserted
+      @nmi_asserted = nmi
+    end
+
+    # BA halts the CPU on a read cycle.
+    def clock_cpu
+      @cpu.pending_write? || !@vic.ba_low? ? @cpu.cycle! : @cpu.stall!
+    end
+
+    # The 8502 at 2 MHz takes both halves of the cycle, and BA no longer
+    # halts it. It leaves phi1 to the VIC in the refresh cycles, and an
+    # access to I/O, whose chips run at 1 MHz, waits for phi2. The VIC's
+    # fetches in the cycle see the bytes on the bus. In a phi1 the CPU
+    # spends waiting that is the byte it writes, or the last byte the bus
+    # held.
+    def clock_fast
+      phi1 = 0xff
+      unless @vic.refresh_cycle?
+        held = @bus.data
+        write = @cpu.pending_write?
+        @cpu.cycle!
+        if @bus.io_access?
+          data = @bus.data
+          return @vic.take_cpu_bus(write ? data : held, data, @bus.vic_access?)
+        end
+
+        phi1 = @bus.data
+      end
+      @cpu.cycle!
+      @vic.take_cpu_bus(phi1, @bus.data, @bus.vic_access?)
+    end
+
+    def handle_init
+      @init_handlers.each(&:call)
+    end
+
+    # The keyboard buffer of the KERNAL the machine runs: the C64's, or in
+    # C128 mode BASIC 7.0's.
+    def feed_keyboard
+      c64 = mode == :c64
+      count = c64 ? KeyboardBuffer::COUNT : C128_KEYBOARD_COUNT
+      return unless ram.peek(count).zero?
+
+      chunk = @pending_keys.shift(KeyboardBuffer::CAPACITY)
+      ram.write(c64 ? KeyboardBuffer::ADDRESS : C128_KEYBOARD_BUFFER, chunk)
+      ram.poke(count, chunk.length)
+      @pending_keys = nil if @pending_keys.empty?
+    end
+  end
+end

data/lib/badline/chrout_trap.rb

@@ -10,6 +10,9 @@ module Badline
 
     attr_reader :output
 
+    # The KERNAL layout whose mapping the trap checks.
+    attr_writer :layout
+
     def initialize(cpu:, bus:, layout:)
       @cpu = cpu
       @bus = bus

data/lib/badline/computer/attachments.rb

@@ -17,18 +17,13 @@ module Badline
 
       # Puts the storage in device 8. Mounting again swaps the disk at any
       # point while the machine runs: the drive keeps its RAM, which only a
-      # drive reset clears, and its status.
+      # drive reset clears, and its status. The traps go on the KERNAL the
+      # machine runs (#trap_layout).
       def mount(storage)
         return @drive.insert(storage) if @drive
 
         @drive = KernalTrap::Drive.new(storage)
-        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 }
+        install_kernal_traps(trap_layout)
       end
 
       # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
@@ -37,11 +32,7 @@ module Badline
       def unmount
         return unless @drive
 
-        cpu.remove_trap(KernalTrap::C64_LAYOUT.load)
-        cpu.remove_trap(KernalTrap::C64_LAYOUT.save)
-        @serial_trap.device = nil
-        @serial_trap = nil
-        @save_trap = nil
+        remove_kernal_traps
         @drive = nil
       end
 

data/lib/badline/computer/kernal_traps.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  class Computer
+    # The LOAD, SAVE and serial traps on the KERNAL a KernalTrap::Layout
+    # describes, which serve the disk in device 8 (Attachments#mount).
+    module KernalTraps
+      private
+
+      def install_kernal_traps(layout)
+        @trap_layout = 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
+
+      def remove_kernal_traps
+        cpu.remove_trap(@trap_layout.load)
+        cpu.remove_trap(@trap_layout.save)
+        @serial_trap.uninstall
+        @serial_trap = nil
+        @save_trap = nil
+      end
+    end
+  end
+end

data/lib/badline/computer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/computer/attachments"
+require "badline/computer/kernal_traps"
 require "badline/computer/saved_state"
 
 module Badline
@@ -8,6 +9,7 @@ module Badline
     include IntegerHelper
     include KeyboardBuffer
     include Attachments
+    include KernalTraps
     include SavedState
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
@@ -48,13 +50,12 @@ module Badline
     # TOD clocks count. The KERNAL tells PAL from NTSC by the raster, so
     # every region boots the same ROMs. reu plugs an REU of that many K
     # into the expansion port, where it drives the IRQ line and takes the
-    # bus for its transfers. kernal: names the KERNAL ROM
-    # (AddressBus::ROMs::KERNALS), and datasette: false leaves the cassette port
-    # empty, as on the SX-64.
-    def initialize(debug: false, reu: nil, kernal: :c64, datasette: true, **machine)
-      @address_bus = AddressBus.new(**machine)
-      @address_bus.kernal = kernal unless kernal == :c64
-      @address_bus.datasette.disconnect! unless datasette
+    # bus for its transfers. kernal:, datasette: and board: fit the bus
+    # afterwards (AddressBus::Fittings): the KERNAL ROM, the cassette port,
+    # which is empty on the SX-64, and the board and case.
+    def initialize(debug: false, reu: nil, **machine)
+      @address_bus = AddressBus.new(**machine.except(*AddressBus::Fittings::NAMES))
+      @address_bus.fit(**machine.slice(*AddressBus::Fittings::NAMES))
       @cpu = CPU.new(@address_bus, debug:)
       @vic = @address_bus.vic
       @vic.open_bus = -> { @address_bus.ram.peek(@cpu.program_counter) }
@@ -195,8 +196,9 @@ module Badline
 
     # RESTORE isn't in the key matrix. It fires a one-shot that pulses the
     # NMI line however long the key is held, modelled here as one cycle.
+    # A machine without a keyboard has no RESTORE key either.
     def press_restore
-      @restore_pulse = true
+      @restore_pulse = true if keyboard.connected?
     end
 
     # The one-shot has pulsed already, so letting go does nothing.
@@ -222,6 +224,9 @@ module Badline
 
     private
 
+    # The KERNAL the traps stand in for (Attachments#mount).
+    def trap_layout = KernalTrap::C64_LAYOUT
+
     # 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

data/lib/badline/frontend/app.rb

@@ -5,6 +5,10 @@ module Badline
     # Opens the window, then runs the machine a frame at a time: poll
     # 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.
+    #
+    # The window shows the machine's video chip, sized to the screen shown.
+    # On the C128 it follows the machine between the VIC-IIe's 40 columns
+    # and the VDC's 80, and F8 switches them until the machine next does.
     class App
       DROPFILE = 0x1000
 
@@ -18,10 +22,10 @@ module Badline
         @pacer = Pacer.new(paced: options.paced?, vsync: options.vsync?, verbose: @verbose, timing:)
         @timeline = timeline
         @snapshots = Snapshots.new(computer, options)
-        @screen = Screen.new(computer.video, timing.crop)
+        @screens = Screens.new(computer)
         @led = DriveLed.for(computer)
         @controls = Controls.new(computer)
-        @window = MachineWindow.new(@screen, timing.pixel_width, vsync: @pacer.vsync?)
+        @window = MachineWindow.new(@screens.screen, 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)
@@ -68,6 +72,7 @@ module Badline
         @frame_report.add(stamps) if @verbose
         @frames += 1
         @timeline.run(@computer, @frames)
+        show_vdc(@timeline.display_at(@frames) == "vdc") if @timeline.display?(@frames)
         @snapshots.tick(@frames)
         @running = false if @frames == @frame_limit || @timeline.quit?(@frames)
         @pacer.check(Pacer::EARLY_CHECK, stamps.last - @started, stamps.last) if @frames == Pacer::EARLY_CHECK
@@ -109,7 +114,7 @@ module Badline
       end
 
       def handle_key(scancode, down)
-        if [Keys::TAB, Keys::F9, Keys::F10].include?(scancode)
+        if [Keys::TAB, Keys::F8, Keys::F9, Keys::F10].include?(scancode)
           handle_toggle(scancode) if down
         elsif down && @snapshots.key(scancode)
           swap(@snapshots.computer)
@@ -123,24 +128,21 @@ module Badline
       # it.
       def swap(computer)
         @computer = computer
-        timing = computer.timing
-        @screen = Screen.new(computer.video, timing.crop)
-        @window.fit(@screen, timing.pixel_width)
-        @menu.center(@window.width, @window.height)
+        @screens.computer = computer
+        fit_window
         @led = DriveLed.for(computer)
         @controls.computer = computer
         @gamepads.computer = computer
-        @sound.switch(computer.sound_source, timing.clock_hz)
+        @sound.switch(computer.sound_source, computer.timing.clock_hz)
         @snapshots.computer = computer
       end
 
       def handle_toggle(scancode)
-        if scancode == Keys::TAB
-          @controls.toggle_keys
-        elsif scancode == Keys::F9
-          return open_menu
-        else
-          @sound.toggle_mute
+        case scancode
+        when Keys::TAB then @controls.toggle_keys
+        when Keys::F8 then show_vdc(!@screens.vdc_shown?)
+        when Keys::F9 then return open_menu
+        else @sound.toggle_mute
         end
         update_title
       end
@@ -189,11 +191,19 @@ module Badline
         menu_events
       end
 
-      def update_title
-        tags = []
-        tags << @controls.tag unless @controls.tag.empty?
-        tags << "MUTED" if @sound.muted?
-        @window.title(tags)
+      def update_title = @window.title(@controls.tag, @sound.muted?)
+
+      # Shows the C128's VDC in the window, or with false its VIC-IIe.
+      def show_vdc(shown)
+        @screens.show_vdc(shown)
+        fit_window
+      end
+
+      # Builds the screen for the chip shown and fits the window to it.
+      def fit_window
+        @screens.build
+        @window.fit(@screens.screen)
+        @menu.center(@window.width, @window.height)
       end
 
       def emulate
@@ -201,8 +211,11 @@ module Badline
       end
 
       def upload
-        @screen.update
-        @window.upload(@screen)
+        @screens.follow
+        fit_window if @screens.stale?
+        screen = @screens.screen
+        screen.update
+        @window.upload(screen)
       end
 
       def draw

data/lib/badline/frontend/boot.rb

@@ -49,7 +49,7 @@ module Badline
     # or --sid the SID. The VIC-20 raises Unsupported for a .sid
     # tune.
     def self.start(options, media, writable)
-      computer = options.family == :vic20 ? vic20(options, media) : c64(options, media)
+      computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
       unless media.nil?
         puts Media.attach(computer, media, autostart: options.autostart?, subtune: options.subtune,
@@ -58,11 +58,41 @@ module Badline
       computer
     end
 
+    def self.build(options, media)
+      case options.family
+      when :vic20 then vic20(options, media)
+      when :c128 then c128(options, media)
+      else c64(options, media)
+      end
+    end
+
     def self.c64(options, media)
       sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
       Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
     end
 
+    # A C128 in C128 mode. With --c64, or media only C64 mode runs, a .sid
+    # tune or a program that loads at the C64's BASIC start, C= is held
+    # through the reset, so the C128 KERNAL starts C64 mode.
+    def self.c128(options, media)
+      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
+      machine = C128.new(model: options.model, sid_model:, mode: :c128)
+      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
+      machine
+    end
+
+    def self.c64_media?(media)
+      return false if media.nil? || !File.file?(media)
+
+      extension = File.extname(media).downcase
+      return true if extension == ".sid"
+      return false unless %w[.prg .p00].include?(extension)
+
+      bytes = File.binread(media).bytes
+      bytes = Storage::P00.data(bytes) if Storage::P00.wraps?(bytes)
+      bytes.length >= 2 && [Media::BASIC_START, Media::BASIC_START - 1].include?(bytes[0] | (bytes[1] << 8))
+    end
+
     # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
     # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
     # media a VIC-20 doesn't take.

data/lib/badline/frontend/controls.rb

@@ -73,6 +73,8 @@ module Badline
       def key(scancode, down)
         if joystick_mode? && Keys.joystick?(scancode)
           joystick_key(scancode, down)
+        elsif @computer.family == :c128
+          c128_key(Keys.c128_key(scancode, @computer.mode), down)
         else
           c64_key(Keys.c64_key(scancode), down)
         end
@@ -111,6 +113,15 @@ module Badline
         end
       end
 
+      # CAPS LOCK and 40/80 DISPLAY aren't in the C128's matrix either.
+      def c128_key(key, down)
+        case key
+        when :caps_lock then down ? @computer.press_caps_lock : @computer.release_caps_lock
+        when :forty_eighty then down ? @computer.press_display_key : @computer.release_display_key
+        else c64_key(key, down)
+        end
+      end
+
       def paddles? = POTS.index(@pot) >= 3
 
       # A fresh pot device on its port, and none on the other. A machine

data/lib/badline/frontend/keys.rb

@@ -3,7 +3,8 @@
 module Badline
   module Frontend
     # SDL scancodes follow key positions on a US layout. They map onto the C64
-    # keys and, in joystick mode, the joystick directions.
+    # keys, the C128's own keys and, in joystick mode, the joystick
+    # directions.
     module Keys
       TAB = 43
 
@@ -20,6 +21,24 @@ module Badline
         224 => :control, 225 => :lshift, 226 => :cbm, 229 => :rshift
       }.freeze
 
+      # The C128's keys that have a host key of their own: the keypad, HELP
+      # on Insert or Help, ALT on the right Alt, NO SCROLL on Scroll Lock,
+      # and CAPS LOCK and 40/80 DISPLAY, which sit outside the matrix, on
+      # Caps Lock and F6 or Pause. In C128 mode Esc is ESC, and RUN/STOP
+      # moves to Page Down. TAB and the separate cursor keys stay with the
+      # C64's keys (the joystick toggle and the cursor combinations), and in
+      # C64 mode Esc stays RUN/STOP.
+      C128_OTHERS = {
+        89 => :keypad1, 90 => :keypad2, 91 => :keypad3, 92 => :keypad4, 93 => :keypad5, 94 => :keypad6,
+        95 => :keypad7, 96 => :keypad8, 97 => :keypad9, 98 => :keypad0, 99 => :keypad_period,
+        86 => :keypad_minus, 87 => :keypad_plus, 88 => :keypad_enter,
+        73 => :help, 117 => :help, 230 => :alt, 71 => :no_scroll, 57 => :caps_lock,
+        63 => :forty_eighty, 72 => :forty_eighty, 78 => :run_stop
+      }.freeze
+
+      ESCAPE = 41
+
+      F8 = 65
       F9 = 66
       F10 = 67
       F11 = 68
@@ -38,6 +57,14 @@ module Badline
         end
       end
 
+      # The C128's key for the scancode in the C128's +mode+, :c128 or
+      # :c64: one of C128_OTHERS, ESC, or the C64's.
+      def self.c128_key(scancode, mode)
+        return :esc if scancode == ESCAPE && mode == :c128
+
+        C128_OTHERS[scancode] || c64_key(scancode)
+      end
+
       def self.arrows(scancode) = ARROWS[scancode] || :none
 
       def self.wasd(scancode) = WASD[scancode] || :none