badline 0.5.1 → 0.6.1

data/lib/badline/gui/application.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    class Application
-      TITLE = "Badline"
-      TOGGLE_SYM = SDL::KEY_TAB
-      MUTE_SYM = SDL::KEY_F10
-      REVERSE_MOD = SDL::KMOD_SHIFT
-
-      SHARED_KEYS = %i[cursor_up cursor_left cursor_h cursor_v space w a s d lshift].freeze
-
-      # Tab steps through the input modes and shift-Tab back; the title bar
-      # names the live one. The pot devices appear once per control port, since
-      # games disagree on which one they read.
-      MODES = {
-        keyboard: nil, joystick: "JOY",
-        mouse1: "MOUSE 1", mouse2: "MOUSE 2",
-        paddles1: "PADDLE 1", paddles2: "PADDLE 2"
-      }.freeze
-
-      # Both pot devices take their input from the host mouse. Motion turns the
-      # paddle knobs or steps the 1351's counters, and the host buttons go to
-      # whichever lines the device puts them on.
-      POT_DEVICES = {
-        mouse1: [Input::Mouse1351, 1], mouse2: [Input::Mouse1351, 2],
-        paddles1: [Input::Paddles, 1], paddles2: [Input::Paddles, 2]
-      }.freeze
-      MOUSE_BUTTONS = { 1 => :left, 3 => :right }.freeze
-
-      # 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(
-          title: TITLE,
-          width: canvas_width, height: canvas_height,
-          vsync: @paced && !@stream
-        )
-        @gamepads = Gamepads.new(@computer)
-        @gamepads.names.each { |name| report "Gamepad: #{name}" }
-        fit_frame
-      end
-
-      def run
-        @running = true
-        while @running
-          handle_events
-          @gamepads.poll
-          @cycles_per_frame.times { @computer.cycle! }
-          @stream&.feed
-          @window.draw(@panes)
-          @stream.pace(@frame_seconds) if @stream && @paced
-        end
-      ensure
-        @computer.drive1541&.flush
-        @stream&.close
-        @gamepads.close
-        @window.close
-        report @computer.cpu.inspect
-      end
-
-      private
-
-      def handle_events
-        while (event = SDL.poll_event)
-          case event
-          when SDL::Quit
-            @running = false
-          when SDL::KeyDown
-            handle_key_down(event)
-          when SDL::KeyUp
-            handle_key_up(event)
-          when SDL::MouseMotion
-            @pot_device&.move(event.xrel, event.yrel)
-          when SDL::MouseButton
-            handle_mouse_button(event)
-          when SDL::ControllerDevice
-            @gamepads.rescan
-          end
-        end
-      end
-
-      def handle_key_down(event)
-        return cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1) if event.sym == TOGGLE_SYM
-        return toggle_mute if event.sym == MUTE_SYM
-
-        port, dir = JoyMap.parse(event) if @mode == :joystick
-        if port
-          joystick(port).press(dir)
-        else
-          press_key(KeyMap.parse(event), event.repeat)
-        end
-      end
-
-      # RESTORE isn't in the key matrix, so it goes to the machine instead,
-      # once per press as the real key's one-shot fires.
-      def press_key(key, repeat)
-        return @computer.press_restore if key == :restore && !repeat
-        return if key == :restore
-
-        @computer.keyboard.press(key)
-      end
-
-      def handle_key_up(event)
-        return if [TOGGLE_SYM, MUTE_SYM].include?(event.sym)
-
-        port, dir = JoyMap.parse(event) if @mode == :joystick
-        if port
-          joystick(port).release(dir)
-        else
-          @computer.keyboard.release(KeyMap.parse(event))
-        end
-      end
-
-      def handle_mouse_button(event)
-        button = MOUSE_BUTTONS[event.button]
-        return unless button && @pot_device
-
-        if event.pressed
-          @pot_device.press(button)
-        else
-          @pot_device.release(button)
-        end
-      end
-
-      def joystick(port)
-        port == 1 ? @computer.joystick1 : @computer.joystick2
-      end
-
-      def cycle_mode(step)
-        modes = MODES.keys
-        @mode = modes[(modes.index(@mode) + step) % modes.size]
-        release_inputs
-        attach_pot_device
-        update_title
-      end
-
-      def toggle_mute
-        return unless @stream
-
-        @stream.toggle_mute
-        update_title
-      end
-
-      def update_title
-        tags = [MODES[@mode], @stream&.muted? && "MUTED"].select(&:itself)
-        @window.title = [TITLE, *tags.map { |tag| "[#{tag}]" }].join(" ")
-      end
-
-      def open_stream
-        sink = Audio::SDLSink.new(rate: Audio::Renderer::DEFAULT_RATE)
-        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)
-        report "Display #{rate} Hz -> #{@cycles_per_frame} cycles/frame"
-      end
-
-      def report(line)
-        puts line if @verbose
-      end
-
-      def attach_pot_device
-        device_class, port = POT_DEVICES[@mode]
-        @pot_device = device_class&.new
-        ports = @computer.control_ports
-        ports.device1 = port == 1 ? @pot_device : nil
-        ports.device2 = port == 2 ? @pot_device : nil
-        SDL::SetRelativeMouseMode.call(@pot_device ? 1 : 0)
-      end
-
-      def release_inputs
-        SHARED_KEYS.each { |key| @computer.keyboard.release(key) }
-        Joystick::DIRECTIONS.each_key do |dir|
-          @computer.joystick1.release(dir)
-          @computer.joystick2.release(dir)
-        end
-      end
-
-      def canvas_width
-        @panes.map { |pane| pane.left + pane.width }.max
-      end
-
-      def canvas_height
-        @panes.map { |pane| pane.top + pane.height }.max
-      end
-    end
-  end
-end

