badline 0.1.0 → 0.2.0

data/lib/badline/datasette.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+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.
+  class Datasette
+    attr_reader :tape
+    attr_writer :motor
+
+    def initialize(tape = nil)
+      @tape = tape
+      @playing = false
+      @motor = false
+      @countdown = 0
+      @flag_handler = nil
+      @sense_handler = nil
+    end
+
+    # Falling edges on the tape read line.
+    def on_flag(&handler)
+      @flag_handler = handler
+    end
+
+    # The cassette sense line, which the $01 port reads back.
+    def on_sense_change(&handler)
+      @sense_handler = handler
+    end
+
+    def insert(tape)
+      @tape = tape
+      rewind
+    end
+
+    def eject
+      stop!
+      @tape = nil
+    end
+
+    def rewind
+      @tape&.rewind
+      @countdown = 0
+    end
+
+    def play! = press(true)
+    def stop! = press(false)
+
+    def playing? = @playing
+
+    # Sense reads low while a key is down on the deck.
+    def sense_low? = @playing
+
+    def motor? = @motor
+
+    def running? = @playing && @motor && !@tape.nil?
+
+    def cycle!
+      return unless running?
+
+      @countdown = @tape.next_pulse.to_i if @countdown.zero?
+      return if @countdown.zero?
+
+      @countdown -= 1
+      @flag_handler&.call if @countdown.zero?
+    end
+
+    def inspect
+      "#<#{self.class.name} tape=#{@tape ? @tape.class.name : 'none'} " \
+        "playing=#{@playing} motor=#{@motor}>"
+    end
+
+    private
+
+    def press(down)
+      return if down == @playing
+
+      @playing = down
+      @sense_handler&.call
+    end
+  end
+end

data/lib/badline/debug_register.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  # The VICE debug cartridge register, mapped at $D7FF on the C64. It is a
+  # VICE facility rather than real hardware, enabled there with -debugcart:
+  # writing a byte ends the run with that value as the exit code. The VICE
+  # test suites write $00 for success and $ff for failure.
+  #
+  # Wraps the SID's top mirror page, so every other access falls through.
+  class DebugRegister
+    ADDRESS = 0xd7ff
+
+    def initialize(sid, &handler)
+      @sid = sid
+      @handler = handler
+    end
+
+    def peek(addr)
+      @sid.peek(addr)
+    end
+
+    def poke(addr, value)
+      return @handler.call(value) if addr == ADDRESS
+
+      @sid.poke(addr, value)
+    end
+  end
+end

data/lib/badline/gui/application.rb

@@ -6,20 +6,42 @@ module Badline
       PAL_CLOCK_HZ = 985_248
       TITLE = "Badline"
       TOGGLE_SYM = SDL2::Key::TAB
+      REVERSE_MOD = SDL2::Key::Mod::SHIFT
 
-      SHARED_KEYS = %i[up left cursor_h cursor_v space].freeze
+      SHARED_KEYS = %i[up left cursor_h cursor_v space w a s d lshift].freeze
 
-      def initialize(media_path: nil, autostart: true, debug: false)
-        @computer = Computer.new(debug:)
-        puts Media.attach(@computer, media_path, autostart:) if media_path
+      # 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
 
-        @joystick_mode = false
+      # 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
+
+      def initialize(media_path: nil, autostart: true, song: nil, sid_model: nil, debug: false)
+        @computer = Computer.new(debug:, sid_model: sid_model || Media.sid_model(media_path))
+        puts Media.attach(@computer, media_path, autostart:, song:) if media_path
+
+        @mode = :keyboard
+        @pot_device = nil
         @panes = [ScreenPane.new(@computer)]
         @window = Window.new(
           title: TITLE,
           width: canvas_width, height: canvas_height,
           vsync: ENV["NOVSYNC"].nil?
         )
+        @gamepads = Gamepads.new(@computer)
+        @gamepads.names.each { |name| puts "Gamepad: #{name}" }
 
         rate = @window.refresh_rate
         @cycles_per_frame = PAL_CLOCK_HZ / rate
@@ -30,10 +52,12 @@ module Badline
         @running = true
         while @running
           handle_events
+          @gamepads.poll
           @cycles_per_frame.times { @computer.cycle! }
           @window.draw(@panes)
         end
       ensure
+        @gamepads.close
         puts @computer.cpu.inspect
       end
 
@@ -48,15 +72,22 @@ module Badline
             handle_key_down(event)
           when SDL2::Event::KeyUp
             handle_key_up(event)
