badline 0.1.0 → 0.2.1

data/lib/badline/cpu.rb

@@ -1,35 +1,61 @@
 # frozen_string_literal: true
 
+require "badline/cpu/microcode"
+require "badline/cpu/addressing"
+require "badline/cpu/operations"
+require "badline/cpu/stack_operations"
+
 module Badline
-  class CPU < Cycleable
-    STATUS_FLAGS = [:carry, :zero, :interrupt, :decimal, :break, 1,
-                    :overflow, :negative].freeze
+  class CPU
+    STATUS_FLAGS = [:carry, :zero, :interrupt, :decimal, :break, 1, :overflow, :negative].freeze
 
-    class InvalidOpcodeError < StandardError; end
     include IntegerHelper
     include InstructionSet
+    include Interrupts
     include Traps
+    include Addressing
+    include Operations
+    include StackOperations
+
+    attr_reader :memory, :instructions, :boundary_crossed, :cycles, :pending_write
+    attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y, :nmi, :irq
 
-    attr_reader :memory, :instructions, :boundary_crossed
-    attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y,
-                  :nmi, :irq
+    alias pending_write? pending_write
 
-    def initialize(memory = nil, debug: false)
+    # +ane_constant+ is ANE's magic constant, which varies from chip to
+    # chip. The default is the C64 6510's.
+    def initialize(memory = nil, debug: false, ane_constant: 0xef)
       @debug = debug
+      @ane_constant = ane_constant
       @memory = memory || Memory.new
-      @status = Status.new(STATUS_FLAGS, value: 0b00100000)
+      @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
       reset_registers
 
       @nmi = @irq = false
+      @irq_sample = @irq_pending = false
+      @nmi_sample = @nmi_pending = false
+      @skip_poll = false
+      @boundary_crossed = false
+      @interrupt = nil
+      @brk = false
+      @pending_write = false
+      @stalled_at = nil
 
+      @cycles = 0
       @instructions = 0
       @traps = nil
-      super()
+      end_sequence
     end
 
     def reset!
       status.interrupt = true
       reset_registers
+      @nmi = false
+      @irq_sample = @irq_pending = false
+      @nmi_sample = @nmi_pending = false
+      @skip_poll = false
+      @pending_write = false
+      end_sequence
     end
 
     def p
@@ -40,9 +66,37 @@ module Badline
       status.value = new_value
     end
 
+    def cycle!
+      poll # the interrupt lines
+
+      # Run the next step
+      index = @index
+      @index = index + 1
+      send(@plan[index])
+      @cycles += 1
+
+      # Record if the next step writes to memory
+      @pending_write = @writes[@index]
+      nil
+    end
+
+    # Called instead of #cycle! on a cycle the VIC holds the CPU through
+    # BA. Records which cycle the CPU was stalled before, and keeps
+    # sampling the interrupt lines.
+    def stall!
+      @stalled_at = @cycles
+      sample_while_stalled
+    end
+
+    def jammed?
+      @plan.equal?(JAMMED_PLAN)
+    end
+
+    # Runs to the end of the instruction, or until the CPU jams.
     def step!
-      @loop.resume unless @instruction || @interrupt
-      cycle! while @instruction || @interrupt
+      cycle!
+      cycle! until @plan.equal?(FETCH_PLAN) || jammed?
+      nil
     end
 
     def inspect
@@ -53,66 +107,58 @@ module Badline
 
     private
 
-    def extra_cycle(instruction)
-      return cycle unless instruction.boundary_cycle?
-
-      boundary_crossed && cycle
-    end
-
-    def handle_interrupt(vector, brk: false, pre_cycles: 2)
-      pre_cycles.times { cycle }
-
-      pc = program_counter
-      pc = (pc + 1) & 0xffff if brk
+    # The first cycle of every instruction. Starts an interrupt if one was
+    # pending when the previous instruction ended. Otherwise reads the
+    # opcode and switches to its plan.
+    def op_fetch
+      return start_interrupt if @boundary_nmi || @boundary_irq
 
-      write_byte(stack_address, high_byte(pc))
-      @stack_pointer = (@stack_pointer - 1) & 0xff
-      write_byte(stack_address, low_byte(pc))
-      @stack_pointer = (@stack_pointer - 1) & 0xff
-      write_byte(stack_address,
-                 status.clone.tap { |s| s.break = brk }.value)
-      @stack_pointer = (@stack_pointer - 1) & 0xff
-      status.interrupt = true
-      @program_counter = read_word(vector)
+      run_traps
+      opcode = @memory.peek(@program_counter)
+      log(opcode) if @debug
+      micro = MICROCODE[opcode]
+      @operation = micro.operation
+      @plan = micro.plan
+      @writes = micro.writes
+      @optional_dummy = micro.optional_dummy
+      @index = 1
+      @boundary_crossed = false
+      @program_counter = (@program_counter + 1) & 0xffff
     end
 
-    def handle_interrupts
-      @interrupt = if nmi
-                     0xfffa
-                   elsif irq && !status.interrupt?
-                     0xfffe
-                   end
-
-      handle_interrupt(@interrupt) if @interrupt
-      @interrupt = nil
-      @nmi = @irq = false
+    def end_instruction
+      @instructions += 1
+      end_sequence
     end
 
-    def read_byte(addr)
-      cycle { @memory.peek(addr) }
+    # Makes the next cycle an opcode fetch, and saves the pending interrupt
+    # flags for op_fetch. The next cycle polls before op_fetch runs, which
+    # updates the live flags.
+    def end_sequence
+      @plan = FETCH_PLAN
+      @writes = FETCH_WRITES
+      @index = 0
+      @boundary_irq = @irq_pending
+      @boundary_nmi = @nmi_pending
     end
 
