badline 0.12.1 → 0.14.0

data/lib/badline/vic20/saved_state.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Vic20
-    MARKER = "VIC20"
-
-    # The RAM expansion of the machine a State from #snapshot was taken
-    # of, a key of Bus::RAM_CONFIGURATIONS.
-    def self.setup(state)
-      input = Snapshot::StateReader.new(state)
-      input.marker(MARKER)
-      input.check_stamp
-      SavedState.read_ram(input)
-    end
-
-    # A new machine, built as the one a State from #snapshot was taken of,
-    # at that state.
-    def self.restored(state) = new(ram: setup(state)).apply_state(state)
-
-    # The whole machine's state for a snapshot, as Computer's: the
-    # machine's own latches, the bus with its RAM and cartridge ROM, the
-    # VIC with its sound, both VIAs, the CPU, the datasette and its tape,
-    # the disk device 8 serves through the traps, and a true 1541. The
-    # serial lines go back into the bus from the restored VIAs. What the
-    # host holds stays out: the keyboard, the joystick, RESTORE, the traps
-    # and callbacks, whether the display renders, whether the sound
-    # records, and whether the datasette records.
-    module SavedState
-      RAM_CONFIGURATIONS = Bus::RAM_CONFIGURATIONS.keys.freeze
-
-      def self.read_ram(input)
-        RAM_CONFIGURATIONS.fetch(input.int)
-      rescue IndexError
-        raise Snapshot::FormatError, "the state names a VIC-20 RAM expansion badline doesn't know"
-      end
-
-      # How many more on_init handlers the machine a State was taken of had
-      # yet to run than this one has. Nil until the machine is restored.
-      attr_reader :init_handlers_lost
-
-      def snapshot
-        out = Snapshot::StateWriter.new
-        save_state(out)
-        out.state
-      end
-
-      # Takes the machine back to a State from #snapshot, trying it on a new
-      # machine first, so one that fails leaves this machine as it was.
-      # Raises Snapshot::FormatError for a state of another machine or RAM
-      # expansion.
-      def restore(state)
-        check_ram(Vic20.setup(state))
-        Vic20.restored(state)
-        apply_state(state)
-      end
-
-      # Puts a State into the machine without trying it on a new one first.
-      def apply_state(state)
-        input = Snapshot::StateReader.new(state)
-        load_state(input)
-        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
-
-        self
-      end
-
-      def save_state(out)
-        out.marker(MARKER).stamp
-        out.int(RAM_CONFIGURATIONS.index(@ram_configuration))
-        out.int(@cycles).boolean(@nmi_asserted).boolean(!@pending_keys.nil?)
-        out.ints(@pending_keys) if @pending_keys
-        out.int(@cycles <= @init_threshold ? @init_handlers.length : 0)
-        @bus.save_state(out)
-        @vic.save_state(out)
-        @sound.save_state(out)
-        @via1.save_state(out)
-        @via2.save_state(out)
-        @cpu.save_state(out)
-        @datasette.save_state(out)
-        save_trap_drive(out)
-        save_drive1541(out)
-        save_drive1581(out)
-      end
-
-      def load_state(input)
-        input.marker(MARKER)
-        input.check_stamp
-        check_ram(SavedState.read_ram(input))
-        @cycles = input.int
-        @nmi_asserted = input.boolean?
-        @pending_keys = nil
-        @pending_keys = input.ints if input.boolean?
-        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
-        @bus.load_state(input)
-        @vic.load_state(input)
-        @sound.load_state(input)
-        @via1.load_state(input)
-        @via2.load_state(input)
-        @cpu.load_state(input)
-        via_written
-        @datasette.load_state(input)
-        load_trap_drive(input)
-        load_drive1541(input)
-        load_drive1581(input)
-      end
-
-      private
-
-      # A true 1541 on the serial bus, with its device number.
-      def save_drive1541(out)
-        out.boolean(!@drive1541.nil?)
-        return unless @drive1541
-
-        out.int(@drive1541.device)
-        @drive1541.save_state(out)
-      end
-
-      def check_ram(ram)
-        return if ram == @ram_configuration
-
-        raise Snapshot::FormatError, "the state is of a VIC-20 with #{ram} RAM, not #{@ram_configuration}"
-      end
-    end
-  end
-end

