badline 0.12.0 → 0.13.0

data/lib/badline/c64/cartridge/westermann.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # 16K. Reading I/O 2 switches ROMH out (8K mode) until reset.
+      class Westermann < Cartridge
+        def readable_io_pages
+          [0xdf]
+        end
+
+        def peek(addr)
+          select_mode(:rom8k) if addr >= 0xdf00
+          open_bus(addr)
+        end
+
+        def reset
+          select_mode(:rom16k)
+        end
+
+        private
+
+        def install_chips(chips)
+          roml, romh = banks_from(chips)
+          @roml = bank(roml, 0)
+          @romh = bank(romh, 0)
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge/zaxxon.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Zaxxon / Super Zaxxon: 16K mode with a 4K ROML mirrored across
+      # $8000-$9FFF and two 8K ROMH banks. A read through ROML selects the
+      # ROMH bank: $8000-$8FFF the first, $9000-$9FFF the second.
+      class Zaxxon < Cartridge
+        class Low
+          def initialize(rom, high)
+            @rom = rom
+            @high = high
+          end
+
+          def peek(addr)
+            @high.select(addr[12])
+            @rom.peek(addr)
+          end
+        end
+
+        class High
+          def initialize(banks)
+            @banks = banks
+            select(0)
+          end
+
+          def select(number)
+            @bank = @banks[number] || EMPTY_BANK
+          end
+
+          def peek(addr)
+            @bank.peek(addr)
+          end
+
+          def save_state(out)
+            out.int([*@banks, EMPTY_BANK].index { |bank| bank.equal?(@bank) })
+          end
+
+          def load_state(input)
+            @bank = [*@banks, EMPTY_BANK].fetch(input.int)
+          end
+        end
+
+        def reset
+          @romh.select(0)
+        end
+
+        private
+
+        def save_mapper(out)
+          @romh.save_state(out)
+        end
+
+        def load_mapper(input)
+          @romh.load_state(input)
+        end
+
+        def install_chips(chips)
+          roml, romh = banks_from(chips)
+          @romh = High.new(romh)
+          @roml = Low.new(roml.first || EMPTY_BANK, @romh)
+          self.mode = :rom16k
+        end
+      end
+    end
+  end
+end

