badline 0.12.1 → 0.14.0

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # C64 Game System / System 3: up to 64 8K banks. Any access to
+      # $DE00-$DEFF selects the bank from the low six address bits; the data
+      # is ignored.
+      class GameSystem < Cartridge
+        def readable_io_pages
+          [0xde]
+        end
+
+        def peek(addr)
+          select(addr) if addr < 0xdf00
+          open_bus(addr)
+        end
+
+        def poke(addr, _value)
+          select(addr) if addr < 0xdf00
+        end
+
+        def reset
+          select(0)
+        end
+
+        private
+
+        def select(addr)
+          @roml = bank(@banks, addr & 0x3f)
+          changed!
+        end
+
+        def install_chips(chips)
+          @banks = banks_from(chips).first
+          self.mode = :rom8k
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # GEO-RAM: a RAM expansion on the expansion port, seen through a 256-byte
+      # window at $DE00-$DEFF. Two write-only registers pick the page the
+      # window shows: $DFFE selects one of the 64 pages of a 16K block, and
+      # $DFFF selects the block. As in VICE, the registers answer at every
+      # address from $DF80 up, even for $DFFE and odd for $DFFF, and the block
+      # number wraps at the number of blocks the RAM holds. Reads of I/O 2 are
+      # open bus. It leaves EXROM and GAME high, and RES clears both
+      # registers.
+      class GeoRAM < Cartridge
+        SIZES = [64, 128, 256, 512, 1024, 2048, 4096].freeze
+        BLOCK_SIZE = 0x4000
+        PAGE_MASK = 0x3f
+
+        attr_reader :size
+
+        # size is the RAM in kilobytes.
+        def initialize(size: 512)
+          raise ArgumentError, "Unsupported GEO-RAM size #{size}K" unless SIZES.include?(size)
+
+          @size = size
+          @block_mask = ((size * 1024) / BLOCK_SIZE) - 1
+          super(Storage::CRTFile::Image.new(hardware_type: nil, subtype: 0, exrom: 1, game: 1,
+                                            name: "GEO-RAM", chips: []))
+        end
+
+        def readable_io_pages
+          [0xde]
+        end
+
+        def peek(addr)
+          @ram_data[@window + (addr & 0xff)]
+        end
+
+        def poke(addr, value)
+          if addr <= 0xdeff
+            @ram_data[@window + (addr & 0xff)] = value
+          elsif addr >= 0xdf80
+            if addr.odd?
+              @block = value & @block_mask
+            else
+              @page = value & PAGE_MASK
+            end
+            @window = (@block * BLOCK_SIZE) + (@page * 0x100)
+          end
+        end
+
+        def reset
+          @block = @page = @window = 0
+        end
+
+        private
+
+        def install_chips(_chips)
+          @ram_data = Array.new(@size * 1024, 0)
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # The KCS Power Cartridge: 16K of ROM, 128 bytes of RAM and a freeze
+      # button. It boots in 16K mode, and any access to I/O 1 sets the lines
+      # from address bit 1 and the direction:
+      #
+      #   read,  bit 1 clear  8K
+      #   read,  bit 1 set    off
+      #   write, bit 1 clear  16K
+      #   write, bit 1 set    Ultimax
+      #
+      # A read of I/O 1 returns the second last page of ROML. I/O 2 holds the
+      # RAM in its lower half, and the upper half reads the EXROM line in bit 7
+      # and GAME in bit 6, which the freezer checks to find the mode it
+      # interrupted. A freeze switches to Ultimax and lets go of NMI.
+      class KCSPower < Cartridge
+        include Freezer
+
+        IO1_ROM_PAGE = 0x1e00
+
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          if addr < 0xdf00
+            select_mode(addr.anybits?(0x02) ? :off : :rom8k)
+            @roml.peek(IO1_ROM_PAGE | (addr & 0xff))
+          elsif addr.anybits?(0x80)
+            (@exrom << 7) | (@game << 6) | (open_bus(addr) & 0x3f)
+          else
+            @io_ram[addr & 0x7f]
+          end
+        end
+
+        def poke(addr, value)
+          if addr < 0xdf00
+            select_mode(addr.anybits?(0x02) ? :ultimax : :rom16k)
+          elsif addr.nobits?(0x80)
+            @io_ram[addr & 0x7f] = value
+          end
+        end
+
+        def reset
+          self.nmi = false
+          select_mode(:rom16k)
+        end
+
+        def freeze!
+          self.nmi = false
+          select_mode(:ultimax)
+        end
+
+        private
+
+        def install_chips(chips)
+          roml, romh = banks_from(chips)
+          @roml = roml.first || EMPTY_BANK
+          @romh = romh.first || EMPTY_BANK
+          @io_ram = Array.new(0x80, 0xff)
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # A cartridge's fields in a keyed snapshot module (Snapshot::Keyed,
+      # BL-CART): the CRT image it was built from and its jumpers, which
+      # build it again (Cartridge.from_fields), the EXROM and GAME lines,
+      # its pull on NMI, the button, and where ROML and ROMH point, each by
+      # the name of the bank or view it shows (window_labels), and whatever
+      # each mapper adds.
+      module KeyedState
+        def save_fields(out)
+          save_setup_fields(out)
+          out.int("exrom", @exrom).int("game", @game).bool("nmi", @nmi).bool("button", @button == true)
+          save_mapper_fields(out)
+          out
+        end
+
+        def load_fields(input)
+          @exrom = input.masked("exrom", @exrom, 1)
+          @game = input.masked("game", @game, 1)
+          @nmi = input.bool("nmi", @nmi)
+          @button = input.bool("button", false)
+          load_mapper_fields(input)
+        end
+
+        private
+
+        def save_setup_fields(out)
+          out.bytes("crt", Storage::CRTFile.encode(@crt))
+          save_jumper_fields(out)
+        end
+
+        def save_jumper_fields(_out); end
+
+        def save_mapper_fields(out)
+          save_window_fields(out)
+        end
+
+        def load_mapper_fields(input)
+          load_window_fields(input)
+        end
+
+        # The name of each of `windows`, in the same order: bank<N> for the
+        # mapper's banks, and empty for erased ROM.
+        def window_labels
+          banks = @banks
+          return [] unless banks
+
+          [*Array.new(banks.length) { |number| "bank#{number}" }, "empty"]
+        end
+
+        def save_window_fields(out)
+          choices = windows
+          return unless choices
+
+          labels = window_labels
+          save_window(out, "roml", @roml, choices, labels)
+          save_window(out, "romh", @romh, choices, labels)
+        end
+
+        def save_window(out, key, window, choices, labels)
+          return if window.nil?
+
+          out.text(key, labels.fetch(window_index(window, choices)))
+        end
+
+        def load_window_fields(input)
+          choices = windows
+          return unless choices
+
+          labels = window_labels
+          @roml = window_named(input.choice("roml", [*labels, "none"], "none"), choices, labels)
+          @romh = window_named(input.choice("romh", [*labels, "none"], "none"), choices, labels)
+        end
+
+        def window_named(label, choices, labels)
+          index = labels.index(label)
+          index.nil? ? nil : choices.fetch(index)
+        end
+      end
+
+      include KeyedState
+
+      class << self
+        # A cartridge built afresh from the CRT image and the jumpers a
+        # keyed snapshot module holds, before load_fields puts its state in.
+        def from_fields(input)
+          kb = input.int("geo_ram_kb", 0)
+          return GeoRAM.new(size: kb) if kb.positive?
+
+          crt = Storage::CRTFile.new(bytes: input.bytes("crt", "".b))
+          mapper_for(crt).from_jumper_fields(crt, input)
+        end
+
+        def from_jumper_fields(crt, _input) = new(crt)
+      end
+
+      # Two banks of ROM, one behind each window: roml<N> and romh<N>.
+      module SplitBanks
+        private
+
+        def window_labels
+          [*Array.new(@roml_banks.length) { |number| "roml#{number}" },
+           *Array.new(@romh_banks.length) { |number| "romh#{number}" }, "empty"]
+        end
+      end
+
+      class SuperGames
+        include SplitBanks
+
+        private
+
+        def save_mapper_fields(out)
+          super
+          out.bool("locked", @locked)
+        end
+
+        def load_mapper_fields(input)
+          super
+          @locked = input.bool("locked", @locked)
+        end
+      end
+
+      class Comal80
+        include SplitBanks
+      end
+
+      class FinalCartridge3
+        include SplitBanks
+
+        private
+
+        def save_mapper_fields(out)
+          super
+          out.bool("register_visible", @register_visible).bool("phi1_ultimax", @phi1_ultimax)
+        end
+
+        def load_mapper_fields(input)
+          super
+          @io_bank = @roml
+          @register_visible = input.bool("register_visible", @register_visible)
+          @phi1_ultimax = input.bool("phi1_ultimax", @phi1_ultimax)
+        end
+      end
+
+      class RGCD
+        private
+
+        def save_mapper_fields(out)
+          super
+          out.bool("disabled", @disabled)
+        end
+
+        def load_mapper_fields(input)
+          super
+          @disabled = input.bool("disabled", @disabled)
+        end
+      end
+
+      class Zaxxon
+        class High
+          def save_fields(out)
+            out.int("high_bank", [*@banks, EMPTY_BANK].index { |bank| bank.equal?(@bank) }.to_i)
+          end
+
+          def load_fields(input)
+            choices = [*@banks, EMPTY_BANK]
+            @bank = choices.fetch(input.int("high_bank", 0).clamp(0, choices.length - 1))
+          end
+        end
+
+        private
+
+        def save_mapper_fields(out) = @romh.save_fields(out)
+
+        def load_mapper_fields(input) = @romh.load_fields(input)
+      end
+
+      class EpyxFastload
+        private
+
+        # How long ago the capacitor was discharged, on the machine's clock.
+        def save_mapper_fields(out)
+          out.int("discharged_ago", now_cycles - @discharged_at)
+        end
+
+        def load_mapper_fields(input)
+          @discharged_at = now_cycles - input.int("discharged_ago", now_cycles - @discharged_at)
+        end
+
+        def now_cycles
+          clock = @clock
+          clock ? clock.call : 0
+        end
+      end
+
+      class ActionReplay
+        private
+
+        def window_labels
+          ["through", "isolated", "contended", *Array.new(@rom_banks.length) { |number| "rom#{number}" }, "empty"]
+        end
+
+        def save_mapper_fields(out)
+          super
+          out.text("rom", window_labels.fetch(window_index(@rom, windows))).bool("active", @active)
+          out.bool("io2_ram", @io2_ram).bytes("ram", @ram_data)
+        end
+
+        def load_mapper_fields(input)
+          super
+          labels = window_labels
+          @rom = window_named(input.choice("rom", labels, "rom0"), windows, labels)
+          @active = input.bool("active", @active)
+          @io2_ram = input.bool("io2_ram", @io2_ram)
+          input.bytes_into("ram", @ram_data)
+        end
+      end
+
+      class KCSPower
+        private
+
+        def save_mapper_fields(out) = out.bytes("io_ram", @io_ram)
+
+        def load_mapper_fields(input) = input.bytes_into("io_ram", @io_ram)
+      end
+
+      class Pagefox
+        private
+
+        def window_labels
+          [*Array.new(@roml_banks.length) { |number| "roml#{number}" },
+           *Array.new(@romh_banks.length) { |number| "romh#{number}" },
+           *Array.new(@ram_banks.length) { |number| "ram#{number}" }, "open_bus", "empty"]
+        end
+
+        def save_mapper_fields(out)
+          super
+          @ram_banks.each_with_index { |ram, number| out.bytes("ram#{number}.data", ram.data) }
+        end
+
+        def load_mapper_fields(input)
+          super
+          @ram_banks.each_with_index { |ram, number| input.bytes_into("ram#{number}.data", ram.data) }
+        end
+      end
+
+      class GeoRAM
+        private
+
+        def save_setup_fields(out) = out.int("geo_ram_kb", @size)
+
+        def save_mapper_fields(out)
+          out.bytes("ram", @ram_data).int("block", @block).int("page", @page).int("window", @window)
+        end
+
+        def load_mapper_fields(input)
+          input.bytes_into("ram", @ram_data)
+          @block = input.int("block", @block)
+          @page = input.int("page", @page)
+          @window = input.int("window", @window)
+        end
+      end
+
+      class Flash
+        # The array, the command state by name, how far through a command
+        # sequence, the toggle bit, a timed operation's end in cycles from
+        # now, and the windows handed out so far, under `prefix`.
+        module KeyedState
+          STATE_NAMES = STATES.map(&:to_s).freeze
+
+          def save_fields(out, prefix)
+            out.bytes("#{prefix}data", @data).text("#{prefix}state", @state.to_s)
+            out.text("#{prefix}base_state", @base_state.to_s).int("#{prefix}cycle", @cycle)
+            out.int("#{prefix}toggle", @toggle)
+            done_at = @done_at
+            out.int("#{prefix}done_in", done_at - @clock.call) unless done_at.nil?
+            out.optional_int("#{prefix}programmed", @programmed).optional_int("#{prefix}remaining", @remaining)
+            sectors = @erasing_sectors
+            out.ints("#{prefix}erasing_sectors", sectors) if sectors
+            out.ints("#{prefix}windows", @windows.keys).ints("#{prefix}status_windows", @status_windows.keys)
+          end
+
+          def load_fields(input, prefix)
+            input.bytes_into("#{prefix}data", @data)
+            @state = state_named(input.choice("#{prefix}state", STATE_NAMES, "read"))
+            @base_state = state_named(input.choice("#{prefix}base_state", STATE_NAMES, "read"))
+            @cycle = input.int("#{prefix}cycle", @cycle)
+            @toggle = input.int("#{prefix}toggle", @toggle)
+            done_in = input.optional_int("#{prefix}done_in")
+            @done_at = done_in.nil? ? nil : @clock.call + done_in
+            @programmed = input.optional_int("#{prefix}programmed")
+            @remaining = input.optional_int("#{prefix}remaining")
+            sectors = input.ints("#{prefix}erasing_sectors", [])
+            @erasing_sectors = sectors.empty? ? nil : sectors.dup
+            rebuild_windows(input.ints("#{prefix}windows", []), input.ints("#{prefix}status_windows", []))
+          end
+
+          private
+
+          def state_named(name)
+            STATES.find { |state| state.to_s == name } || :read
+          end
+        end
+
+        include KeyedState
+      end
+
+      class GMod2
+        private
+
+        def save_mapper_fields(out)
+          out.int("bank", @bank).bool("flash_writes", @flash_writes)
+          @flash.save_fields(out, "flash.")
+        end
+
+        def load_mapper_fields(input)
+          @bank = input.int("bank", @bank)
+          @flash_writes = input.bool("flash_writes", @flash_writes)
+          @flash.load_fields(input, "flash.")
+          @roml = @flash.window(@bank * BANK_SIZE)
+        end
+      end
+
+      class EasyFlash
+        private
+
+        def save_mapper_fields(out)
+          out.int("bank", @bank).int("control", @control).bytes("io_ram", @io_ram)
+          @low_flash.save_fields(out, "flash_low.")
+          @high_flash.save_fields(out, "flash_high.")
+        end
+
+        def load_mapper_fields(input)
+          @bank = input.int("bank", @bank)
+          @control = input.byte("control", @control)
+          input.bytes_into("io_ram", @io_ram)
+          @low_flash.load_fields(input, "flash_low.")
+          @high_flash.load_fields(input, "flash_high.")
+          map_bank
+        end
+      end
+
+      class RetroReplay
+        CONFIG_NAMES = CONTROL_MODES.map(&:to_s).freeze
+
+        # The flash and bank jumpers, as the board has them set.
+        def self.from_jumper_fields(crt, input)
+          new(crt, flash_jumper: input.bool("jumper.flash", false), bank_jumper: input.bool("jumper.bank", false))
+        end
+
+        private
+
+        def save_jumper_fields(out)
+          out.bool("jumper.flash", @flash_jumper).bool("jumper.bank", @bank_jumper)
+        end
+
+        def save_mapper_fields(out)
+          out.bool("active", @active).bool("frozen", @frozen).bool("phi1_ultimax", @phi1_ultimax)
+          out.bool("ram_enabled", @ram_enabled).bool("ram_at_a000", @ram_at_a000).bool("allow_bank", @allow_bank)
+          out.bool("no_freeze", @no_freeze).bool("reu_mapping", @reu_mapping).bool("write_once", @write_once)
+          out.int("bank", @bank).text("config", @config.to_s)
+          @ram_data.each_with_index { |data, number| out.bytes("ram#{number}", data) }
+          @flash.save_fields(out, "flash.")
+        end
+
+        def load_mapper_fields(input)
+          load_flag_fields(input)
+          @bank = input.int("bank", @bank)
+          config = input.choice("config", CONFIG_NAMES, "rom8k")
+          @config = CONTROL_MODES.find { |mode| mode.to_s == config } || :rom8k
+          @ram_data.each_with_index { |data, number| input.bytes_into("ram#{number}", data) }
+          @flash.load_fields(input, "flash.")
+          map_windows
+        end
+
+        def load_flag_fields(input)
+          @active = input.bool("active", @active)
+          @frozen = input.bool("frozen", @frozen)
+          @phi1_ultimax = input.bool("phi1_ultimax", @phi1_ultimax)
+          @ram_enabled = input.bool("ram_enabled", @ram_enabled)
+          @ram_at_a000 = input.bool("ram_at_a000", @ram_at_a000)
+          @allow_bank = input.bool("allow_bank", @allow_bank)
+          @no_freeze = input.bool("no_freeze", @no_freeze)
+          @reu_mapping = input.bool("reu_mapping", @reu_mapping)
+          @write_once = input.bool("write_once", @write_once)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # 8K. Writing I/O 1 switches the ROM in, writing I/O 2 switches it out.
+      # Both I/O pages read the last 512 bytes of the ROM.
+      class Mach5 < Cartridge
+        def readable_io_pages
+          [0xde, 0xdf]
+        end
+
+        def peek(addr)
+          @roml.peek(addr)
+        end
+
+        def poke(addr, _value)
+          select_mode(addr < 0xdf00 ? :rom8k : :off)
+        end
+
+        def reset
+          select_mode(:rom8k)
+        end
+
+        private
+
+        def install_chips(chips)
+          @roml = banks_from(chips).first.compact.first || EMPTY_BANK
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Magic Desk: up to 128 8K banks. A write to I/O 1 selects the bank from
+      # bits 0-6, masked to the size of the ROM and at least four banks, and
+      # switches the ROM out with bit 7.
+      class MagicDesk < Cartridge
+        def poke(addr, value)
+          return if addr > 0xdeff
+
+          @exrom = value.anybits?(0x80) ? 1 : 0
+          @roml = bank(@banks, value & @bank_mask)
+          changed!
+        end
+
+        def reset
+          poke(0xde00, 0)
+        end
+
+        private
+
+        def install_chips(chips)
+          @banks = banks_from(chips).first
+          @bank_mask = (bank_mask(@banks) | 0x03) & 0x7f
+          reset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class Cartridge
+      # Ocean: up to 64 8K banks. A write to I/O 1 selects the bank from bits
+      # 0-5, masked to the size of the ROM.
+      class Ocean < Cartridge
+        def poke(addr, value)
+          return if addr > 0xdeff
+
+          select_bank(value & @bank_mask)
+          changed!
+        end
+
+        def reset
+          select_bank(0)
+          changed!
+        end
+
+        private
+
+        # In 16K mode the selected bank shows through ROMH as well.
+        def select_bank(number)
+          @roml = bank(@banks, number)
+          @romh = @roml if game.zero?
+        end
+
+        def install_chips(chips)
+          @banks = banks_from(chips).first
+          @bank_mask = bank_mask(@banks) & 0x3f
+          reset
+        end
+      end
+    end
+  end
+end