data/lib/badline/gui/drive_led_pane.rb

@@ -1,29 +0,0 @@
-# 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/gamepads.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # Host game controllers wired onto the control ports.
-    #
-    # The first controller found drives joystick 2, the port most games read;
-    # a second one drives joystick 1. D-pad and left stick both steer, every
-    # face and shoulder button fires.
-    #
-    # SDL announces arrivals by device index but reports button presses by
-    # instance id, so rather than line the two up, this class polls the
-    # controllers every frame. It only releases directions it
-    # pressed itself, so the keyboard mapping keeps working with a pad
-    # connected.
-    class Gamepads
-      DEADZONE = 8_000
-      PORTS = [2, 1].freeze
-
-      BUTTONS = {
-        up: [SDL::CONTROLLER_BUTTON_DPAD_UP],
-        down: [SDL::CONTROLLER_BUTTON_DPAD_DOWN],
-        left: [SDL::CONTROLLER_BUTTON_DPAD_LEFT],
-        right: [SDL::CONTROLLER_BUTTON_DPAD_RIGHT],
-        fire: [SDL::CONTROLLER_BUTTON_A, SDL::CONTROLLER_BUTTON_B,
-               SDL::CONTROLLER_BUTTON_X, SDL::CONTROLLER_BUTTON_Y,
-               SDL::CONTROLLER_BUTTON_LEFTSHOULDER, SDL::CONTROLLER_BUTTON_RIGHTSHOULDER]
-      }.freeze
-
-      AXES = {
-        up: [SDL::CONTROLLER_AXIS_LEFTY, -1],
-        down: [SDL::CONTROLLER_AXIS_LEFTY, 1],
-        left: [SDL::CONTROLLER_AXIS_LEFTX, -1],
-        right: [SDL::CONTROLLER_AXIS_LEFTX, 1]
-      }.freeze
-
-      def initialize(computer)
-        SDL.check(SDL::InitSubSystem.call(SDL::INIT_GAMECONTROLLER))
-        @computer = computer
-        @controllers = []
-        @pressed = Array.new(PORTS.size) { [] }
-        rescan
-      end
-
-      def names = @controllers.map { |controller| SDL::GameControllerName.call(controller) }
-
-      def rescan
-        close
-        @controllers = (0...SDL::NumJoysticks.call)
-                       .select { |index| SDL::IsGameController.call(index) == 1 }
-                       .first(PORTS.size)
-                       .map { |index| SDL::GameControllerOpen.call(index) }
-                       .reject(&:null?)
-      end
-
-      def poll
-        @controllers.each_with_index { |controller, index| apply(controller, index) }
-      end
-
-      def close
-        @controllers.each { |controller| SDL::GameControllerClose.call(controller) }
-        @controllers = []
-        @pressed.size.times { |index| release(index) }
-      end
-
-      private
-
-      def apply(controller, index)
-        active = Joystick::DIRECTIONS.keys.select { |dir| active?(controller, dir) }
-        (@pressed[index] - active).each { |dir| joystick(index).release(dir) }
-        active.each { |dir| joystick(index).press(dir) }
-        @pressed[index] = active
-      end
-
-      def release(index)
-        @pressed[index].each { |dir| joystick(index).release(dir) }
-        @pressed[index] = []
-      end
-
-      def active?(controller, direction)
-        BUTTONS.fetch(direction).any? { |button| SDL::GameControllerGetButton.call(controller, button) == 1 } ||
-          tilted?(controller, direction)
-      end
-
-      def tilted?(controller, direction)
-        axis, sign = AXES[direction]
-        return false unless axis
-
-        SDL::GameControllerGetAxis.call(controller, axis) * sign > DEADZONE
-      end
-
-      def joystick(index)
-        PORTS[index] == 1 ? @computer.joystick1 : @computer.joystick2
-      end
-    end
-  end
-end

