badline 0.1.0 → 0.2.1

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

data/lib/badline/instruction_set/branch.rb

@@ -7,71 +7,72 @@ module Badline
       #
       # Opcodes:
       #   $90 - relative - 2+ cycles
-      def bcc(addr, _value)
-        branch(addr) unless status.carry?
+      def bcc(_addr, _value)
+        take_branch unless status.carry?
       end
 
       # Branch if carry set (C=1).
       #
       # Opcodes:
       #   $B0 - relative - 2+ cycles
-      def bcs(addr, _value)
-        branch(addr) if status.carry?
+      def bcs(_addr, _value)
+        take_branch if status.carry?
       end
 
       # Branch if equal (Z=1).
       #
       # Opcodes:
       #   $F0 - relative - 2+ cycles
-      def beq(addr, _value)
-        branch(addr) if status.zero?
+      def beq(_addr, _value)
+        take_branch if status.zero?
       end
 
       # Branch if minus (N=1).
       #
       # Opcodes:
       #   $30 - relative - 2+ cycles
-      def bmi(addr, _value)
-        branch(addr) if status.negative?
+      def bmi(_addr, _value)
+        take_branch if status.negative?
       end
 
       # Branch if not equal (Z=0).
       #
       # Opcodes:
       #   $D0 - relative - 2+ cycles
-      def bne(addr, _value)
-        branch(addr) unless status.zero?
+      def bne(_addr, _value)
+        take_branch unless status.zero?
       end
 
       # Branch if plus (N=0).
       #
       # Opcodes:
       #   $10 - relative - 2+ cycles
-      def bpl(addr, _value)
-        branch(addr) unless status.negative?
+      def bpl(_addr, _value)
+        take_branch unless status.negative?
       end
 
       # Branch if overflow clear (V=0).
       #
       # Opcodes:
       #   $50 - relative - 2+ cycles
-      def bvc(addr, _value)
-        branch(addr) unless status.overflow?
+      def bvc(_addr, _value)
+        take_branch unless status.overflow?
       end
 
       # Branch if overflow set (V=1).
       #
       # Opcodes:
       #   $70 - relative - 2+ cycles
-      def bvs(addr, _value)
-        branch(addr) if status.overflow?
+      def bvs(_addr, _value)
+        take_branch if status.overflow?
       end
 
       private
 
-      def branch(addr)
-        cycle if high_byte(addr) != high_byte(@program_counter)
-        cycle { @program_counter = addr }
+      # Marks the branch as taken. Operations#op_relative reads the flag
+      # and runs the extra cycles.
+      def take_branch
+        @branch_taken = true
       end
     end
   end

data/lib/badline/instruction_set/flag.rb

@@ -8,7 +8,7 @@ module Badline
       # Opcodes:
       #   $18 - implied - 2 cycles
       def clc(_addr, _value)
-        cycle { status.carry = false }
+        status.carry = false
       end
 
       # Clear decimal mode flag.
@@ -16,7 +16,7 @@ module Badline
       # Opcodes:
       #   $D8 - implied - 2 cycles
       def cld(_addr, _value)
-        cycle { status.decimal = false }
+        status.decimal = false
       end
 
       # Clear interrupt disable flag.
@@ -24,7 +24,7 @@ module Badline
       # Opcodes:
       #   $58 - implied - 2 cycles
       def cli(_addr, _value)
-        cycle { status.interrupt = false }
+        status.interrupt = false
       end
 
       # Clear overflow flag.
@@ -32,7 +32,7 @@ module Badline
       # Opcodes:
       #   $B8 - implied - 2 cycles
       def clv(_addr, _value)
-        cycle { status.overflow = false }
+        status.overflow = false
       end
 
       # Set carry flag.
@@ -40,7 +40,7 @@ module Badline
       # Opcodes:
       #   $38 - implied - 2 cycles
       def sec(_addr, _value)
-        cycle { status.carry = true }
+        status.carry = true
       end
 
       # Set decimal mode flag.
@@ -48,7 +48,7 @@ module Badline
       # Opcodes:
       #   $F8 - implied - 2 cycles
       def sed(_addr, _value)