data/lib/badline/vic20/sound/output.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Vic20
-    class Sound
-      # The sound's level averaged over each sample of the audio rate, then
-      # through the machine's output stage: a one-pole low-pass at 1,420 Hz
-      # and a one-pole high-pass at 158 Hz, both run at the audio rate.
-      #
-      # The two corners are fitted to xvic's step response: a voice turned
-      # on at volume 15 rises and decays back to the line as those two RC
-      # stages do, within 6 parts in 11,000.
-      class Output
-        LOW_PASS_HZ = 1_420
-        HIGH_PASS_HZ = 158
-
-        # Scales the loudest level, four voices high at volume 15, to the
-        # top of a signed 16-bit sample.
-        SCALE = 32_767.0 / 570
-
-        attr_reader :samples
-
-        # `level` is the sound's level as the recording starts, which the
-        # stage takes as settled.
-        def initialize(clock_hz:, rate:, level:)
-          @clock_hz = clock_hz
-          @rate = rate
-          @remainder = 0
-          @window = next_window
-          @left = @window
-          @sum = 0
-          @low = @drift = level.to_f
-          @low_pass = 1.0 - Math.exp(-2.0 * Math::PI * LOW_PASS_HZ / rate)
-          @high_pass = 1.0 - Math.exp(-2.0 * Math::PI * HIGH_PASS_HZ / rate)
-          @samples = []
-        end
-
-        # Adds `cycles` cycles at `level`, closing every sample they finish.
-        def hold(level, cycles)
-          left = @left
-          while cycles >= left
-            @sum += level * left
-            cycles -= left
-            close
-            left = @left
-          end
-          @sum += level * cycles
-          @left = left - cycles
-        end
-
-        # The samples closed since the last drain.
-        def drain
-          samples = @samples
-          @samples = []
-          samples
-        end
-
-        private
-
-        def close
-          @low += @low_pass * (@sum.fdiv(@window) - @low)
-          @drift += @high_pass * (@low - @drift)
-          sample = ((@low - @drift) * SCALE).round
-          sample = 32_767 if sample > 32_767
-          sample = -32_768 if sample < -32_768
-          @samples << sample
-          @sum = 0
-          @window = next_window
-          @left = @window
-        end
-
-        # Each window is a whole number of cycles, and they add up to the
-        # clock's cycles over a second.
-        def next_window
-          @remainder += @clock_hz
-          cycles = @remainder / @rate
-          @remainder -= cycles * @rate
-          cycles
-        end
-      end
-    end
-  end
-end