data/lib/badline/gui/joy_map.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # Maps host keys onto the two control ports while joystick mode is on.
-    #
-    # The arrow cluster plus space drives joystick 2, WASD plus left shift
-    # joystick 1, so both ports can be played at once.
-    class JoyMap
-      PORTS = {
-        2 => { "Up" => :up, "Down" => :down, "Left" => :left, "Right" => :right, "Space" => :fire }.freeze,
-        1 => { "W" => :up, "S" => :down, "A" => :left, "D" => :right, "Left Shift" => :fire }.freeze
-      }.freeze
-
-      def self.parse(event)
-        name = SDL.key_name(event.sym)
-
-        PORTS.each do |port, map|
-          direction = map[name]
-          return [port, direction] if direction
-        end
-
-        nil
-      end
-    end
-  end
-end

data/lib/badline/gui/key_map.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # Translates SDL key events into the emulator's key symbols.
-    #
-    # MAP is just the overrides, anything not covered simply falls though.
-    class KeyMap
-      MAP = {
-        "Backspace" => :delete,
-        "Return" => :return,
-        "Right" => :cursor_h,
-        "Down" => :cursor_v,
-        "Left" => :cursor_left,
-        "Up" => :cursor_up,
-        "`" => :left,
-        "]" => :up,
-        "PageUp" => :restore,
-        "Space" => :space,
-        "Left Ctrl" => :control,
-        "Left Alt" => :cbm,
-        "Left Shift" => :lshift,
-        "Right Shift" => :rshift,
-        "Home" => :clr_home,
-        "Escape" => :run_stop,
-        "Backslash" => :"@",
-        "'" => :":",
-        "End" => :£,
-        "Keypad +" => :+,
-        "Keypad *" => :*
-      }.freeze
-
-      def self.parse(event)
-        name = SDL.key_name(event.sym)
-        MAP[name] || name.downcase.to_sym
-      end
-    end
-  end
-end

