badline 0.12.1 → 0.14.0

data/lib/badline/c128/saved_state.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C128
-    MARKER = "C128"
-
-    # The model, the SID and the mode it resets into of the machine a State
-    # from #snapshot was taken of, the arguments C128.new takes.
-    def self.setup(state)
-      input = Snapshot::StateReader.new(state)
-      input.marker(MARKER)
-      input.check_stamp
-      SavedState.read_setup(input)
-    end
-
-    # A new machine, built as the one a State from #snapshot was taken of,
-    # at that state.
-    def self.restored(state)
-      setup = setup(state)
-      new(model: setup[0], sid_model: setup[1], mode: setup[2]).apply_state(state)
-    end
-
-    # The whole machine's state for a snapshot, as Computer's: the
-    # machine's own latches, FAST and TEST as they last took hold, the bus with its RAM, the MMU, the chips and
-    # the VDC, the CPU, the cartridge, the disk device 8 serves through the
-    # traps and a true 1541. The serial lines go back into the bus from the
-    # restored CIA 2. What the host holds stays out: the keyboard, the
-    # joysticks, CAPS LOCK and 40/80 DISPLAY, the traps and callbacks, and
-    # which chip renders.
-    module SavedState
-      SID_MODELS = %i[mos6581 mos8580].freeze
-      MODES = %i[c64 c128].freeze
-
-      # The model's name, the SID's model and the mode.
-      def self.read_setup(input)
-        name = input.string
-        known = Model::ALL.any? { |model| model.name == name }
-        raise Snapshot::FormatError, "the state names a C128 model badline doesn't know" unless known
-
-        sid_model = SID_MODELS.fetch(input.int)
-        [name, sid_model, MODES.fetch(input.int)]
-      rescue IndexError
-        raise Snapshot::FormatError, "the state names a SID or a mode 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 model or SID.
-      def restore(state)
-        check_setup(C128.setup(state))
-        C128.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.string(@model.name).int(SID_MODELS.index(@sid.model)).int(@c64_built ? 0 : 1)
-        out.int(@cycles).int(@clock_bits).boolean(@nmi_asserted).boolean(@cartridge_nmi).boolean(@restore_pulse)
-        out.boolean(!@pending_keys.nil?)
-        out.ints(@pending_keys) if @pending_keys
-        out.int(@cycles <= init_threshold ? @init_handlers.length : 0)
-        save_cartridge(out)
-        @bus.save_state(out)
-        @cpu.save_state(out)
-        @z80.save_state(out)
-        out.int(@z80_due).int(@chips_ahead).boolean(@cpu_reset_pending)
-        save_trap_drive(out)
-        save_serial_bus(out)
-      end
-
-      def load_state(input)
-        input.marker(MARKER)
-        input.check_stamp
-        check_setup(SavedState.read_setup(input))
-        @cycles = input.int
-        @clock_bits = input.int
-        @nmi_asserted = input.boolean?
-        @cartridge_nmi = input.boolean?
-        @restore_pulse = input.boolean?
-        @pending_keys = nil
-        @pending_keys = input.ints if input.boolean?
-        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
-        load_cartridge(input)
-        @cpu_reset_pending = false
-        @bus.load_state(input)
-        push_serial_lines
-        @cpu.load_state(input)
-        load_z80(input)
-        load_trap_drive(input)
-        load_serial_bus(input)
-        push_fast_serial
-      end
-
-      private
-
-      # The Z80 and which CPU has the bus, which a state from before the
-      # Z80 leaves to the 8502. The bus, restored before it, hands the bus
-      # to its CPU without resetting the 8502.
-      def load_z80(input)
-        @z80_running = @bus.z80?
-        @z80_turn = @z80_running
-        @z80_due = @z80.cycles
-        @chips_ahead = 0
-        @cpu_reset_pending = false
-        return unless input.schema > 6
-
-        @z80.load_state(input)
-        @z80_due = input.int
-        @chips_ahead = input.int
-        @cpu_reset_pending = input.boolean?
-        @z80_turn = @z80_running || @chips_ahead.positive?
-      end
-
-      def check_setup(setup)
-        ours = [@model.name, @sid.model, @c64_built ? :c64 : :c128]
-        return if setup == ours
-
-        raise Snapshot::FormatError, "the state is of a #{setup.join(' with a ')}, not a #{ours.join(' with a ')}"
-      end
-    end
-
-    include SavedState
-  end
-end