data/lib/badline/vic20/sound.rb

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/vic20/sound/output"
-
-module Badline
-  class Vic20
-    # The VIC-I's sound: three square-wave voices, bass, alto and soprano at
-    # $900A-$900C, a noise voice at $900D, and the volume in $900E bits 0-3.
-    #
-    # Each voice has a 7-bit counter, ticked every 16, 8, 4 or 2 cycles from
-    # bass to noise. It counts up from the low 7 bits of its register, and
-    # on the tick it would reach 127 it reloads from the register instead.
-    # So a voice's counter comes round every 128 - ((value + 1) & 127)
-    # ticks, and the register's new value takes hold at the next reload.
-    #
-    # A tone voice's counter shifts an 8-bit shift register at each reload,
-    # bit 7 out and back into bit 0 inverted while bit 7 of the register
-    # enables the voice, and a zero while it doesn't. Bit 0 is the voice's
-    # output: a square wave of 16 shifts while the voice is on, which a
-    # voice turned off shifts out to silence.
-    #
-    # The noise voice's counter shifts a 16-bit LFSR instead, bit 0 in from
-    # the XOR of bits 3, 12, 14 and 15 while the voice is on and a one
-    # while it's off. Each time the LFSR's bit 0 rises, it shifts the noise
-    # voice's own 8-bit shift register, bit 7 back into bit 0, inverted
-    # while the voice is on. Its bit 0 is the voice's output while the voice
-    # is on, and it is silent while it's off.
-    #
-    # The output is the voices that are high, plus a little more, times the
-    # volume, so a volume write steps the output even with every voice off.
-    #
-    # The voices only run while #record collects the output: nothing the
-    # CPU reads depends on them. Until then a write only sets the register.
-    # While recording, the voices catch up to the current cycle whenever a
-    # write lands or the samples are drained, one shift at a time.
-    class Sound
-      VOICES = 4
-      NOISE = 3
-
-      # The cycles between ticks of each voice's counter.
-      DIVIDERS = [16, 8, 4, 2].freeze
-
-      # What a voice that is high adds to the output's level, and what the
-      # output carries with every voice low, before the volume.
-      VOICE_LEVEL = 9
-      IDLE_LEVEL = 2
-
-      attr_reader :volume
-
-      # `clock` answers the machine's cycles, `clock_hz` the rate they run at.
-      def initialize(clock, clock_hz)
-        @clock = clock
-        @clock_hz = clock_hz
-        @output = nil
-        @time = 0
-        @shift_registers = Array.new(VOICES, 0)
-        @next_shifts = Array.new(VOICES, 0)
-        @frequencies = Array.new(VOICES, 0)
-        @enabled = Array.new(VOICES, false)
-        power_on!
-      end
-
-      def model = :mos6561
-
-      # The power-on state: every register clear and the tone voices' shift
-      # registers empty. The noise voice's LFSR and shift register start full
-      # of ones, as a noise voice left off fills them.
-      def power_on!
-        now = @clock.cycles
-        run_to(now)
-        @volume = 0
-        VOICES.times do |voice|
-          @frequencies[voice] = 0
-          @enabled[voice] = false
-          @shift_registers[voice] = 0
-          divider = DIVIDERS[voice]
-          @next_shifts[voice] = ((now / divider) + 128) * divider
-        end
-        @shift_registers[NOISE] = 0xff
-        @lfsr = 0xffff
-        @level = level_now
-      end
-
-      # Starts collecting the output, averaged down to `rate` samples a
-      # second, for #drain_samples. `clock_hz` is the rate the cycles are
-      # taken to run at.
-      def record(rate:, clock_hz: @clock_hz)
-        now = @clock.cycles
-        run_to(now)
-        resume(now)
-        @output = Output.new(clock_hz:, rate:, level: @level)
-      end
-
-      def recording? = !@output.nil?
-
-      # The samples recorded since the last drain.
-      def drain_samples
-        output = @output
-        return [] if output.nil?
-
-        run_to(@clock.cycles)
-        output.drain
-      end
-
-      # A write to $900A-$900E, which takes hold from the next cycle.
-      def write(register, value)
-        run_to(@clock.cycles + 1)
-        if register == 0x0e
-          @volume = value & 0x0f
-        else
-          voice = register - 0x0a
-          @frequencies[voice] = value & 0x7f
-          @enabled[voice] = value >= 0x80
-        end
-        @level = level_now
-      end
-
-      # The registers and the voices as they last ran, for a snapshot.
-      # Recording is the host's, and starts the voices again from the
-      # cycle it starts at.
-      def save_state(out)
-        run_to(@clock.cycles)
-        out.marker("VIC20 SOUND").int(@volume).ints(@frequencies).booleans(@enabled)
-        out.ints(@shift_registers).ints(@next_shifts).int(@lfsr).int(@level).int(@time)
-      end
-
-      def load_state(input)
-        input.marker("VIC20 SOUND")
-        @volume = input.int
-        input.ints_into(@frequencies)
-        input.booleans_into(@enabled)
-        input.ints_into(@shift_registers)
-        input.ints_into(@next_shifts)
-        @lfsr = input.int
-        @level = input.int
-        @time = input.int
-        resume(@clock.cycles) if recording?
-      end
-
-      # A voice's shift register as of the current cycle, while recording.
-      def shift_register(voice)
-        run_to(@clock.cycles)
-        @shift_registers[voice]
-      end
-
-      def lfsr
-        run_to(@clock.cycles)
-        @lfsr
-      end
-
-      private
-
-      # Moves each shift that the cycles since the voices last ran have
-      # passed to its next turn from `now`, keeping its phase.
-      def resume(now)
-        @time = now
-        VOICES.times do |voice|
-          due = @next_shifts[voice]
-          next if due >= now
-
-          interval = period(voice) * DIVIDERS[voice]
-          @next_shifts[voice] = due + ((now - due + interval - 1) / interval * interval)
-        end
-      end
-
-      # Runs the voices up to the start of cycle `target`, the output holding
-      # each level for the cycles it lasts.
-      def run_to(target)
-        time = @time
-        output = @output
-        return if output.nil? || target <= time
-
-        following = next_shift
-        while following < target
-          output.hold(@level, following - time)
-          time = following
-          shift_due(time)
-          @level = level_now
-          following = next_shift
-        end
-        output.hold(@level, target - time)
-        @time = target
-      end
-
-      def next_shift
-        shifts = @next_shifts
-        following = shifts[0]
-        following = shifts[1] if shifts[1] < following
-        following = shifts[2] if shifts[2] < following
-        following = shifts[3] if shifts[3] < following
-        following
-      end
-
-      def shift_due(time)
-        shifts = @next_shifts
-        VOICES.times do |voice|
-          next unless shifts[voice] == time
-
-          voice == NOISE ? step_noise : shift_tone(voice)
-          shifts[voice] = time + (period(voice) * DIVIDERS[voice])
-        end
-      end
-
-      def shift_tone(voice)
-        bits = @shift_registers[voice]
-        fill = @enabled[voice] && bits < 0x80 ? 1 : 0
-        @shift_registers[voice] = ((bits << 1) | fill) & 0xff
-      end
-
-      def step_noise
-        lfsr = @lfsr
-        enabled = @enabled[NOISE]
-        fill = enabled ? ((lfsr >> 3) ^ (lfsr >> 12) ^ (lfsr >> 14) ^ (lfsr >> 15)) & 1 : 1
-        @lfsr = ((lfsr << 1) | fill) & 0xffff
-        return unless fill == 1 && lfsr.even?
-
-        bits = @shift_registers[NOISE]
-        fill = (bits >> 7) ^ (enabled ? 1 : 0)
-        @shift_registers[NOISE] = ((bits << 1) | fill) & 0xff
-      end
-
-      # The ticks between two reloads of a voice's counter.
-      def period(voice) = 128 - ((@frequencies[voice] + 1) & 0x7f)
-
-      def level_now
-        registers = @shift_registers
-        high = (registers[0] & 1) + (registers[1] & 1) + (registers[2] & 1)
-        high += registers[NOISE] & 1 if @enabled[NOISE]
-        ((high * VOICE_LEVEL) + IDLE_LEVEL) * @volume
-      end
-    end
-  end
-end