data/lib/badline/c64/cartridge.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "badline/c64/cartridge/bank"
+require "badline/c64/cartridge/flash"
+require "badline/c64/cartridge/standard"
+require "badline/c64/cartridge/simons_basic"
+require "badline/c64/cartridge/ocean"
+require "badline/c64/cartridge/fun_play"
+require "badline/c64/cartridge/super_games"
+require "badline/c64/cartridge/epyx_fastload"
+require "badline/c64/cartridge/westermann"
+require "badline/c64/cartridge/rex_utility"
+require "badline/c64/cartridge/game_system"
+require "badline/c64/cartridge/dinamic"
+require "badline/c64/cartridge/zaxxon"
+require "badline/c64/cartridge/magic_desk"
+require "badline/c64/cartridge/comal80"
+require "badline/c64/cartridge/easy_flash"
+require "badline/c64/cartridge/mach5"
+require "badline/c64/cartridge/pagefox"
+require "badline/c64/cartridge/rgcd"
+require "badline/c64/cartridge/g_mod2"
+require "badline/c64/cartridge/freezer"
+require "badline/c64/cartridge/action_replay"
+require "badline/c64/cartridge/atomic_power"
+require "badline/c64/cartridge/final_cartridge3"
+require "badline/c64/cartridge/retro_replay"
+require "badline/c64/cartridge/kcs_power"
+require "badline/c64/cartridge/geo_ram"
+require "badline/c64/cartridge/saved_state"
+
+module Badline
+  class C64
+    class Cartridge
+      include SavedState
+
+      class UnsupportedTypeError < StandardError; end
+
+      ROMH_START = 0xa000
+      BANK_SIZE = 0x2000
+
+      HARDWARE_TYPES = {
+        0 => Standard, 1 => ActionReplay, 2 => KCSPower, 3 => FinalCartridge3,
+        4 => SimonsBasic, 5 => Ocean, 7 => FunPlay, 8 => SuperGames,
+        9 => AtomicPower, 10 => EpyxFastload, 11 => Westermann,
+        12 => RexUtility, 15 => GameSystem, 17 => Dinamic, 18 => Zaxxon,
+        19 => MagicDesk, 21 => Comal80, 32 => EasyFlash, 36 => RetroReplay,
+        51 => Mach5, 53 => Pagefox, 57 => RGCD, 60 => GMod2
+      }.freeze
+
+      # The EXROM and GAME line levels of each memory configuration. The lines
+      # are active low.
+      MODES = {
+        rom8k: [0, 1].freeze, rom16k: [0, 0].freeze,
+        ultimax: [1, 0].freeze, off: [1, 1].freeze
+      }.freeze
+
+      attr_reader :name, :exrom, :game, :roml, :romh
+
+      # A callable returning the current cycle, for mappers with timed state.
+      attr_writer :clock
+
+      class << self
+        # Options set the cartridge's jumpers, for the mappers that have them.
+        def from_file(path, **)
+          from_crt(Storage::CRTFile.new(path), **)
+        end
+
+        def from_crt(crt, **)
+          mapper_for(crt).new(crt, **)
+        end
+
+        # A cartridge built afresh from what save_setup wrote, before
+        # load_state puts its state in.
+        def from_setup(input)
+          return GeoRAM.new(size: input.int) if input.int == GEO_RAM_SETUP
+
+          crt = Storage::CRTFile.new(bytes: input.string)
+          mapper_for(crt).from_jumpers(crt, input)
+        end
+
+        # A cartridge from its image and what save_jumpers wrote: whether
+        # there are jumpers, then their settings on a mapper that has them.
+        def from_jumpers(crt, input)
+          input.boolean?
+          new(crt)
+        end
+
+        def mapper_for(crt)
+          HARDWARE_TYPES.fetch(crt.hardware_type) do
+            raise UnsupportedTypeError,
+                  "Unsupported cartridge hardware type #{crt.hardware_type}"
+          end
+        end
+      end
+
+      # What save_setup writes first: a cartridge from a CRT image, or a
+      # GEO-RAM.
+      CRT_SETUP = 0
+      GEO_RAM_SETUP = 1
+
+      # Keeps the image it was built from, so a snapshot's machine can build
+      # the same cartridge before the snapshot's state goes into it.
+      def initialize(crt)
+        @crt = crt
+        @name = crt.name
+        @exrom = crt.exrom
+        @game = crt.game
+        @roml = @romh = nil
+        @banks = nil
+        @on_change = nil
+        @on_nmi_change = nil
+        @nmi = false
+        @open_bus = nil
+        @clock = nil
+        install_chips(crt.chips)
+      end
+
+      def on_change(&block)
+        @on_change = block
+      end
+
+      # Called with the level of the cartridge's pull on the NMI line when it
+      # changes. The line is wired-OR with CIA 2's.
+      def on_nmi_change(&block)
+        @on_nmi_change = block
+      end
+
+      def nmi?
+        @nmi
+      end
+
+      # The address bus hands over the C64's RAM, for mappers that write
+      # through to it, and the open bus, for I/O reads the cartridge doesn't
+      # drive.
+      def connect(ram:, open_bus:)
+        @ram = ram
+        @open_bus = open_bus
+      end
+
+      def ultimax?
+        @game.zero? && @exrom == 1
+      end
+
+      # Whether the first half of the cycle, where the VIC does most of its
+      # fetching, sees Ultimax mode. Some cartridges drive GAME and EXROM
+      # differently in the two halves; #ultimax? is the second, the CPU's.
+      def phi1_ultimax?
+        ultimax?
+      end
+
+      # The I/O pages ($de, $df) whose reads the mapper drives. Reads of the
+      # others are open bus.
+      def readable_io_pages
+        []
+      end
+
+      def poke(_addr, _value); end
+
+      # A window taking writes to $E000-$FFFF while reads there see the C64's
+      # memory, for a cartridge that asserts Ultimax on write cycles only.
+      def romh_writes; end
+
+      # A window at $A000-$BFFF in Ultimax mode, where the C64 maps nothing.
+      def ultimax_a000; end
+
+      # The RES line on the expansion port.
+      def reset; end
+
+      # Whether the cartridge has a freeze button.
+      def freezer? = false
+
+      # The freeze button, which cartridges without one ignore.
+      def press_button; end
+
+      def release_button; end
+
+      private
+
+      # The banks and views ROML and ROMH can point at, which a snapshot
+      # names them by: the mapper's banks, or nothing for a mapper whose
+      # windows stay where install_chips put them.
+      def windows
+        [*@banks, EMPTY_BANK] if @banks
+      end
+
+      def window_index(window, windows)
+        return -1 if window.nil?
+
+        windows.index { |candidate| candidate.equal?(window) } ||
+          raise(ArgumentError, "#{self.class.name}: a window that isn't among its banks")
+      end
+
+      def window_at(index, windows) = index.negative? ? nil : windows.fetch(index)
+
+      def nmi=(level)
+        return if @nmi == level
+
+        @nmi = level
+        @on_nmi_change&.call(level)
+      end
+
+      def changed!
+        @on_change&.call
+      end
+
+      def mode=(mode)
+        @exrom, @game = MODES.fetch(mode)
+      end
+
+      # Sets the lines and tells the machine to map the cartridge again.
+      def select_mode(mode)
+        self.mode = mode
+        changed!
+      end
+
+      def open_bus(addr)
+        @open_bus ? @open_bus.peek(addr) : 0xff
+      end
+
+      def install_chips(_chips)
+        raise NotImplementedError
+      end
+
+      def rom_bank(data)
+        Bank.new(data)
+      end
+
+      # A bank the image leaves out reads as erased ROM.
+      def bank(banks, number)
+        banks[number] || EMPTY_BANK
+      end
+
+      # The bank register bits a ROM decodes. The ROM holds the highest bank
+      # in the image, and has address lines for the power of two that covers
+      # it; the register bits above those lines are ignored.
+      def bank_mask(banks)
+        (1 << (banks.length - 1).bit_length) - 1
+      end
+
+      # Sorts the CHIP packets into ROML and ROMH banks by load address. A 16K
+      # chip at $8000 spans both.
+      def banks_from(chips)
+        roml = []
+        romh = []
+        chips.each do |chip|
+          if chip.address >= ROMH_START
+            romh[chip.bank] = rom_bank(chip.data)
+          else
+            roml[chip.bank] = rom_bank(chip.data[0, BANK_SIZE])
+            romh[chip.bank] = rom_bank(chip.data[BANK_SIZE, BANK_SIZE]) if chip.data.length > BANK_SIZE
+          end
+        end
+        [roml, romh]
+      end
+    end
+  end
+end