data/lib/badline/gui/palette.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    class Palette
-      COLORS = [
-        "#000000", "#FFFFFF", "#924A40", "#84C5CC",
-        "#9351B6", "#72B14B", "#483AAA", "#D5DF7C",
-        "#675200", "#C33D00", "#C18178", "#606060",
-        "#8A8A8A", "#B3EC91", "#867ADE", "#B3B3B3"
-      ].freeze
-
-      attr_reader :dwords
-
-      def initialize
-        @dwords = COLORS.map { |hex| dword(hex) }.freeze
-        @entries = @dwords.map { |rgba| [rgba].pack("V") }.freeze
-      end
-
-      def [](color)
-        @entries[color]
-      end
-
-      private
-
-      # Color as a little-endian RGBA dword.
-      def dword(hex)
-        r = hex[1, 2].to_i(16)
-        g = hex[3, 2].to_i(16)
-        b = hex[5, 2].to_i(16)
-        (255 << 24) | (b << 16) | (g << 8) | r
-      end
-    end
-  end
-end

data/lib/badline/gui/pane.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    class Pane
-      attr_reader :left, :top, :width, :height
-
-      def initialize(width:, height:, left: 0, top: 0)
-        @width = width
-        @height = height
-        @left = left
-        @top = top
-        @rect = [left, top, width, height].pack("l4")
-      end
-
-      def render(_renderer)
-        raise NotImplementedError, "#{self.class} must implement #render"
-      end
-
-      private
-
-      # The pixels are little-endian RGBA dwords, red in the low byte.
-      def blit(renderer, pixels)
-        surface = SDL::CreateRGBSurfaceFrom.call(
-          pixels, width, height, 32, width * 4,
-          0x0000_00ff, 0x0000_ff00, 0x00ff_0000, 0xff00_0000
-        )
-        texture = SDL::CreateTextureFromSurface.call(renderer, surface)
-        SDL::RenderCopy.call(renderer, texture, nil, @rect)
-      ensure
-        SDL::DestroyTexture.call(texture) if texture
-        SDL::FreeSurface.call(surface) if surface
-      end
-    end
-  end
-end

data/lib/badline/gui/screen_pane.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    # The part of the VIC's raster the machine's region crops out.
-    class ScreenPane < Pane
-      def initialize(computer, left: 0, top: 0, palette: Palette.new)
-        @col_offset, @row_offset, crop_width, crop_height = computer.region.crop
-        super(width: crop_width, height: crop_height, left:, top:)
-        @computer = computer
-        @row_bytes = width * 4
-        @palette = palette.dwords
-        @buffer = ("\x00" * (height * @row_bytes)).b
-      end
-
-      def render(renderer)
-        blit(renderer, framebuffer)
-      end
-
-      private
-
-      # Repack only the scanlines the VIC has touched since the last frame.
-      def framebuffer
-        vic = @computer.vic
-        display = vic.display
-        vic_width = vic.width
-        dirty = vic.dirty_lines
-
-        height.times do |row|
-          next unless dirty[row + @row_offset]
-
-          @buffer[row * @row_bytes, @row_bytes] =
-            pack_row(display, vic_width, row)
-        end
-        vic.clear_dirty_lines!
-        @buffer
-      end
-
-      def pack_row(display, vic_width, row)
-        line = display[((row + @row_offset) * vic_width) + @col_offset, width]
-        line.map! { |c| @palette[c] }
-        line.pack("V*")
-      end
-    end
-  end
-end