data/lib/badline/vic20/vic/saved_state.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Vic20
-    class VIC
-      # The VIC's state for a snapshot: the registers and what they set, the
-      # raster, the text window and its fetches, and the picture with what
-      # each line fetched. The sound saves its own.
-      module SavedState
-        def save_state(out)
-          out.marker("VIC20 VIC")
-          out.ints(@registers).int(@rasterline).int(@column).int(@next_event)
-          [@origin_x, @origin_y, @columns, @rows, @char_shift, @screen_base, @char_base].each { |value| out.int(value) }
-          out.boolean(@window_open).boolean(@window_done)
-          [@row_start, @matrix, @char_line, @text_rows].each { |value| out.int(value) }
-          [@fetch_from, @fetch_to, @fetched, @slot, @code].each { |value| out.int(value) }
-          @painter.save_state(out)
-        end
-
-        def load_state(input)
-          input.marker("VIC20 VIC")
-          input.ints_into(@registers)
-          @rasterline = input.int
-          @column = input.int
-          @next_event = input.int
-          load_window(input)
-          @fetch_from = input.int
-          @fetch_to = input.int
-          @fetched = input.int
-          @slot = input.int
-          @code = input.int
-          @painter.load_state(input)
-        end
-
-        private
-
-        def load_window(input)
-          @origin_x = input.int
-          @origin_y = input.int
-          @columns = input.int
-          @rows = input.int
-          @char_shift = input.int
-          @screen_base = input.int
-          @char_base = input.int
-          @window_open = input.boolean?
-          @window_done = input.boolean?
-          @row_start = input.int
-          @matrix = input.int
-          @char_line = input.int
-          @text_rows = input.int
-        end
-      end
-    end
-  end
-end