data/lib/badline/cartridge/action_replay.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # Action Replay v4.2 to v6: four 8K ROM banks and 8K of RAM. A write to
-    # I/O 1 sets the control register:
-    #
-    #   bit 0    pulls GAME low
-    #   bit 1    releases EXROM
-    #   bit 2    switches the register off until the next freeze or reset
-    #   bits 3-4 ROM bank
-    #   bit 5    RAM instead of ROM at ROML and I/O 2
-    #   bit 6    acknowledges a freeze and lets go of NMI
-    #
-    # I/O 2 shows the last page of the RAM or of the ROM bank. The register
-    # doesn't decode R/W, so a read of I/O 1 writes whatever is on the bus
-    # into it. RAM with only EXROM released ($22) selects the cartridge RAM
-    # and the C64's together at ROML. A freeze switches the cartridge back
-    # on, in Ultimax mode with the RAM at ROML and the first bank at ROMH.
-    class ActionReplay < Cartridge
-      include Freezer
-
-      CONTROL_MODES = %i[rom8k rom16k off ultimax].freeze
-      IO2_PAGE = 0x1f00
-
-      def connect(ram:, open_bus:)
-        super
-        @through.backing = ram
-        @contended.backing = ram
-      end
-
-      def readable_io_pages
-        [0xde, 0xdf]
-      end
-
-      def peek(addr)
-        return open_bus(addr) unless @active
-        return io2_peek(addr) if addr >= 0xdf00
-
-        open_bus(addr).tap { |value| control(value) }
-      end
-
-      def poke(addr, value)
-        return unless @active
-
-        if addr < 0xdf00
-          control(value)
-        elsif @io2_ram
-          @ram_data[IO2_PAGE | (addr & 0xff)] = value
-        end
-      end
-
-      def reset
-        @active = true
-        self.nmi = false
-        control(0)
-      end
-
-      def freeze!
-        @active = true
-        @rom = bank(@rom_banks, 0)
-        select(:ultimax, @isolated, io2_ram: true)
-      end
-
-      private
-
-      def save_mapper(out)
-        super
-        out.int(window_index(@rom, windows)).boolean(@active).boolean(@io2_ram).blob(@ram_data)
-      end
-
-      def load_mapper(input)
-        super
-        @rom = window_at(input.int, windows)
-        @active = input.boolean?
-        @io2_ram = input.boolean?
-        input.blob_into(@ram_data)
-      end
-
-      def windows = [@through, @isolated, @contended, *@rom_banks, EMPTY_BANK]
-
-      def io2_peek(addr)
-        @io2_ram ? @ram_data[IO2_PAGE | (addr & 0xff)] : @rom.peek(addr)
-      end
-
-      def control(value)
-        self.nmi = false if value.anybits?(0x40)
-        @rom = bank(@rom_banks, (value >> 3) & 0x03)
-        configure(value)
-        @active = false if value.anybits?(0x04)
-      end
-
-      def configure(value)
-        return select(:rom8k, @contended, io2_ram: true) if (value & 0x23) == 0x22
-
-        configure_standard(value)
-      end
-
-      def configure_standard(value)
-        mode = CONTROL_MODES[value & 0x03]
-        if value.anybits?(0x20)
-          select(mode, mode == :ultimax ? @isolated : @through, io2_ram: true)
-        else
-          select(mode, @rom, io2_ram: false)
-        end
-      end
-
-      def select(mode, roml, io2_ram:, romh: @rom)
-        self.mode = mode
-        @roml = roml
-        @romh = romh
-        @io2_ram = io2_ram
-        changed!
-      end
-
-      def install_chips(chips)
-        @rom_banks = banks_from(chips).first
-        @ram_data = Array.new(BANK_SIZE, 0)
-        @through = RAMBank.new(@ram_data)
-        @isolated = RAMBank.new(@ram_data)
-        @contended = ContendedRAM.new(@ram_data)
-        reset
-      end
-    end
-  end
-end