+          when SDL2::Event::MouseMotion
+            @pot_device&.move(event.xrel, event.yrel)
+          when SDL2::Event::MouseButton
+            handle_mouse_button(event)
+          when SDL2::Event::ControllerDevice
+            @gamepads.rescan
           end
         end
       end
 
       def handle_key_down(event)
-        if event.sym == TOGGLE_SYM
-          toggle_joystick_mode
-        elsif @joystick_mode && (dir = JoyMap.parse(event))
-          @computer.joystick2.press(dir)
+        return cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1) if event.sym == TOGGLE_SYM
+
+        port, dir = JoyMap.parse(event) if @mode == :joystick
+        if port
+          joystick(port).press(dir)
         else
           @computer.keyboard.press(KeyMap.parse(event))
         end
@@ -65,21 +96,51 @@ module Badline
       def handle_key_up(event)
         return if event.sym == TOGGLE_SYM
 
-        if @joystick_mode && (dir = JoyMap.parse(event))
-          @computer.joystick2.release(dir)
+        port, dir = JoyMap.parse(event) if @mode == :joystick
+        if port
+          joystick(port).release(dir)
         else
           @computer.keyboard.release(KeyMap.parse(event))
         end
       end
 
-      def toggle_joystick_mode
-        @joystick_mode = !@joystick_mode
-        if @joystick_mode
-          SHARED_KEYS.each { |key| @computer.keyboard.release(key) }
-        else
-          Joystick::DIRECTIONS.each_key { |dir| @computer.joystick2.release(dir) }
+      def handle_mouse_button(event)
+        button = MOUSE_BUTTONS[event.button]
+        return unless button && @pot_device
+
+        case event
+        when SDL2::Event::MouseButtonDown then @pot_device.press(button)
+        when SDL2::Event::MouseButtonUp then @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
+        @window.title = [TITLE, MODES[@mode] && "[#{MODES[@mode]}]"].compact.join(" ")
+      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
+        SDL2::Mouse.relative_mode = !@pot_device.nil?
+      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
-        @window.title = @joystick_mode ? "#{TITLE} [JOY]" : TITLE
       end
 
       def canvas_width

data/lib/badline/gui/gamepads.rb