data/lib/badline/z80/arithmetic.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Z80
-    # The ALU's 8- and 16-bit arithmetic. Bits 5 and 3 of F come from the
-    # result, except for CP, which takes them from the operand, and the
-    # 16-bit operations, which take them from the high byte.
-    module Arithmetic
-      private
-
-      # The eight operations an opcode's bits 5-3 pick: ADD ADC SUB SBC AND
-      # XOR OR CP.
-      def alu(operation, value)
-        case operation
-        when 0 then add_a(value, 0)
-        when 1 then add_a(value, @f & CF)
-        when 2 then @a = subtract(value, 0)
-        when 3 then @a = subtract(value, @f & CF)
-        when 4 then logic(@a & value, HF)
-        when 5 then logic(@a ^ value, 0)
-        when 6 then logic(@a | value, 0)
-        else compare(value)
-        end
-      end
-
-      def add_a(value, carry)
-        result = @a + value + carry
-        assign_flags(SZ53[result & 0xff] | (result >> 8) | ((@a ^ value ^ result) & HF) |
-                  (((@a ^ value ^ 0x80) & (@a ^ result) & 0x80) >> 5))
-        @a = result & 0xff
-      end
-
-      def subtract(value, carry)
-        result = @a - value - carry
-        assign_flags(SZ53[result & 0xff] | NF | ((result >> 8) & CF) | ((@a ^ value ^ result) & HF) |
-                  (((@a ^ value) & (@a ^ result) & 0x80) >> 5))
-        result & 0xff
-      end
-
-      def compare(value)
-        subtract(value, 0)
-        assign_flags((@f & ~XYF) | (value & XYF))
-      end
-
-      def logic(result, half)
-        @a = result
-        assign_flags(SZ53P[result] | half)
-      end
-
-      def increment(value)
-        result = (value + 1) & 0xff
-        assign_flags((@f & CF) | SZ53[result] | (result == 0x80 ? PF : 0) | (result.nobits?(0x0f) ? HF : 0))
-        result
-      end
-
-      def decrement(value)
-        result = (value - 1) & 0xff
-        assign_flags((@f & CF) | NF | SZ53[result] | (result == 0x7f ? PF : 0) | (value.nobits?(0x0f) ? HF : 0))
-        result
-      end
-
-      def add16(left, right)
-        result = left + right
-        @wz = (left + 1) & 0xffff
-        assign_flags((@f & (SF | ZF | PF)) | ((result >> 8) & XYF) | (((left ^ right ^ result) >> 8) & HF) |
-                  (result >> 16))
-        result & 0xffff
-      end
-
-      def adc16(right)
-        left = hl
-        result = left + right + (@f & CF)
-        @wz = (left + 1) & 0xffff
-        self.hl = result & 0xffff
-        assign_flags(word_flags(result) | (((left ^ right ^ result) >> 8) & HF) |
-                  (((left ^ right ^ 0x8000) & (left ^ result) & 0x8000) >> 13))
-      end
-
-      def sbc16(right)
-        left = hl
-        result = left - right - (@f & CF)
-        @wz = (left + 1) & 0xffff
-        self.hl = result & 0xffff
-        assign_flags(word_flags(result) | NF | (((left ^ right ^ result) >> 8) & HF) |
-                  (((left ^ right) & (left ^ result) & 0x8000) >> 13))
-      end
-
-      def word_flags(result)
-        ((result >> 8) & (SF | XYF)) | (result.nobits?(0xffff) ? ZF : 0) | ((result >> 16) & CF)
-      end
-
-      def daa
-        low = @a & 0x0f
-        carry = @f.anybits?(CF) || @a > 0x99 ? CF : 0
-        correction = (carry.zero? ? 0 : 0x60) | (@f.anybits?(HF) || low > 9 ? 0x06 : 0)
-        subtracting = @f.anybits?(NF)
-        half = daa_half(low, subtracting)
-        @a = (subtracting ? @a - correction : @a + correction) & 0xff
-        assign_flags(SZ53P[@a] | (@f & NF) | carry | half)
-      end
-
-      def daa_half(low, subtracting)
-        if subtracting
-          @f.anybits?(HF) && low < 6 ? HF : 0
-        else
-          low > 9 ? HF : 0
-        end
-      end
-
-      def neg
-        value = @a
-        @a = 0
-        @a = subtract(value, 0)
-      end
-    end
-  end
-end

data/lib/badline/z80/bit_page.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Z80
-    # The CB page: rotates and shifts (quarter 0), BIT (1), RES (2) and SET
-    # (3) of the bit the row names, on the column's register or (HL). After
-    # DD or FD the operand is always (IX+d): the displacement comes before
-    # the opcode, and an opcode that names a register other than (HL) also
-    # copies the result into it.
-    module BitPage
-      private
-
-      def execute_bits(opcode)
-        operation = opcode >> 6
-        number = (opcode >> 3) & 7
-        index = opcode & 7
-        return bits_in_memory(operation, number, hl) if index == 6
-
-        value = register(index)
-        if operation == 1
-          bit(number, value, value)
-        else
-          set_register(index, bit_result(operation, number, value))
-        end
-      end
-
-      def execute_index_bits
-        displaced
-        opcode = fetch_byte
-        @cycles += 2
-        result = bits_in_memory(opcode >> 6, (opcode >> 3) & 7, @wz)
-        index = opcode & 7
-        set_plain_register(index, result) unless index == 6 || (opcode >> 6) == 1
-      end
-
-      def bits_in_memory(operation, number, address)
-        value = read_byte(address)
-        @cycles += 1
-        return bit(number, value, @wz >> 8) if operation == 1
-
-        result = bit_result(operation, number, value)
-        write_byte(address, result)
-        result
-      end
-
-      def bit_result(operation, number, value)
-        case operation
-        when 0 then shift(number, value)
-        when 2 then value & ~(1 << number) & 0xff
-        else value | (1 << number)
-        end
-      end
-    end
-  end
-end