data/lib/badline/cartridge/atomic_power.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # Atomic Power, sold as Nordic Power: an Action Replay 5 with one more
-    # configuration. RAM with only EXROM released and bits 2, 6 and 7 clear
-    # ($22) selects 16K mode with the ROM bank at ROML and the RAM at ROMH
-    # and I/O 2. Writes to that RAM don't reach the C64's. The VIC never
-    # sees Ultimax mode.
-    class AtomicPower < ActionReplay
-      def phi1_ultimax?
-        false
-      end
-
-      private
-
-      def configure(value)
-        return select(:rom16k, @rom, romh: @isolated, io2_ram: true) if (value & 0xe7) == 0x22
-
-        configure_standard(value)
-      end
-    end
-  end
-end

data/lib/badline/cartridge/bank.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # One 8K bank of cartridge ROM. The chip decodes only the low address
-    # lines, so the same bank answers at $8000, $A000 or $E000, and a smaller
-    # chip mirrors across the window.
-    class Bank
-      def initialize(data)
-        size = [1 << (data.length - 1).bit_length, 1].max
-        @mask = size - 1
-        @data = (data + ([0xff] * (size - data.length))).freeze
-      end
-
-      def peek(addr)
-        @data[addr & @mask]
-      end
-      alias [] peek
-    end
-
-    # Cartridge RAM mapped into the ROML or ROMH window. Writes land in the
-    # C64's RAM underneath as well, when there is a backing. Banks built on
-    # the same data are views of the same RAM.
-    class RAMBank
-      attr_reader :data
-      attr_writer :backing
-
-      def initialize(data = Array.new(BANK_SIZE, 0))
-        @data = data
-        @backing = nil
-      end
-
-      def peek(addr)
-        @data[addr & 0x1fff]
-      end
-      alias [] peek
-
-      def poke(addr, value)
-        @data[addr & 0x1fff] = value
-        @backing&.poke(addr, value)
-      end
-      alias []= poke
-    end
-
-    # Cartridge RAM the window reads, where the cartridge ignores writes.
-    class RAMReader
-      def initialize(data)
-        @data = data
-      end
-
-      def peek(addr)
-        @data[addr & 0x1fff]
-      end
-      alias [] peek
-    end
-
-    # Cartridge RAM that takes writes while the window reads something else.
-    class WriteOnlyRAM < RAMBank
-      def initialize(data, reader)
-        super(data)
-        @reader = reader
-      end
-
-      def peek(addr)
-        @reader.peek(addr)
-      end
-      alias [] peek
-    end
-
-    # Cartridge RAM selected together with the C64's RAM, both driving the
-    # bus on a read. The result is ORed, as VICE has it.
-    class ContendedRAM < RAMBank
-      def peek(addr)
-        @data[addr & 0x1fff] | @backing.peek(addr)
-      end
-      alias [] peek
-    end
-
-    EMPTY_BANK = Bank.new([0xff])
-  end
-end

data/lib/badline/cartridge/comal80.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # Comal-80: four 16K banks, or eight with the extra ROMs. A write to
-    # I/O 1 selects the bank and the memory configuration. The black board
-    # (subtype 0) takes the bank from bits 0-2 and switches the ROM out with
-    # bit 6; the grey one (subtype 1) takes the bank from bits 0-1 and the
-    # configuration from bits 5-6.
-    class Comal80 < Cartridge
-      GREY_MODES = %i[rom16k ultimax rom8k off].freeze
-
-      def initialize(crt)
-        @grey = crt.subtype == 1
-        super
-      end
-
-      def poke(addr, value)
-        return if addr > 0xdeff
-
-        if @grey
-          select(value & 0x03, GREY_MODES[(value >> 5) & 0x03])
-        else
-          select(value & 0x07, value.anybits?(0x40) ? :off : :rom16k)
-        end
-        changed!
-      end
-
-      def reset
-        select(0, :rom16k)
-        changed!
-      end
-
-      private
-
-      def windows = [*@roml_banks, *@romh_banks, EMPTY_BANK]
-
-      def select(number, mode)
-        @roml = bank(@roml_banks, number)
-        @romh = bank(@romh_banks, number)
-        self.mode = mode
-      end
-
-      def install_chips(chips)
-        @roml_banks, @romh_banks = banks_from(chips)
-        reset
-      end
-    end
-  end
-end

