badline 0.13.0 → 0.14.0

data/lib/badline/chips/vic/sprite/saved_state.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class VIC
-      class Sprite
-        # The sprite's save_state and load_state.
-        module SavedState
-          # The shift register, MC, MCBASE, the expansion flip-flop and whether
-          # the sprite shows, for a VICE snapshot.
-          attr_reader :sr, :mc, :mcbase, :exp_ff, :display_on
-
-          # Sets MC, MCBASE, the expansion flip-flop, whether the sprite's DMA
-          # runs and whether it shows, as a VICE snapshot gives them.
-          def restore_counters(counter, base, expanded, dma, shows)
-            @mc = counter
-            @mcbase = base
-            @exp_ff = expanded
-            @dma = dma
-            @display_on = shows
-          end
-
-          def save_state(out)
-            out.boolean(@dma).boolean(@display_on).int(@mcbase).int(@mc).boolean(@exp_ff).optional_int(@crunched_mc)
-            out.int(@bits).boolean(@row_ready).optional_int(@prev_bits).boolean(@first_byte_lost).boolean(@blind)
-            out.int(@show_from).optional_int(@stop_x)
-            out.ints(@codes).int(@leftmost).int(@span).ints(@reload_codes).int(@reload_leftmost).int(@reload_span)
-            out.int(@sr).int(@latch).boolean(@mc_flop).boolean(@xe_flop)
-          end
-
-          def load_state(input)
-            load_counters(input)
-            @show_from = input.int
-            @stop_x = input.optional_int
-            input.ints_into(@codes)
-            @leftmost = input.int
-            @span = input.int
-            input.ints_into(@reload_codes)
-            @reload_leftmost = input.int
-            @reload_span = input.int
-            @sr = input.int
-            @latch = input.int
-            @mc_flop = input.boolean?
-            @xe_flop = input.boolean?
-          end
-
-          private
-
-          def load_counters(input)
-            @dma = input.boolean?
-            @display_on = input.boolean?
-            @mcbase = input.int
-            @mc = input.int
-            @exp_ff = input.boolean?
-            @crunched_mc = input.optional_int
-            @bits = input.int
-            @row_ready = input.boolean?
-            @prev_bits = input.optional_int
-            @first_byte_lost = input.boolean?
-            @blind = input.boolean?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/chips/vic/sprites/saved_state.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class VIC
-      class Sprites
-        # The sprites' save_state and load_state.
-        module SavedState
-          # Whether any sprite's DMA runs, set after Sprite#restore_counters.
-          def update_any_dma
-            @any_dma = @sprites.any?(&:displaying?)
-          end
-
-          # The sprites, their shared bus, the collisions and the register log,
-          # then the line's coverage and the pixels carried into the next line,
-          # each as x, colour and priority.
-          def save_state(out)
-            out.boolean(@any_dma).boolean(@stopped_dma).boolean(@carried).int(@lo).int(@hi).int(@sequenced)
-            out.blob(@win_color).booleans(@win_priority).ints(@palette)
-            [@carry, @carry_next].each { |carry| carry.each { |pixels| save_carry(pixels, out) } }
-            @sprites.each { |sprite| sprite.save_state(out) }
-            @bus.save_state(out)
-            @collisions.save_state(out)
-            @log.save_state(out)
-          end
-
-          def load_state(input)
-            @any_dma = input.boolean?
-            @stopped_dma = input.boolean?
-            @carried = input.boolean?
-            @lo = input.int
-            @hi = input.int
-            @sequenced = input.int
-            input.blob_into(@win_color)
-            input.booleans_into(@win_priority)
-            input.ints_into(@palette)
-            [@carry, @carry_next].each { |carry| carry.each { |pixels| load_carry(pixels, input) } }
-            @sprites.each { |sprite| sprite.load_state(input) }
-            @bus.load_state(input)
-            @collisions.load_state(input)
-            @log.load_state(input)
-          end
-
-          private
-
-          def save_carry(pixels, out)
-            out.int(pixels.length / 3)
-            pixels.each_slice(3) { |x, color, priority| out.int(x).int(color).boolean(priority) }
-          end
-
-          def load_carry(pixels, input)
-            pixels.clear
-            input.int.times { pixels.push(input.int, input.int, input.boolean?) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/chips/vic_i/painter/saved_state.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class VICI
-      class Painter
-        # The painter's state for a snapshot.
-        module SavedState
-          # The colours, the line being painted and how far, what each line
-          # fetched, and the display, for a snapshot. Whether it renders is
-          # the host's, and a restored display is all changed.
-          def save_state(out)
-            out.int(@border).int(@background).int(@aux).boolean(@reverse)
-            out.int(@row).int(@painted).boolean(@written)
-            out.blob(@display).blob(@patterns).blob(@colors)
-            out.ints(@counts).ints(@starts).booleans(@stale).ints(@memo_keys)
-          end
-
-          def load_state(input)
-            @border = input.int
-            @background = input.int
-            @aux = input.int
-            @reverse = input.boolean?
-            @row = input.int
-            @painted = input.int
-            @written = input.boolean?
-            input.blob_into(@display)
-            input.blob_into(@patterns)
-            input.blob_into(@colors)
-            input.ints_into(@counts)
-            input.ints_into(@starts)
-            input.booleans_into(@stale)
-            input.ints_into(@memo_keys)
-            @dirty_lines.fill(true)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/chips/vic_i/saved_state.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class VICI
-      # 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/chips/z80/saved_state.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class Z80
-      # The registers, the T-state count and the interrupt latches for a
-      # snapshot, taken between instructions.
-      module SavedState
-        def save_state(out)
-          out.marker("Z80")
-          out.int(@a).int(@f).int(@b).int(@c).int(@d).int(@e).int(@h).int(@l)
-          out.int(@af_alt).int(@bc_alt).int(@de_alt).int(@hl_alt)
-          out.int(@i).int(@r).int(@pc).int(@sp).int(@ix).int(@iy).int(@wz).int(@q).int(@last_q).int(@im)
-          out.int(@cycles)
-          out.boolean(@iff1).boolean(@iff2).boolean(@halted).boolean(@after_ei).boolean(@after_ld_a_ir)
-          out.boolean(@int).boolean(@nmi).boolean(@nmi_pending)
-        end
-
-        def load_state(input)
-          input.marker("Z80")
-          load_main_registers(input)
-          @af_alt = input.int
-          @bc_alt = input.int
-          @de_alt = input.int
-          @hl_alt = input.int
-          load_special_registers(input)
-          @cycles = input.int
-          load_latches(input)
-          @prefix = 0
-        end
-
-        private
-
-        def load_main_registers(input)
-          @a = input.int
-          @f = input.int
-          @b = input.int
-          @c = input.int
-          @d = input.int
-          @e = input.int
-          @h = input.int
-          @l = input.int
-        end
-
-        def load_special_registers(input)
-          @i = input.int
-          @r = input.int
-          @pc = input.int
-          @sp = input.int
-          @ix = input.int
-          @iy = input.int
-          @wz = input.int
-          @q = input.int
-          @last_q = input.int
-          @im = input.int
-        end
-
-        def load_latches(input)
-          @iff1 = input.boolean?
-          @iff2 = input.boolean?
-          @halted = input.boolean?
-          @after_ei = input.boolean?
-          @after_ld_a_ir = input.boolean?
-          @int = input.boolean?
-          @nmi = input.boolean?
-          @nmi_pending = input.boolean?
-        end
-      end
-    end
-  end
-end

data/lib/badline/chrout_trap.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  # Observe-only PC trap on the KERNAL CHROUT routine ($FFD2). Records each
-  # character written while the layout finds the KERNAL mapped in, then lets execution fall
-  # through to the ROM, so the screen output is unaffected. Used for headless
-  # capture of program output.
-  class ChroutTrap
-    ADDRESS = 0xffd2
-
-    attr_reader :output
-
-    # The KERNAL layout whose mapping the trap checks.
-    attr_writer :layout
-
-    def initialize(cpu:, bus:, layout:)
-      @cpu = cpu
-      @bus = bus
-      @layout = layout
-      @output = +""
-    end
-
-    def call
-      @output << ascii(@cpu.a) if @layout.kernal_mapped?(@bus)
-    end
-
-    def inspect
-      "#<#{self.class.name} output=#{@output.inspect}>"
-    end
-
-    private
-
-    def ascii(byte)
-      case byte
-      when 0x0d then "\n"
-      when 0x41..0x5a then (byte + 0x20).chr
-      when 0xc1..0xda then (byte - 0x80).chr
-      when 0x20..0x7e then byte.chr
-      else ""
-      end
-    end
-  end
-end

data/lib/badline/debug_register.rb

@@ -1,28 +0,0 @@
-# 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/drives/datasette/saved_state.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Datasette
-      # The datasette's state for a snapshot.
-      module SavedState
-        # The keys, the motor, the countdown to the next pulse and the tape:
-        # its path, its bytes and how far it has played.
-        def save_state(out)
-          out.marker("DATASETTE")
-          out.boolean(@playing).boolean(@motor).int(@countdown).boolean(!@tape.nil?)
-          return unless @tape
-
-          out.string(@tape.path).blob(@tape.bytes).int(@tape.position)
-        end
-
-        # The tape goes back in from the bytes the state holds, without its
-        # host file, unless the tape in is the same one. The sense and flag
-        # handlers don't fire.
-        def load_state(input)
-          input.marker("DATASETTE")
-          @playing = input.boolean?
-          @motor = input.boolean?
-          @countdown = input.int
-          return @tape = nil unless input.boolean?
-
-          path = input.string
-          bytes = input.blob
-          position = input.int
-          @tape = Storage::TAP.new(path, bytes:) unless @tape&.path&.b == path && @tape.bytes == bytes
-          @tape.position = position
-        end
-      end
-    end
-  end
-end

data/lib/badline/drives/model1541/disk/saved_state.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/media/extensions"
-
-module Badline
-  module Drives
-    class Model1541
-      class Disk
-        # Saving and restoring a Disk for a snapshot: the image by its path,
-        # and every half track as the head sees it, with those written since
-        # the last flush. The image itself is read again from its host file,
-        # where there still is one.
-        module SavedState
-          # The image's path, expanded, and whether it was opened read-only,
-          # for a disk from Disk.open. Nil for a disk made another way.
-          attr_reader :path, :read_only
-
-          # Whether the image is a .g64 or .g71, by its name.
-          def self.g64?(path) = Media::Extensions.kind(path) == :gcr
-
-          # A disk for the image at the path (Disk.image_for), its tracks left
-          # for the state.
-          def self.reopen(path, read_only) = Disk.new(Disk.image_for(path, read_only)).opened(path, read_only)
-
-          # The disk a state from save_state describes: +current+ when it was
-          # opened from the same image the same way, and otherwise a disk for
-          # the image at the path the state names. Where no file is at that
-          # path, the disk has no image and is write-protected, and a
-          # detached reader always gets one without an image. Either way its
-          # tracks come from the state.
-          def self.load(input, current)
-            path = input.optional_string
-            read_only = input.boolean?
-            disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
-            disk ||= fresh(path, read_only, input.detached?)
-            disk.load_tracks(input)
-            disk
-          end
-
-          def self.fresh(path, read_only, detached)
-            return Disk.new if path.nil? || detached
-            return Disk.new.opened(path, true) unless File.file?(path)
-
-            reopen(path, read_only)
-          end
-
-          # Notes the image's path and how it was opened.
-          def opened(path, read_only)
-            @path = File.expand_path(path)
-            @read_only = read_only
-            self
-          end
-
-          def save_state(out)
-            out.optional_string(@path).boolean(@read_only)
-            @tracks.each do |track|
-              out.boolean(!track.nil?)
-              save_track(track, out) if track
-            end
-            out.ints(@written.keys)
-          end
-
-          def load_tracks(input)
-            @tracks.each_index do |half_track|
-              @tracks[half_track] = input.boolean? ? load_track(input) : nil
-            end
-            @written.clear
-            input.ints.each { |half_track| @written[half_track] = true }
-          end
-
-          private
-
-          def save_track(track, out)
-            out.int(track.zone).boolean(!track.speeds.nil?)
-            out.ints(track.speeds) if track.speeds
-            out.blob(track.bytes)
-          end
-
-          def load_track(input)
-            zone = input.int
-            speeds = input.boolean? ? input.ints : nil
-            Track.new(input.blob, zone, speeds)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/drives/model1541/mechanism/saved_state.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Model1541
-      class Mechanism
-        # Saving and restoring the Mechanism for a snapshot.
-        module SavedState
-          # The disk (Disk#save_state) and everything the head, the motor, the
-          # stepper and the read and write electronics hold, down to the cell
-          # under the head and the read clock's phase.
-          def save_state(out)
-            out.boolean(!@disk.nil?)
-            @disk&.save_state(out)
-            [@half_track, @slip, @side_base, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits,
-             @write_shift, @index, @mask, @cell_end, @width, @next].each { |value| out.int(value) }
-            [@motor, @led, @sync, @byte_ready, @byte_latched, @writing, @write_gate, @protected,
-             @track_written].each { |flag| out.boolean(flag) }
-            out.optional_int(@write_index)
-          end
-
-          # Puts the state back, reusing the disk in when it's the one the state
-          # names (Disk::SavedState.load). A disk taken out is flushed, as insert
-          # does.
-          def load_state(input)
-            disk = input.boolean? ? Disk::SavedState.load(input, @disk) : nil
-            flush unless disk.equal?(@disk)
-            @disk = disk
-            load_head(input)
-            load_flags(input)
-            @write_index = input.optional_int
-            head_on_track
-          end
-
-          private
-
-          def load_head(input)
-            @half_track = input.int
-            @slip = input.int
-            @side_base = input.int
-            @zone = input.int
-            @clock = input.int
-            @time = input.int
-            @clock_at = input.int
-            @clocks = input.int
-            @shift = input.int
-            @ones = input.int
-            @bits = input.int
-            @write_shift = input.int
-            @index = input.int
-            @mask = input.int
-            @cell_end = input.int
-            @width = input.int
-            @next = input.int
-          end
-
-          def load_flags(input)
-            @motor = input.boolean?
-            @led = input.boolean?
-            @sync = input.boolean?
-            @byte_ready = input.boolean?
-            @byte_latched = input.boolean?
-            @writing = input.boolean?
-            @write_gate = input.boolean?
-            @protected = input.boolean?
-            @track_written = input.boolean?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/drives/model1541/saved_state.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Model1541
-      # The drive's state for a snapshot.
-      module SavedState
-        # The drive's whole state: its clock phase, the CPU, RAM, both VIAs,
-        # the serial port's latch of the C64's lines and the mechanism with its
-        # disk. The drive settles first, so it is awake and not recording a
-        # pass, and a restored drive starts the same way, its orbits forgotten
-        # from the state it takes: Idle's and Orbit's bookkeeping
-        # isn't stored. The device number, the host's clock rate and whether
-        # the drive may sleep are the machine's wiring.
-        def save_state(out)
-          settle!
-          out.marker("DRIVE1541")
-          out.int(@phase).int(@cycles).boolean(@mechanism.so_pending)
-          @serial_port.save_state(out)
-          @via1.save_state(out)
-          @via2.save_state(out)
-          @bus.save_state(out)
-          @cpu.save_state(out)
-          @mechanism.save_state(out)
-        end
-
-        def load_state(input)
-          settle!
-          input.marker("DRIVE1541")
-          @phase = input.int
-          @cycles = input.int
-          @mechanism.so_pending = input.boolean?
-          @serial_port.load_state(input)
-          @via1.load_state(input)
-          @via2.load_state(input)
-          @bus.load_state(input)
-          @cpu.load_state(input)
-          @mechanism.load_state(input)
-          forget_orbits
-        end
-      end
-    end
-  end
-end

data/lib/badline/drives/model1571/saved_state.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Model1571
-      # The drive's state for a snapshot.
-      module SavedState
-        # The drive's whole state, as the 1541's (Drives::Model1541#save_state), with
-        # the CIA and the WD1770's registers. The clock rate, the side and the
-        # fast serial direction follow from VIA 1's port A.
-        def save_state(out)
-          settle!
-          out.marker("DRIVE1571")
-          out.int(@phase).int(@cycles).boolean(@mechanism.so_pending)
-          @serial_port.save_state(out)
-          @via1.save_state(out)
-          @via2.save_state(out)
-          @cia.save_state(out)
-          @fdc.save_state(out)
-          @bus.save_state(out)
-          @cpu.save_state(out)
-          @mechanism.save_state(out)
-        end
-
-        def load_state(input)
-          settle!
-          input.marker("DRIVE1571")
-          @phase = input.int
-          @cycles = input.int
-          @mechanism.so_pending = input.boolean?
-          @serial_port.load_state(input)
-          @via1.load_state(input)
-          @via2.load_state(input)
-          @cia.load_state(input)
-          @fdc.load_state(input)
-          @bus.load_state(input)
-          @cpu.load_state(input)
-          @mechanism.load_state(input)
-          @fast_serial_out = @via1.port_a_output.anybits?(FAST_SERIAL_OUT)
-          port_a_written(@via1.port_a_output)
-          push_fast_output(@fast_serial_out ? fast_pins : 0)
-          forget_orbits
-        end
-      end
-    end
-  end
-end