data/lib/badline/gui/window.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module GUI
-    class Window
-      DEFAULT_REFRESH_RATE = 60
-
-      # SDL_DisplayMode: Uint32 format; int w, h, refresh_rate; then a pointer.
-      DISPLAY_MODE_SIZE = 24
-
-      attr_reader :renderer
-
-      def initialize(title:, width:, height:, scale: 2, vsync: true)
-        SDL.check(SDL::InitSubSystem.call(SDL::INIT_VIDEO | SDL::INIT_EVENTS))
-        SDL::SetHint.call("SDL_RENDER_SCALE_QUALITY", "0") # nearest-neighbour
-        SDL::SetHint.call("SDL_MOUSE_RELATIVE_SCALING", "0") # host pixels, whatever the window size
-
-        @window = SDL.check_pointer(SDL::CreateWindow.call(
-                                      title,
-                                      SDL::WINDOWPOS_CENTERED, SDL::WINDOWPOS_CENTERED,
-                                      width * scale, height * scale,
-                                      SDL::WINDOW_RESIZABLE
-                                    ))
-
-        flags = SDL::RENDERER_ACCELERATED
-        flags |= SDL::RENDERER_PRESENTVSYNC if vsync
-        @renderer = SDL.check_pointer(SDL::CreateRenderer.call(@window, -1, flags))
-        SDL.check(SDL::RenderSetLogicalSize.call(@renderer, width, height))
-      end
-
-      def title=(title)
-        SDL::SetWindowTitle.call(@window, title)
-      end
-
-      def refresh_rate
-        mode = "\0".b * DISPLAY_MODE_SIZE
-        SDL.check(SDL::GetCurrentDisplayMode.call(0, mode))
-        rate = mode.unpack1("l", offset: 12)
-        rate.positive? ? rate : DEFAULT_REFRESH_RATE
-      rescue SDL::Error
-        DEFAULT_REFRESH_RATE
-      end
-
-      def draw(panes)
-        SDL::SetRenderDrawColor.call(@renderer, 0, 0, 0, 255)
-        SDL::RenderClear.call(@renderer)
-        panes.each { |pane| pane.render(@renderer) }
-        SDL::RenderPresent.call(@renderer)
-      end
-
-      def close
-        return unless @window
-
-        SDL::DestroyRenderer.call(@renderer)
-        SDL::DestroyWindow.call(@window)
-        SDL::QuitSubSystem.call(SDL::INIT_VIDEO | SDL::INIT_EVENTS)
-        @window = nil
-      end
-    end
-  end
-end

data/lib/badline/gui.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/sdl"
-
-require "badline/gui/palette"
-require "badline/gui/key_map"
-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/sdl/events.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module SDL
-    KEY_TAB = 0x09
-    KEY_F10 = 0x4000_0043
-    KMOD_SHIFT = 0x0003
-
-    # The events the front end handles. SDL_Event is a 56-byte union, read
-    # here at the offsets its keyboard, mouse and controller members use.
-    Quit = Data.define
-    # A held key sends repeats, flagged at byte 13 of the event.
-    KeyDown = Data.define(:sym, :mod, :repeat) do
-      def initialize(sym:, mod:, repeat: false) = super
-    end
-    KeyUp = Data.define(:sym, :mod)
-    MouseMotion = Data.define(:xrel, :yrel)
-    MouseButton = Data.define(:button, :pressed)
-    ControllerDevice = Data.define
-
-    EVENT_SIZE = 56
-
-    # The next event the front end handles, skipping the others, or nil once
-    # the queue is empty.
-    def self.poll_event
-      buffer = (@event ||= Fiddle::Pointer.malloc(EVENT_SIZE, Fiddle::RUBY_FREE))
-      while PollEvent.call(buffer) == 1
-        event = decode(buffer.to_str(EVENT_SIZE))
-        return event if event
-      end
-      nil
-    end
-
-    def self.decode(bytes)
-      case bytes.unpack1("L")
-      when 0x100 then Quit.new
-      when 0x300 then KeyDown.new(*bytes.unpack("lS", offset: 20), bytes.getbyte(13) != 0)
-      when 0x301 then KeyUp.new(*bytes.unpack("lS", offset: 20))
-      when 0x400 then MouseMotion.new(*bytes.unpack("l2", offset: 28))
-      when 0x401, 0x402 then MouseButton.new(bytes.getbyte(16), bytes.getbyte(17) == 1)
-      when 0x653..0x655 then ControllerDevice.new
-      end
-    end
-
-    def self.key_name(sym) = GetKeyName.call(sym)
-  end
-end