@@ -0,0 +1,97 @@
+# 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, and the binding gives no way to line the two up, so 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: [SDL2::GameController::Button::DPAD_UP],
+        down: [SDL2::GameController::Button::DPAD_DOWN],
+        left: [SDL2::GameController::Button::DPAD_LEFT],
+        right: [SDL2::GameController::Button::DPAD_RIGHT],
+        fire: [SDL2::GameController::Button::A, SDL2::GameController::Button::B,
+               SDL2::GameController::Button::X, SDL2::GameController::Button::Y,
+               SDL2::GameController::Button::LEFTSHOULDER,
+               SDL2::GameController::Button::RIGHTSHOULDER]
+      }.freeze
+
+      AXES = {
+        up: [SDL2::GameController::Axis::LEFTY, -1],
+        down: [SDL2::GameController::Axis::LEFTY, 1],
+        left: [SDL2::GameController::Axis::LEFTX, -1],
+        right: [SDL2::GameController::Axis::LEFTX, 1]
+      }.freeze
+
+      def initialize(computer)
+        SDL2.init(SDL2::INIT_GAMECONTROLLER)
+        @computer = computer
+        @controllers = []
+        @pressed = Array.new(PORTS.size) { [] }
+        rescan
+      end
+
+      def names = @controllers.map(&:name)
+
+      def rescan
+        close
+        @controllers = (0...SDL2::Joystick.num_connected_joysticks)
+                       .select { |index| SDL2::Joystick.game_controller?(index) }
+                       .first(PORTS.size)
+                       .map { |index| SDL2::GameController.open(index) }
+      end
+
+      def poll
+        @controllers.each_with_index { |controller, index| apply(controller, index) }
+      end
+
+      def close
+        @controllers.each { |controller| controller.destroy unless controller.destroy? }
+        @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| controller.button_pressed?(button) } ||
+          tilted?(controller, direction)
+      end
+
+      def tilted?(controller, direction)
+        axis, sign = AXES[direction]
+        return false unless axis
+
+        controller.axis(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

@@ -2,17 +2,25 @@
 
 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
-      MAP = {
-        "Up" => :up,
-        "Down" => :down,
-        "Left" => :left,
-        "Right" => :right,
-        "Space" => :fire
+      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)
-        MAP[SDL2::Key.name_of(event.sym)]
+        name = SDL2::Key.name_of(event.sym)
+
+        PORTS.each do |port, map|
+          direction = map[name]
+          return [port, direction] if direction
+        end
+
+        nil
       end
     end
   end

data/lib/badline/gui.rb

@@ -5,6 +5,7 @@ require "sdl2"
 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/window"

data/lib/badline/input/mouse1351.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    # Commodore 1351 mouse in proportional mode.
+    #
+    # Each axis drives a 6-bit counter that the mouse presents on POTX/POTY
+    # shifted up one bit. A driver recovers movement by masking off bit 7,
+    # subtracting the previous reading and halving the difference. The counters
+    # wrap, so a single reading says nothing on its own, and the driver has to
+    # sample before the mouse travels 32 counts.
+    #
+    # #move takes host deltas with y counting down the screen; the counter
+    # counts the other way. The left button sits on the joystick fire line, the
+    # right button on the up line.
+    class Mouse1351
+      BUTTONS = { left: :fire, right: :up }.freeze
+
+      def initialize
+        @lines = Joystick.new
+        @x = 0
+        @y = 0
+      end
+
+      def press(button) = @lines.press(BUTTONS[button])
+
+      def release(button) = @lines.release(BUTTONS[button])
+
+      def port_bits = @lines.port_bits
+
+      def move(delta_x, delta_y)
+        @x = (@x + delta_x) & 0x3f
+        @y = (@y - delta_y) & 0x3f
+      end
+
+      def pot_x = @x << 1
+
+      def pot_y = @y << 1
+    end
+  end
+end

data/lib/badline/input/paddles.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    # A pair of paddles on one control port.
+    #
+    # Paddle A sits on POTX with its button on the joystick left line, paddle B
+    # on POTY with its button on the right line. Positions are the 0-255 counts
+    # SID reads back, and the knobs stop at either end.
+    #
+    # Buttons are named after the host mouse buttons, as on the 1351: the left
+    # one fires paddle A, the right one paddle B.
+    class Paddles
+      BUTTONS = { left: :left, right: :right }.freeze
+
+      attr_reader :pot_x, :pot_y
+
+      def initialize
+        @lines = Joystick.new
+        @pot_x = 0x80
+        @pot_y = 0x80
+      end
+
+      def press(button) = @lines.press(BUTTONS[button])
+
+      def release(button) = @lines.release(BUTTONS[button])
+
+      def port_bits = @lines.port_bits
+
+      def move(turn_a, turn_b)
+        @pot_x = (@pot_x + turn_a).clamp(0, 0xff)
+        @pot_y = (@pot_y + turn_b).clamp(0, 0xff)
+      end
+    end
+  end
+end

data/lib/badline/input.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "badline/input/mouse1351"
+require "badline/input/paddles"

data/lib/badline/instruction_set/arithmetic.rb

@@ -15,19 +15,18 @@ module Badline
       #   $79 - absolute_y - 4+ cycles
       #   $7D - absolute_x - 4+ cycles
       def adc(_addr, value)
-        v = resolve(value)
-        result = a + v + status.carry
+        result = a + value + status.carry
         status.zero = result.nobits?(0xff)
 
         if status.decimal?
-          result = (a & 0x0f) + (v & 0x0f) + status.carry
+          result = (a & 0x0f) + (value & 0x0f) + status.carry
           result += 0x06 if result > 0x09
           c = result > 0x0f ? 1 : 0
-          result = (a & 0xf0) + (v & 0xf0) + (c << 4) + (result & 0x0f)
-          update_calculation_flags(v, result)
+          result = (a & 0xf0) + (value & 0xf0) + (c << 4) + (result & 0x0f)
+          update_calculation_flags(value, result)
           result += 0x60 if result > 0x9f
         else
-          update_calculation_flags(v, result)
+          update_calculation_flags(value, result)
         end
 
         status.carry = result > 0xff
@@ -46,9 +45,8 @@ module Badline
       #   $D9 - absolute_y - 4+ cycles
       #   $DD - absolute_x - 4+ cycles
       def cmp(_addr, value)
-        v = resolve(value)
-        status.carry = (@a >= v)
-        update_number_flags(@a - v)
+        status.carry = (@a >= value)
+        update_number_flags(@a - value)
       end
 
       # Compare memory with X register.
@@ -58,9 +56,8 @@ module Badline
       #   $E4 - zeropage   - 3 cycles
       #   $EC - absolute   - 4 cycles
       def cpx(_addr, value)
-        v = resolve(value)
-        status.carry = @x >= v
-        update_number_flags(@x - v)
+        status.carry = @x >= value
+        update_number_flags(@x - value)
       end
 
       # Compare memory with Y register.
@@ -70,9 +67,8 @@ module Badline
       #   $C4 - zeropage   - 3 cycles
       #   $CC - absolute   - 4 cycles
       def cpy(_addr, value)
-        v = resolve(value)
-        status.carry = @y >= v
-        update_number_flags(@y - v)
+        status.carry = @y >= value
+        update_number_flags(@y - value)
       end
 
       # Subtract memory from accumulator with borrow.
@@ -87,20 +83,19 @@ module Badline
       #   $F9 - absolute_y - 4+ cycles
       #   $FD - absolute_x - 4+ cycles
       def sbc(_addr, value)
-        v = resolve(value)
-        v_inv = ~v & 0xff
+        inverted = ~value & 0xff
         carry = status.carry? ? 0 : -1
 
-        result = a + v_inv + status.carry
+        result = a + inverted + status.carry
         status.zero = result.nobits?(0xff)
         status.carry = result > 0xff
-        update_calculation_flags(v_inv, result)
+        update_calculation_flags(inverted, result)
 
         if status.decimal?
-          al = (a & 0x0f) - (v & 0x0f) + carry
+          al = (a & 0x0f) - (value & 0x0f) + carry
           al = ((al - 0x06) & 0x0F) - 0x10 if al.negative?
 
-          result = (a & 0xf0) - (v & 0xf0) + al
+          result = (a & 0xf0) - (value & 0xf0) + al
           result -= 0x60 if result.negative?
         end
 

data/lib/badline/instruction_set/bitwise.rb

@@ -15,7 +15,7 @@ module Badline
       #   $39 - absolute_y - 4+ cycles
       #   $3D - absolute_x - 4+ cycles
       def and(_addr, value)
-        @a &= resolve(value)
+        @a &= value
         update_number_flags(@a)
       end
 
@@ -28,10 +28,9 @@ module Badline
       #   $16 - zeropage_x - 6 cycles
       #   $1E - absolute_x - 7 cycles
       def asl(addr, value)
-        v = resolve(value)
-        result = (v << 1) & 0xff
-        status.carry = v[7]
-        write_modified(addr, v, result)
+        result = (value << 1) & 0xff
+        status.carry = value[7]
+        write_modified(addr, result)
         update_number_flags(result)
       end
 
@@ -41,10 +40,9 @@ module Badline
       #   $24 - zeropage - 3 cycles
       #   $2C - absolute - 4 cycles
       def bit(_addr, value)
-        v = resolve(value)
         status.value = ((status.value & 0b00111111) +
-                        (v & 0b11000000)).to_i
-        status.zero = (a & v).nobits?(0xff)
+                        (value & 0b11000000)).to_i
+        status.zero = (a & value).nobits?(0xff)
       end
 
       # Performs bitwise XOR on accumulator with memory.
