badline 0.12.1 → 0.13.0

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # RGCD: up to eight 8K banks. A write to I/O 1 selects the bank from the
+      # low bits, and bit 3 switches the ROM out until reset. The Hucky board
+      # (subtype 1) inverts the bank bits and decodes only as many as it has
+      # banks.
+      class RGCD < Cartridge
+        def initialize(crt)
+          @hucky = crt.subtype == 1
+          super
+        end
+
+        def poke(addr, value)
+          return if addr > 0xdeff || @disabled
+
+          select(value)
+          changed!
+        end
+
+        def reset
+          @disabled = false
+          self.mode = :rom8k
+          select(0)
+          changed!
+        end
+
+        private
+
+        def save_mapper(out)
+          super
+          out.boolean(@disabled)
+        end
+
+        def load_mapper(input)
+          super
+          @disabled = input.boolean?
+        end
+
+        def select(value)
+          value ^= 0x07 if @hucky
+          if value.anybits?(0x08)
+            @disabled = true
+            self.mode = :off
+          else
+            @roml = bank(@banks, value & @bank_mask)
+          end
+        end
+
+        def install_chips(chips)
+          @banks = banks_from(chips).first
+          @bank_mask = @hucky ? bank_mask(@banks) : 0x07
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # A cartridge's state for a snapshot: the setup that builds it again and
+      # the state that goes into it.
+      module SavedState
+        # What builds the same cartridge afresh (Cartridge.from_setup): the CRT
+        # image it was built from, and the jumpers of a mapper that has them.
+        def save_setup(out)
+          out.int(CRT_SETUP).string(Storage::CRTFile.encode(@crt))
+          save_jumpers(out)
+        end
+
+        # The lines, the pull on NMI, the button and the mapper's own state.
+        # Loading sets them without calling back into the machine, which maps
+        # the cartridge again afterwards.
+        def save_state(out)
+          out.marker("CARTRIDGE")
+          out.int(@exrom).int(@game).boolean(@nmi).boolean(@button == true)
+          save_mapper(out)
+        end
+
+        def load_state(input)
+          input.marker("CARTRIDGE")
+          @exrom = input.int
+          @game = input.int
+          @nmi = input.boolean?
+          @button = input.boolean?
+          load_mapper(input)
+        end
+
+        private
+
+        def save_jumpers(out)
+          out.boolean(false)
+        end
+
+        # The mapper's own state: where its windows point, for a mapper that
+        # moves them, and whatever a mapper adds after calling super.
+        def save_mapper(out)
+          save_windows(out, windows) if windows
+        end
+
+        def load_mapper(input)
+          load_windows(input, windows) if windows
+        end
+
+        # Where the ROML and ROMH windows point, as their places in `windows`,
+        # the banks and views the mapper picks them from, or -1 for none.
+        def save_windows(out, windows)
+          out.int(window_index(@roml, windows)).int(window_index(@romh, windows))
+        end
+
+        def load_windows(input, windows)
+          @roml = window_at(input.int, windows)
+          @romh = window_at(input.int, windows)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # 16K. Reading I/O 1 switches ROMH out (8K mode), writing it switches
+      # ROMH back in.
+      class SimonsBasic < Cartridge
+        def readable_io_pages
+          [0xde]
+        end
+
+        def peek(addr)
+          select_mode(:rom8k) if addr < 0xdf00
+          open_bus(addr)
+        end
+
+        def poke(addr, _value)
+          select_mode(:rom16k) if addr < 0xdf00
+        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/standard.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      class Standard < Cartridge
+        private
+
+        def install_chips(chips)
+          roml, romh = banks_from(chips)
+          @roml = roml.compact.first
+          @romh = romh.compact.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Super Games: four 16K banks. A write to I/O 2 selects the bank from bits
+      # 0-1, switches the ROM out with bit 2, and with bit 3 locks the register
+      # until reset.
+      class SuperGames < Cartridge
+        def poke(addr, value)
+          return if addr < 0xdf00 || @locked
+
+          select(value)
+          changed!
+        end
+
+        def reset
+          select(0)
+          changed!
+        end
+
+        private
+
+        def save_mapper(out)
+          super
+          out.boolean(@locked)
+        end
+
+        def load_mapper(input)
+          super
+          @locked = input.boolean?
+        end
+
+        def windows = [*@roml_banks, *@romh_banks, EMPTY_BANK]
+
+        def select(value)
+          @roml = bank(@roml_banks, value & 0x03)
+          @romh = bank(@romh_banks, value & 0x03)
+          self.mode = value.anybits?(0x04) ? :off : :rom16k
+          @locked = value.anybits?(0x08)
+        end
+
+        def install_chips(chips)
+          @roml_banks, @romh_banks = banks_from(chips)
+          reset
+        end
+      end
+    end
+  end
+end

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/{computer → c64}/common.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Badline
-  class Computer
+  class C64
     # What the C128 does as the C64 does: the NMI line, a PRG put into RAM
-    # and the region's timing. Computer and C128 each include it.
+    # 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.