-        cycle { status.decimal = true }
+        status.decimal = true
       end
 
       # Set interrupt disable flag.
@@ -56,7 +56,7 @@ module Badline
       # Opcodes:
       #   $78 - implied - 2 cycles
       def sei(_addr, _value)
-        cycle { status.interrupt = true }
+        status.interrupt = true
       end
     end
   end

data/lib/badline/instruction_set/illegal.rb

@@ -9,7 +9,7 @@ module Badline
       # Opcodes:
       #   $4B - immediate - 2 cycles
       def alr(_addr, value)
-        @a &= resolve(value)
+        @a &= value
         status.carry = @a[0]
         @a = (@a >> 1) & 0xff
         update_number_flags(@a)
@@ -25,13 +25,14 @@ module Badline
       end
 
       # Unstable instruction. AND's value with A|magic_const and X.
-      # Magic constant varies by CPU.
+      # Magic constant varies by CPU. A VIC stall between the opcode and
+      # operand fetches clears its bits 0 and 4.
       #
       # Opcodes:
       #   $8B - immediate - 2 cycles
       def ane(_addr, value)
-        magic_const = 0xee
-        @a = (a | magic_const) & x & resolve(value)
+        magic_const = stalled_before_this_cycle? ? @ane_constant & 0xee : @ane_constant
+        @a = (a | magic_const) & x & value
         update_number_flags(@a)
       end
 
@@ -40,7 +41,7 @@ module Badline
       # Opcodes:
       #   $6B - immediate - 2 cycles
       def arr(_addr, value)
-        tmp = a & resolve(value)
+        tmp = a & value
         result = (tmp >> 1) | (status.carry? ? 0x80 : 0)
         status.zero = result.zero?
         status.negative = status.carry
@@ -94,23 +95,12 @@ module Badline
         sbc(addr, inc(addr, value))
       end
 
-      # Freezes the CPU by forcing an infinite loop.
-      #
-      # Opcodes:
-      #   $02, $12, $22, $32, $42, $52, $62, $72, $92, $B2, $D2, $F2
-      def jam(_addr, _value)
-        # TODO: Handle jam
-        # It is possible to implement with loop { cycle }, but makes
-        # testing problematic.
-        10.times { cycle }
-      end
-
       # Loads A and S with value AND stack pointer.
       #
       # Opcodes:
       #   $BB - absolute_y - 4 cycles
       def las(_addr, value)
-        @a = @x = @stack_pointer = resolve(value) & stack_pointer
+        @a = @x = @stack_pointer = value & stack_pointer
         update_number_flags(@a)
       end
 
@@ -124,7 +114,7 @@ module Badline
       #   $B7 - zeropage_y - 4 cycles
       #   $BF - absolute_y - 4+ cycles
       def lax(_addr, value)
-        @a = @x = resolve(value)
+        @a = @x = value
 
         update_number_flags(@a)
       end
@@ -136,7 +126,7 @@ module Badline
       #   $AB - immediate - 2 cycles
       def lxa(_addr, value)
         magic_const = 0xee
-        @a = @x = (a | magic_const) & resolve(value)
+        @a = @x = (a | magic_const) & value
         update_number_flags(@a)
       end
 
@@ -191,8 +181,7 @@ module Badline
       # Opcodes:
       #   $CB - immediate - 2 cycles
       def sbx(_addr, value)
-        v = resolve(value)
-        result = (@x & @a) - v
+        result = (@x & @a) - value
         status.carry = result >= 0
         @x = result & 0xff
         update_number_flags(@x)
@@ -263,6 +252,9 @@ module Badline
 
       private
 
+      # A VIC stall right before the dummy read, the second-to-last cycle,
+      # drops the & (H+1) from the stored value but not from the high byte
+      # of a page-crossing target.
       def store_high_and(register, addr)
         base_high = if boundary_crossed
                       (high_byte(addr) - 1) & 0xff
@@ -271,7 +263,7 @@ module Badline
                     end
         result = register & ((base_high + 1) & 0xff)
         target = boundary_crossed ? uint16(low_byte(addr), result) : addr
-        write_byte(target, result)
+        write_byte(target, stalled_before_previous_cycle? ? register : result)
       end
     end
   end