@@ -59,7 +57,7 @@ module Badline
       #   $59 - absolute_y - 4+ cycles
       #   $5D - absolute_x - 4+ cycles
       def eor(_addr, value)
-        @a = (@a ^ resolve(value)) & 0xff
+        @a = (@a ^ value) & 0xff
         update_number_flags(@a)
       end
 
@@ -72,10 +70,9 @@ module Badline
       #   $56 - zeropage_x - 6 cycles
       #   $5E - absolute_x - 7 cycles
       def lsr(addr, value)
-        v = resolve(value)
-        result = (v >> 1) & 0xff
-        status.carry = v[0]
-        write_modified(addr, v, result)
+        result = (value >> 1) & 0xff
+        status.carry = value[0]
+        write_modified(addr, result)
         update_number_flags(result)
       end
 
@@ -91,7 +88,7 @@ module Badline
       #   $19 - absolute_y - 4+ cycles
       #   $1D - absolute_x - 4+ cycles
       def ora(_addr, value)
-        @a |= resolve(value)
+        @a |= value
         update_number_flags(@a)
       end
 
@@ -104,10 +101,9 @@ module Badline
       #   $36 - zeropage_x - 6 cycles
       #   $3E - absolute_x - 7 cycles
       def rol(addr, value)
-        v = resolve(value)
-        result = ((v << 1) + status.carry) & 0xff
-        status.carry = v[7]
-        write_modified(addr, v, result)
+        result = ((value << 1) + status.carry) & 0xff
+        status.carry = value[7]
+        write_modified(addr, result)
         update_number_flags(result)
       end
 
@@ -120,10 +116,9 @@ module Badline
       #   $76 - zeropage_x - 6 cycles
       #   $7E - absolute_x - 7 cycles
       def ror(addr, value)
-        v = resolve(value)
-        result = ((v >> 1) + (status.carry? ? 0x80 : 0)) & 0xff
-        status.carry = v[0]
-        write_modified(addr, v, result)
+        result = ((value >> 1) + (status.carry? ? 0x80 : 0)) & 0xff
+        status.carry = value[0]
+        write_modified(addr, result)
         update_number_flags(result)
       end
     end