data/lib/badline/c64/color_memory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    # Colour RAM is four bits wide. A CPU read takes the upper nibble off the
+    # open data bus, which still holds the byte the VIC fetched in phi1.
+    class ColorMemory < Memory
+      def initialize(vic, start: 0xd800, length: 2**10)
+        super(start:, length:)
+        @vic = vic
+      end
+
+      def peek(addr)
+        (@vic.phi1_data & 0xf0) | @storage[offset_of(addr)]
+      end
+
+      def poke(addr, value)
+        super(addr, value & 0x0f)
+      end
+
+      # The four bits the cell stores, as the VIC's c-access sees them.
+      def nibble(addr)
+        @storage[offset_of(addr)]
+      end
+    end
+  end
+end

data/lib/badline/c64/common.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    # What the C128 does as the C64 does: the NMI line, a PRG put into RAM
+    # and the region's timing. C64 and C128 each include it.
+    module Common
+      # The clock, the raster and the crop of the machine's region, a pixel
+      # to a window pixel.
+      def timing
+        region = address_bus.region
+        Timing.new(clock_hz: region.clock_hz, cycles_per_line: region.cycles_per_line,
+                   lines_per_frame: region.lines_per_frame, crop: region.crop, pixel_width: 1)
+      end
+
+      def load_prg(data)
+        uint16(data[0], data[1]).tap do |load_addr|
+          ram.write(load_addr, data[2..])
+        end
+      end
+
+      private
+
+      # The NMI line is wired-OR between CIA 2, the cartridge and the RESTORE
+      # key, and the CPU takes an interrupt on its falling edge.
+      def drive_nmi
+        nmi = @cia2.interrupted? || @cartridge_nmi || @restore_pulse
+        @restore_pulse = false
+        @cpu.nmi = true if nmi && !@nmi_asserted
+        @nmi_asserted = nmi
+      end
+    end
+  end
+end