data/lib/badline/cartridge/dinamic.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # Dinamic: up to 16 8K banks. Reading $DE00-$DE0F selects the bank from
-    # the low address bits.
-    class Dinamic < Cartridge
-      def readable_io_pages
-        [0xde]
-      end
-
-      def peek(addr)
-        if addr < 0xde10
-          @roml = bank(@banks, addr & 0x0f)
-          changed!
-        end
-        open_bus(addr)
-      end
-
-      def reset
-        @roml = bank(@banks, 0)
-        changed!
-      end
-
-      private
-
-      def install_chips(chips)
-        @banks = banks_from(chips).first
-        self.mode = :rom8k
-        reset
-      end
-    end
-  end
-end

data/lib/badline/cartridge/easy_flash.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # EasyFlash: two Am29F040B flash chips, one for ROML and one for ROMH,
-    # each 64 banks of 8K, and 256 bytes of RAM at $DF00. $DE00 selects the
-    # bank. $DE02 sets the memory configuration: bit 2 hands the GAME line
-    # to bit 0 (otherwise the boot jumper holds it low), bit 1 pulls EXROM
-    # low and bit 7 drives the LED.
-    #
-    # The flash takes writes in Ultimax mode, at $8000 for ROML and $E000
-    # for ROMH, which is how EAPI programs and erases it. The writes stay in
-    # memory; #save_crt writes the flash out as a new image.
-    #
-    # An image built for EasyFlash carries an EAPI, the flash driver, at $B800
-    # in bank 0 of ROMH. On attach, as in VICE, the bundled Am29F040 EAPI
-    # (roms/eapi) takes its place, so the image drives the flash emulated here.
-    class EasyFlash < Cartridge
-      BANKS = 64
-      EAPI_OFFSET = 0x1800
-
-      def self.eapi
-        @eapi ||= ROM.read("eapi/eapi-am29f040-14").drop(2).freeze
-      end
-
-      attr_reader :low_flash, :high_flash
-
-      def clock=(clock)
-        super
-        [@low_flash, @high_flash].each { |flash| flash.clock = clock }
-      end
-
-      def readable_io_pages
-        [0xdf]
-      end
-
-      def peek(addr)
-        @io_ram[addr & 0xff]
-      end
-
-      def poke(addr, value)
-        if addr >= 0xdf00
-          @io_ram[addr & 0xff] = value
-        elsif addr.nobits?(0x02)
-          @bank = value & 0x3f
-          select_bank
-        else
-          @control = value & 0x87
-          apply_control
-          changed!
-        end
-      end
-
-      def led?
-        @control.anybits?(0x80)
-      end
-
-      # Reset clears both registers, and leaves the flash and the RAM.
-      def reset
-        @bank = 0
-        @control = 0
-        apply_control
-        select_bank
-      end
-
-      # Writes every bank that isn't blank to a CRT image at path.
-      def save_crt(path)
-        chips = (0...BANKS).flat_map do |number|
-          [[@low_flash, 0x8000], [@high_flash, 0xa000]].filter_map do |flash, address|
-            data = flash.data[number * BANK_SIZE, BANK_SIZE]
-            Storage::CRTFile::Chip.new(chip_type: 2, bank: number, address:, data:) if data.any?(0..0xfe)
-          end
-        end
-        image = Storage::CRTFile::Image.new(hardware_type: 32, subtype: 0, exrom: 1, game: 0, name:, chips:)
-        Storage::CRTFile.write(path, image)
-      end
-
-      private
-
-      def select_bank
-        map_bank
-        changed!
-      end
-
-      def map_bank
-        @roml = @low_flash.window(@bank * BANK_SIZE)
-        @romh = @high_flash.window(@bank * BANK_SIZE)
-      end
-
-      def save_mapper(out)
-        out.int(@bank).int(@control).blob(@io_ram)
-        @low_flash.save_state(out)
-        @high_flash.save_state(out)
-      end
-
-      def load_mapper(input)
-        @bank = input.int
-        @control = input.int
-        input.blob_into(@io_ram)
-        @low_flash.load_state(input)
-        @high_flash.load_state(input)
-        map_bank
-      end
-
-      def apply_control
-        game = @control.nobits?(0x04) || @control.anybits?(0x01)
-        exrom = @control.anybits?(0x02)
-        @game = game ? 0 : 1
-        @exrom = exrom ? 0 : 1
-      end
-
-      def install_chips(chips)
-        low = Array.new(BANKS * BANK_SIZE, 0xff)
-        high = Array.new(BANKS * BANK_SIZE, 0xff)
-        chips.each do |chip|
-          offset = (chip.bank & 0x3f) * BANK_SIZE
-          if chip.address >= ROMH_START
-            place(high, offset, chip.data)
-          else
-            place(low, offset, chip.data)
-            place(high, offset, chip.data[BANK_SIZE..]) if chip.data.length > BANK_SIZE
-          end
-        end
-        install_eapi(high)
-        @low_flash = Flash.new(low)
-        @high_flash = Flash.new(high)
-        [@low_flash, @high_flash].each { |flash| flash.on_change { select_bank } }
-        @io_ram = Array.new(0x100, 0xff)
-        reset
-      end
-
-      def install_eapi(high)
-        return unless high[EAPI_OFFSET, 4] == "eapi".bytes
-
-        eapi = EasyFlash.eapi
-        high[EAPI_OFFSET, eapi.length] = eapi
-      end
-
-      def place(flash_data, offset, bytes)
-        bytes = bytes.first(BANK_SIZE)
-        flash_data[offset, bytes.length] = bytes
-      end
-    end
-  end
-end