-    def read_word(addr)
-      uint16(read_byte(addr),
-             read_byte((addr + 1) & 0xffff))
+    # True when the CPU was stalled right before this cycle.
+    def stalled_before_this_cycle?
+      @stalled_at == @cycles
     end
 
-    def read_zeropage_word(addr)
-      uint16(read_byte(addr & 0xff),
-             read_byte((addr + 1) & 0xff))
+    # True when the CPU was stalled right before the cycle that preceded
+    # this one.
+    def stalled_before_previous_cycle?
+      @stalled_at == @cycles - 1
     end
 
-    def read_instruction
-      Instruction.find(@memory.peek(@program_counter))
+    def write_byte(addr, value)
+      @memory.poke(addr, value)
     end
 
-    def read_operand(instruction)
-      return nil unless instruction.operand?
-      # JSR fetches its operand high byte late (see Stack#jsr).
-      return read_byte(program_counter) if instruction.name == :jsr
-      return read_word(program_counter) if instruction.operand_length == 2
-
-      read_byte(program_counter)
+    def stack_address(offset = 0)
+      0x0100 | ((@stack_pointer + offset) & 0xff)
     end
 
     def reset_registers
@@ -123,117 +169,12 @@ module Badline
       @a = @x = @y = 0x0
     end
 
-    def read_address(instruction, operand)
-      case instruction.addressing_mode
-      when :implied, :immediate
-        nil
-      when :accumulator
-        :accumulator
-      when :relative
-        (@program_counter + signed_int8(operand) + 1) & 0xffff
-      when :zeropage, :absolute
-        operand
-      when :zeropage_x
-        cycle { (operand + @x) & 0xff }
-      when :zeropage_y
-        cycle { (operand + @y) & 0xff }
-      when :absolute_x
-        # Do an extra cycle if page boundary is crossed
-        @boundary_crossed = high_byte(operand + @x) != high_byte(operand)
-        extra_cycle(instruction)
-        (operand + @x) & 0xffff
-      when :absolute_y
-        @boundary_crossed = high_byte(operand + @y) != high_byte(operand)
-        # Do an extra cycle if page boundary is crossed
-        extra_cycle(instruction)
-        (operand + @y) & 0xffff
-      when :indirect
-        # This is only used for JMP. There's no carry associated, so an
-        # indirect jump to $30FF will wrap around on the same page and read
-        # from [0x30ff, 0x3000].
-        uint16(
-          read_byte(operand),
-          read_byte(uint16(
-                      (low_byte(operand) + 1) & 0xff, # Wrap around low byte
-                      high_byte(operand)
-                    ))
-        )
-      when :indirect_x
-        cycle
-        read_zeropage_word(operand + @x)
-      when :indirect_y
-        value = read_zeropage_word(operand)
-        @boundary_crossed = ((value & 0xff) + y) > 0xff
-        # Do an extra cycle if page boundary is crossed
-        extra_cycle(instruction)
-        (value + y) & 0xffff
-      end
-    end
-
-    def realize_value(instruction, operand, address)
-      case instruction.addressing_mode
-      when :implied
-        raise "Implied value can't be realized"
-      when :accumulator
-        @a
-      when :immediate
-        operand
-      else
-        read_byte(address)
-      end
-    end
-
-    def stack_address(offset = 0)
-      uint16((stack_pointer + offset) & 0xff, 0x01)
-    end
-
-    def log(instruction, operand, address)
-      return unless @debug
-
-      pc = (@program_counter - 1) - instruction.operand_length
+    def log(opcode)
+      instruction = Instruction.find(opcode)
       puts(
-        "#{@cycles}: " \
-        "PC: #{pc.to_s(16)} - " \
-        "#{@instruction.name.upcase} #{@instruction.addressing_mode} " \
-        "Operand: #{operand.inspect} Address: #{address.inspect}"
+        "#{@cycles}: PC: #{format16(@program_counter)} - " \
+        "#{instruction.name.upcase} #{instruction.addressing_mode}"
       )
     end
-
-    def main_loop
-      if nmi || (irq && !status.interrupt?)
-        handle_interrupts
-      else
-        run_traps
-        @boundary_crossed = false
-        @instruction = read_instruction
-        raise InvalidOpcodeError unless @instruction
-
-        @program_counter = (@program_counter + 1) & 0xffff
-        @cycles += 1
-
-        @operand = operand = read_operand(@instruction)
-        @address = address = read_address(@instruction, operand)
-
-        @program_counter = (@program_counter + @instruction.operand_length) &
-                           0xffff
-
-        log(@instruction, operand, address)
-
-        # Run the instruction; :lazy realizes the value through #resolve
-        send(@instruction.name, address, :lazy)
-
-        @instructions += 1
-        @instruction = nil
-      end
-      Fiber.yield
-    end
-
-    def write_byte(addr, value)
-      if addr == :accumulator
-        @a = value
-      else
-        cycle(write: true) { @memory.poke(addr, value) }
-      end
-    end
   end
 end

data/lib/badline/cycleable.rb

@@ -22,12 +22,15 @@ module Badline
     def cycle(write: false)
       @pending_write = write
       Fiber.yield
+      poll
       result = yield if block_given?
       @cycles += 1
       @pending_write = false
       result
     end
 
+    def poll; end
+
     def main_loop
       Fiber.yield
     end

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