data/lib/badline/c64/kernal_traps.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    # The disk device 8 serves through the LOAD, SAVE and serial traps, and
+    # CHROUT capture, on the KERNAL the machine runs. C64, Vic20 and
+    # C128 each include it and answer two private methods: #trap_layout,
+    # the KernalTrap::Layout of that KERNAL, and #trap_bus, the bus the
+    # traps read and write through.
+    module KernalTraps
+      # Puts the storage in device 8. Mounting again swaps the disk at any
+      # point while the machine runs: the drive keeps its RAM, which only a
+      # drive reset clears, and its status. The traps go on the KERNAL the
+      # machine runs (#trap_layout).
+      def mount(storage)
+        return @dos.insert(storage) if @dos
+
+        @dos = KernalTrap::DOS.new(storage)
+        install_kernal_traps(trap_layout)
+      end
+
+      # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
+      # serial traps, so the KERNAL's routines go out over the serial bus.
+      # Mounting again starts a new drive, with its RAM cleared.
+      def unmount
+        return unless @dos
+
+        remove_kernal_traps
+        @dos = nil
+      end
+
+      # Whether device 8 serves a disk or directory through the traps.
+      def mounted? = !@dos.nil?
+
+      # The path of the disk or directory device 8 serves through the
+      # traps, or an empty one.
+      def mounted_path = @dos.nil? ? "" : @dos.path
+
+      # Records what the KERNAL prints through CHROUT (ChroutTrap).
+      def capture_output
+        @capture_output ||= ChroutTrap.new(cpu:, bus: trap_bus, layout: trap_layout).tap do |trap|
+          cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
+        end
+      end
+
+      private
+
+      def install_kernal_traps(layout)
+        @trap_layout = layout
+        load_trap = KernalTrap::Load.new(cpu:, bus: trap_bus, layout:, dos: @dos)
+        cpu.install_trap(layout.load) { load_trap.call }
+        @serial_trap = KernalTrap::Serial.new(cpu:, bus: trap_bus, layout:, dos: @dos,
+                                              device: serial_trap_device).install
+        save_trap = @save_trap = KernalTrap::Save.new(cpu:, bus: trap_bus, layout:, dos: @dos)
+        cpu.install_trap(layout.save) { save_trap.call }
+      end
+
+      def remove_kernal_traps
+        cpu.remove_trap(@trap_layout.load)
+        cpu.remove_trap(@trap_layout.save)
+        @serial_trap.uninstall
+        @serial_trap = nil
+        @save_trap = nil
+      end
+
+      # The disk device 8 serves through the traps, with the traps' own
+      # state: open channels, the drive's status and RAM, a SAVE under way.
+      def save_trap_dos(out)
+        out.boolean(!@dos.nil?)
+        return unless @dos
+
+        @dos.save_state(out)
+        @serial_trap.save_state(out)
+        @save_trap.save_state(out)
+      end
+
+      def load_trap_dos(input)
+        return unmount unless input.boolean?
+
+        storage = Snapshot::StorageSetup.read(input)
+        unmount
+        mount(storage)
+        @dos.load_state(input)
+        @serial_trap.load_state(input)
+        @save_trap.load_state(input)
+      end
+    end
+  end
+end

data/lib/badline/c64/reu/dma/saved_state.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      class DMA
+        # A transfer's state for a snapshot (REU::SavedState).
+        module SavedState
+          # Everything a transfer holds between cycles. Before the first
+          # transfer, the fields it sets on starting are empty.
+          def save_state(out)
+            out.int(@c64).int(@expansion).int(@length).int(@events)
+            [@type, @c64_step, @expansion_step, @last, @ba_low_after_writes, @swap_byte, @held_read].each do |value|
+              out.optional_int(value)
+            end
+            [@holding, @waiting, @stopped_after_write, @swap_write_due, @swap_read_again, @moved_all,
+             @extra_cycle].each do |flag|
+              out.boolean(flag)
+            end
+          end
+
+          def load_state(input)
+            @c64 = input.int
+            @expansion = input.int
+            @length = input.int
+            @events = input.int
+            load_steps(input)
+            @holding = input.boolean?
+            @waiting = input.boolean?
+            @stopped_after_write = input.boolean?
+            @swap_write_due = input.boolean?
+            @swap_read_again = input.boolean?
+            @moved_all = input.boolean?
+            @extra_cycle = input.boolean?
+          end
+
+          private
+
+          def load_steps(input)
+            @type = input.optional_int
+            @c64_step = input.optional_int
+            @expansion_step = input.optional_int
+            @last = input.optional_int
+            @ba_low_after_writes = input.optional_int
+            @swap_byte = input.optional_int
+            @held_read = input.optional_int
+          end
+        end
+      end
+    end
+  end
+end