data/lib/badline/cartridge/epyx_fastload.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Cartridge
-    # Epyx FastLoad: 8K. A capacitor holds the ROM in for 512 cycles after
-    # it was last discharged, by reset, a read through ROML or a read of
-    # I/O 1; once it charges, $8000-$9FFF reads RAM. I/O 2 reads the last
-    # 256 bytes of the ROM.
-    class EpyxFastload < Cartridge
-      DISCHARGED_CYCLES = 512
-
-      class Window
-        def initialize(cartridge, rom)
-          @cartridge = cartridge
-          @rom = rom
-        end
-
-        def peek(addr)
-          @cartridge.rom_visible? ? @rom.peek(addr) : @cartridge.ram_peek(addr)
-        end
-      end
-
-      def clock=(clock)
-        super
-        discharge!
-      end
-
-      def readable_io_pages
-        [0xde, 0xdf]
-      end
-
-      def peek(addr)
-        return @rom.peek(addr) if addr >= 0xdf00
-
-        discharge!
-        open_bus(addr)
-      end
-
-      # True while the capacitor holds the ROM in, discharging it again.
-      def rom_visible?
-        return true unless @clock
-        return false if @clock.call - @discharged_at >= DISCHARGED_CYCLES
-
-        discharge!
-        true
-      end
-
-      def ram_peek(addr)
-        @ram.peek(addr)
-      end
-
-      # Reset discharges the capacitor, so the ROM shows.
-      def reset
-        discharge!
-      end
-
-      private
-
-      def save_mapper(out)
-        out.int(@discharged_at)
-      end
-
-      def load_mapper(input)
-        @discharged_at = input.int
-      end
-
-      def discharge!
-        @discharged_at = @clock ? @clock.call : 0
-      end
-
-      def install_chips(chips)
-        @rom = banks_from(chips).first.compact.first || EMPTY_BANK
-        @roml = Window.new(self, @rom)
-        @discharged_at = 0
-        self.mode = :rom8k
-      end
-    end
-  end
-end