badline 0.9.0 → 0.10.1

data/lib/badline/media/vic20_basic.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A program loading into a VIC-20 once it has booted (Vic20Media).
+    module Vic20Basic
+      # Where BASIC starts with each RAM expansion it can start in, as
+      # TXTTAB holds it.
+      BASIC_STARTS = { 0x1001 => :unexpanded, 0x0401 => :"3k", 0x1201 => :"8k" }.freeze
+
+      class << self
+        # A BASIC program, one that loads at a start of BASIC or a byte
+        # ahead of it, goes to this machine's start of BASIC. Anything else
+        # goes where it says, and doesn't RUN.
+        def load_program(machine, data, autostart:)
+          load_addr = data[0] | (data[1] << 8)
+          basic_start = machine.basic_start
+          ahead = [0, 1].find { |offset| BASIC_STARTS.key?(load_addr + offset) || load_addr + offset == basic_start }
+          return machine.load_prg(data) unless ahead
+
+          load_basic(machine, data, basic_start - ahead, load_addr)
+          machine.type_text("run\r") if autostart
+        end
+
+        private
+
+        # Puts a BASIC program at `address`, relinking its lines when that
+        # isn't where it was saved from, as BASIC's LOAD does, and sets the
+        # end of the program, where BASIC's variables start, and the end
+        # address the KERNAL's LOAD leaves.
+        def load_basic(machine, data, address, saved_at)
+          ram = machine.ram
+          ram.write(address, data[2..])
+          end_addr = address + data.length - 2
+          relink(ram, machine.basic_start, end_addr) unless address == saved_at
+          [0x2d, 0xae].each { |pointer| ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+        end
+
+        # Points each line's link at the line after it, as BASIC's LINKPRG
+        # does: past the zero that ends the line's text. A link with a zero
+        # high byte ends the program.
+        def relink(ram, line, end_addr)
+          while line + 4 < end_addr && ram.peek(line + 1).positive?
+            following = line + 4
+            following += 1 while following < end_addr && ram.peek(following).positive?
+            following += 1
+            ram.write(line, [following & 0xff, following >> 8])
+            line = following
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/vic20_cartridge.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A VIC-20 cartridge kept as programs, one per ROM chip, each loading
+    # at the block the chip goes in. The chip in BLK5 at $A000 starts the
+    # cartridge, and a bigger cartridge has more in BLK1 to BLK3. The files
+    # of one cartridge share a name, with each block's address in its
+    # extension (game.a0, game.60) or its name (game-a000.prg,
+    # game-6000.prg).
+    module Vic20Cartridge
+      BLOCKS = [0xa000, 0x2000, 0x4000, 0x6000].freeze
+
+      class << self
+        # The ROM chips, as CRTFile::Chips, of the cartridge `data`, the
+        # program at `path`, is a part of, or nil when it isn't one: a
+        # program loading at $A000, or one loading at the start of BLK1 to
+        # BLK3 with an $A000 part beside it.
+        def chips(path, data)
+          own = load_address(data)
+          return unless BLOCKS.include?(own)
+
+          parts = BLOCKS.filter_map { |address| address == own ? data : part(path, own, address) }
+          return unless parts.any? { |part| load_address(part) == 0xa000 }
+
+          parts.map { |part| rom_chip(part) }
+        end
+
+        # A program's bytes, unwrapped from a .p00.
+        def program_bytes(path)
+          bytes = File.binread(path).bytes
+          Storage::P00.wraps?(bytes) ? Storage::P00.data(bytes) : bytes
+        end
+
+        private
+
+        def load_address(data)
+          data[0] | (data[1] << 8) if data.length > 2
+        end
+
+        def part(path, own, address)
+          name = part_names(path, own, address).find { |candidate| File.file?(candidate) }
+          return unless name
+
+          part = program_bytes(name)
+          part if load_address(part) == address
+        end
+
+        # `path` with the block at `own` in its extension or its name
+        # swapped for the one at `address`, its letters in either case.
+        def part_names(path, own, address)
+          extension = File.extname(path)
+          base = path[0, path.length - extension.length]
+          own_tag = own.to_s(16)
+          tags = [address.to_s(16), address.to_s(16).upcase].uniq
+          return tags.map { |tag| "#{base}.#{tag[0, 2]}" } if extension.downcase == ".#{own_tag[0, 2]}"
+
+          name = File.basename(base)
+          at = name.downcase.index(own_tag)
+          return [] unless at
+
+          tags.map { |tag| File.join(File.dirname(base), name[0, at] + tag + name[(at + 4)..]) + extension }
+        end
+
+        # A ROM chip of whole pages, the last padded with $FF.
+        def rom_chip(part)
+          data = part[2..]
+          data += [0xff] * (-data.length % 0x100)
+          Storage::CRTFile::Chip.new(chip_type: 0, bank: 0, address: load_address(part), data:)
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/vic20_media.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # Media on a VIC-20. A program loads once the KERNAL has booted: a
+    # BASIC program at the start of BASIC, wherever the RAM puts it, and
+    # RUNs. A program that loads into BLK5 at $A000 is a cartridge's ROM
+    # instead, as are the parts of a set that includes one
+    # (Vic20Cartridge), and goes in with a power cycle, as a .crt does.
+    # Disks mount on device 8 through the KERNAL traps, or go in a true
+    # 1541 (TrueDrive), and tapes play on the datasette.
+    module Vic20Media
+      # The expansions that fill BLK1, BLK2 and BLK3 one block after
+      # another, each with the last address it fills.
+      BLOCK_EXPANSIONS = [[0x3fff, :"8k"], [0x5fff, :"16k"], [0x7fff, :"24k"]].freeze
+
+      # What a VIC-20 doesn't take.
+      UNSUPPORTED = %w[.sid].freeze
+
+      # The platform byte of a VIC-20 tape (Storage::TAP#platform).
+      TAPE_PLATFORM = 1
+
+      class << self
+        def attach(machine, path, autostart:, **options)
+          extension = File.extname(path).downcase
+          raise ArgumentError, "#{path} doesn't go in a VIC-20" if UNSUPPORTED.include?(extension)
+
+          if TrueDrive.takes?(machine, path)
+            attach_true_drive(machine, path, options.fetch(:disk, {}), autostart:)
+          elsif File.directory?(path)
+            machine.mount(Storage::HostDirectory.new(path))
+            "Mounted #{path} as device 8"
+          elsif extension == ".crt"
+            attach_cartridge(machine, path, Storage::CRTFile.new(path, machine: :vic20).chips)
+          elsif extension == ".tap"
+            attach_tape(machine, path, autostart:)
+          elsif MOUNT_TYPES.key?(extension)
+            attach_storage(machine, path, options.fetch(:disk, {}), autostart:)
+          else
+            attach_prg(machine, path, autostart:)
+          end
+        end
+
+        # The RAM expansion (Vic20::Bus::RAM_CONFIGURATIONS) a VIC-20 needs
+        # for the program at `path`, or for the first program on the disk
+        # or in the directory there, by where it loads. A BASIC program
+        # needs the expansion its start of BASIC comes with, and more of
+        # BLK1 to BLK3 when it runs past $3FFF. So does a machine-language
+        # program loading into those blocks. Anything else, cartridges
+        # included, runs unexpanded.
+        def ram_for(path)
+          data = first_program(path)
+          return :unexpanded unless data && data.length > 2 && !Vic20Cartridge.chips(path, data)
+
+          load_addr = data[0] | (data[1] << 8)
+          if load_addr == 0x1201 || load_addr.between?(0x2000, 0x7fff)
+            expansion_reaching(load_addr + data.length - 3)
+          else
+            Vic20Basic::BASIC_STARTS.fetch(load_addr, :unexpanded)
+          end
+        end
+
+        private
+
+        def expansion_reaching(last)
+          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
+          BLOCK_EXPANSIONS.last.last
+        end
+
+        def first_program(path)
+          extension = File.extname(path).downcase
+          if File.directory?(path) || MOUNT_TYPES.key?(extension)
+            open_storage(path).read_file("*")
+          elsif File.file?(path) && !%w[.sid .crt .tap .g64].include?(extension)
+            Vic20Cartridge.program_bytes(path)
+          end
+        end
+
+        def open_storage(path, disk = {})
+          return Storage::HostDirectory.new(path) if File.directory?(path)
+
+          storage = MOUNT_TYPES.fetch(File.extname(path).downcase)
+          storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
+        end
+
+        def attach_cartridge(machine, path, chips)
+          machine.attach_cartridge(chips)
+          "Attached cartridge #{path}"
+        end
+
+        # A tape made for another machine plays all the same, and says so.
+        def attach_tape(machine, path, autostart:)
+          tape = Storage::TAP.new(path)
+          machine.datasette.insert(tape)
+          machine.datasette.play!
+          machine.type_text(TAPE_AUTOSTART) if autostart
+          message = "Inserted #{path} in the datasette"
+          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the VIC-20"
+        end
+
+        def attach_true_drive(machine, path, disk, autostart:)
+          message = TrueDrive.insert(machine, path, read_only: disk.fetch(:read_only, false))
+          machine.type_text(disk_autostart(first_program(path))) if autostart
+          message
+        end
+
+        def attach_storage(machine, path, disk, autostart:)
+          storage = open_storage(path, disk)
+          machine.mount(storage)
+          machine.type_text(disk_autostart(storage.read_file("*"))) if autostart
+          "Mounted #{path} as device 8"
+        end
+
+        # A BASIC program loads relocated to the start of BASIC, and anything
+        # else where it says.
+        def disk_autostart(data)
+          basic = data && data.length > 2 && Vic20Basic::BASIC_STARTS.key?(data[0] | (data[1] << 8))
+          basic ? %(lO"*",8\rrun\r) : AUTOSTART
+        end
+
+        def attach_prg(machine, path, autostart:)
+          bytes = Vic20Cartridge.program_bytes(path)
+          chips = Vic20Cartridge.chips(path, bytes)
+          return attach_cartridge(machine, path, chips) if chips
+
+          machine.on_init { Vic20Basic.load_program(machine, bytes, autostart:) }
+          "Loading #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/badline/media.rb

@@ -4,6 +4,9 @@ require "badline/media/true_drive"
 require "badline/media/queue"
 require "badline/media/disk_set"
 require "badline/media/disk_list"
+require "badline/media/vic20_basic"
+require "badline/media/vic20_cartridge"
+require "badline/media/vic20_media"
 
 module Badline
   module Media
@@ -30,25 +33,13 @@ module Badline
       # autostart then loads through it.
       #
       # An .m3u or .vfl list of disks attaches the first disk it lists
-      # (DiskList).
-      def attach(computer, path, autostart: true, subtune: nil, **options)
+      # (DiskList). A machine other than the C64 takes its own media
+      # (Vic20Media).
+      def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        if TrueDrive.takes?(computer, path)
-          attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
-        elsif File.directory?(path)
-          computer.mount(Storage::HostDirectory.new(path))
-          "Mounted #{path} as device 8"
-        elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
-        elsif File.extname(path).downcase == ".sid"
-          attach_sid(computer, path, autostart:, subtune:)
-        elsif File.extname(path).downcase == ".tap"
-          attach_tape(computer, path, autostart:)
-        elsif MOUNT_TYPES.key?(File.extname(path).downcase)
-          attach_storage(computer, path, options.fetch(:disk, {}), autostart:)
-        else
-          attach_prg(computer, path, autostart:)
-        end
+        return Vic20Media.attach(computer, path, autostart:, **) unless computer.is_a?(Computer)
+
+        attach_c64(computer, path, autostart:, subtune:, **)
       end
 
       # Swaps the disk in device 8 for a disk image or a host directory,
@@ -69,6 +60,10 @@ module Badline
         "Inserted #{path} in device 8"
       end
 
+      # The RAM expansion a VIC-20 for `path` should be built with
+      # (Vic20Media.ram_for), a key of Vic20::Bus::RAM_CONFIGURATIONS.
+      def vic20_ram_for(path) = Vic20Media.ram_for(path)
+
       # The SID a machine for `path` should be built with. A .sid tune names
       # its own; everything else gets `otherwise`.
       def sid_model(path, otherwise: :mos6581)
@@ -79,6 +74,25 @@ module Badline
 
       private
 
+      def attach_c64(computer, path, autostart:, subtune:, **options)
+        if TrueDrive.takes?(computer, path)
+          attach_true_drive(computer, path, options.fetch(:disk, {}), autostart:)
+        elsif File.directory?(path)
+          computer.mount(Storage::HostDirectory.new(path))
+          "Mounted #{path} as device 8"
+        elsif File.extname(path).downcase == ".crt"
+          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
+        elsif File.extname(path).downcase == ".sid"
+          attach_sid(computer, path, autostart:, subtune:)
+        elsif File.extname(path).downcase == ".tap"
+          attach_tape(computer, path, autostart:)
+        elsif MOUNT_TYPES.key?(File.extname(path).downcase)
+          attach_storage(computer, path, options.fetch(:disk, {}), autostart:)
+        else
+          attach_prg(computer, path, autostart:)
+        end
+      end
+
       def disk?(path)
         storage = MOUNT_TYPES[File.extname(path).downcase]
         File.directory?(path) || (!storage.nil? && storage < Storage::DiskImage)

data/lib/badline/model.rb

@@ -8,39 +8,56 @@ module Badline
   # a datasette. The names are x64sc's.
   module Model
     # Each field but the name is a keyword Computer.new takes.
-    Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :kernal, :datasette)
+    Profile = Data.define(:name, :vic_model, :cia_model, :sid_model, :region, :kernal, :datasette, :board)
 
     # The breadbin PAL C64: the 6569 VIC-II, 6526 CIAs and the 6581 SID.
     C64 = Profile.new(name: "c64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                      region: Region::PAL, kernal: :c64, datasette: true)
+                      region: Region::PAL, kernal: :c64, datasette: true, board: :c64)
 
     # The PAL C64C: the HMOS 8565 VIC-II, 6526A CIAs and the 8580 SID.
     C64C = Profile.new(name: "c64c", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
-                       region: Region::PAL, kernal: :c64, datasette: true)
+                       region: Region::PAL, kernal: :c64, datasette: true, board: :c64)
 
     # The NTSC C64 with the 6567R8 VIC-II.
     NTSC = Profile.new(name: "ntsc", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                       region: Region::NTSC, kernal: :c64, datasette: true)
+                       region: Region::NTSC, kernal: :c64, datasette: true, board: :c64)
 
     # The NTSC C64C: the 8562, the 6567R8's HMOS successor, with the
     # C64C's CIAs and SID.
     NEW_NTSC = Profile.new(name: "newntsc", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
-                           region: Region::NTSC, kernal: :c64, datasette: true)
+                           region: Region::NTSC, kernal: :c64, datasette: true, board: :c64)
 
     # The first NTSC C64s, with the 6567R56A VIC-II.
     OLD_NTSC = Profile.new(name: "oldntsc", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                           region: Region::NTSC_OLD, kernal: :c64, datasette: true)
+                           region: Region::NTSC_OLD, kernal: :c64, datasette: true, board: :c64)
 
     # The Drean C64 of Argentina, on PAL-N with the 6572 VIC-II.
     DREAN = Profile.new(name: "drean", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                        region: Region::DREAN, kernal: :c64, datasette: true)
+                        region: Region::DREAN, kernal: :c64, datasette: true, board: :c64)
 
     # The portable SX-64: a PAL C64's chips with its own KERNAL, a 1541
     # built in as device 8 and no cassette port.
     SX64 = Profile.new(name: "sx64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
-                       region: Region::PAL, kernal: :sx64, datasette: false)
+                       region: Region::PAL, kernal: :sx64, datasette: false, board: :c64)
 
-    ALL = [C64, C64C, NTSC, NEW_NTSC, OLD_NTSC, DREAN, SX64].freeze
+    # The PET 64, or Educator 64: a PAL C64's board in a PET's case, with
+    # its own KERNAL and a green monochrome monitor built in.
+    PET64 = Profile.new(name: "pet64", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                        region: Region::PAL, kernal: :pet64, datasette: true, board: :pet64)
+
+    # The C64GS games console: a PAL C64C's board with its own BASIC and
+    # KERNAL, which show an animation asking for a cartridge when it has
+    # none, in a case with no keyboard and no cassette port.
+    C64GS = Profile.new(name: "c64gs", vic_model: :mos8565, cia_model: :mos6526a, sid_model: :mos8580,
+                        region: Region::PAL, kernal: :gs, datasette: false, board: :gs)
+
+    # The MAX Machine, or Ultimax, of Japan: the 6566, an NTSC VIC-II
+    # for static RAM, which runs here as the first NTSC C64s' 6567R56A,
+    # one CIA, 2K of RAM and no ROMs, so it runs only a cartridge's.
+    ULTIMAX = Profile.new(name: "ultimax", vic_model: :mos6569, cia_model: :mos6526, sid_model: :mos6581,
+                          region: Region::NTSC_OLD, kernal: :c64, datasette: true, board: :max)
+
+    ALL = [C64, C64C, NTSC, NEW_NTSC, OLD_NTSC, DREAN, SX64, PET64, C64GS, ULTIMAX].freeze
 
     def self.named(name)
       model = ALL.find { |candidate| candidate.name == name }
@@ -49,13 +66,13 @@ module Badline
       model
     end
 
-    # The model whose chips, region, KERNAL and datasette `machine` has, or
-    # nil for none.
+    # The model whose chips, region, KERNAL, datasette and board `machine`
+    # has, or nil for none.
     def self.of(machine)
       ALL.find do |model|
         model.vic_model == machine.vic_model && model.cia_model == machine.cia_model &&
           model.sid_model == machine.sid_model && model.region == machine.region &&
-          model.kernal == machine.kernal && model.datasette == machine.datasette
+          model.kernal == machine.kernal && model.datasette == machine.datasette && model.board == machine.board
       end
     end
   end

data/lib/badline/options/event.rb

@@ -6,10 +6,11 @@ module Badline
     # `frame` frames have run. An event given at several frames becomes
     # one Event per frame.
     class Event
-      # The actions, and whether each takes an argument.
+      # The actions, and whether each takes an argument. menu's page may be
+      # left out.
       ACTIONS = {
-        "key" => true, "type" => true, "insert" => true, "eject" => true, "screenshot" => true,
-        "reset" => false, "freeze" => false, "quit" => false
+        "key" => true, "type" => true, "insert" => true, "eject" => true, "screenshot" => true, "menu" => true,
+        "reset" => false, "freeze" => false, "resume" => false, "quit" => false
       }.freeze
 
       # The frames a key or the freeze button is held for.
@@ -79,6 +80,7 @@ module Badline
 
       def self.valid?(action, argument)
         return false unless ACTIONS.key?(action)
+        return true if action == "menu"
         return argument.empty? unless ACTIONS[action]
         return EJECTABLE.include?(argument) if action == "eject"
         return insertable?(argument) if action == "insert"

data/lib/badline/options/help.rb

@@ -37,11 +37,17 @@ module Badline
 
     def banner
       <<~BANNER
-        Usage: #{@program} [options] [media]
+        Usage: #{@program} [c64] [options] [media]
+               #{@program} vic20 [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
 
+        Commands:
+            c64                              Run a C64, the one --model names (the default)
+            vic20                            Run a PAL VIC-20, with the RAM --ram names
+            sid                              Play .sid tunes and directories of them
+
         Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
         .g64 disk image for the true 1541, an .m3u or .vfl list of disk
         images, a .t64 tape archive, a .tap tape, a .crt cartridge, a .sid
@@ -80,8 +86,10 @@ module Badline
         frames. type=TEXT types it, with \\n for RETURN. insert=FILE swaps
         in a disk, a list's first disk, a tape or a cartridge, and
         eject=disk, tape or cartridge takes one out. screenshot=FILE saves
-        the frame as a .bmp, with the frame's number in place of %d. reset,
-        freeze and quit take no argument.
+        the frame as a .bmp, with the frame's number in place of %d. menu
+        opens the pause menu, and menu=PAGE opens it on snapshots, drive,
+        datasette, expansion, ports, sound or power. Its frames still count,
+        and resume closes it. reset, freeze and quit take no argument.
       BANNER
     end
 

data/lib/badline/options/table.rb

@@ -5,7 +5,15 @@ module Badline
     DEFAULT_RATE = 44_100
 
     # The names Badline::Model builds, in the order the help lists them.
-    MODELS = %w[c64 c64c ntsc newntsc oldntsc drean sx64].freeze
+    MODELS = %w[c64 c64c ntsc newntsc oldntsc drean sx64 pet64 c64gs ultimax].freeze
+
+    # The VIC-20's models, as xvic names its video standards. Only PAL is
+    # emulated.
+    VIC20_MODELS = %w[pal ntsc].freeze
+
+    # The VIC-20 RAM expansions --ram takes, in the order the help lists
+    # them.
+    RAM_NAMES = %w[unexpanded 3k 8k 16k 24k 32k all].freeze
 
     SECTIONS = ["Options", "Window options", "Options without the window", "Testing options"].freeze
 
@@ -28,9 +36,11 @@ module Badline
                  section: "Window options", needs: :window),
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),
-      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first})",
+      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal",
                  section: "Window options", needs: :window),
       Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
+      Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded)",
+                 section: "Window options", needs: :window),
       Option.new("--no-vsync", "Pace frames by the timer or the sound instead of the display",
                  section: "Window options", needs: :window),
       Option.new("--verbose", "Print the display, sound and gamepad setup and the frame timing",

data/lib/badline/options/validation.rb

@@ -2,13 +2,45 @@
 
 module Badline
   class Options
-    # The checks Options#parse makes once every argument has been read:
-    # the options fit the mode, the numbers are positive and the files
-    # exist.
+    # The checks Options#parse makes: that each value reads as its option
+    # takes it, and once every argument has been read, that the options
+    # fit the mode, the numbers are positive and the files exist.
     module Validation
       private
 
+      def sid_model_for(value)
+        return if value == "auto"
+        raise Error, "invalid argument: --sid #{value}" unless SID_MODELS.key?(value)
+
+        SID_MODELS[value]
+      end
+
+      def ram_configuration(value)
+        raise Error, "invalid argument: --ram #{value}" unless RAM_CONFIGURATIONS.key?(value)
+
+        RAM_CONFIGURATIONS[value]
+      end
+
+      def reu_size(value)
+        raise Error, "invalid argument: --reu #{value}" unless REU_SIZES.include?(value)
+
+        value.to_i
+      end
+
+      def number(flag, value)
+        raise Error, "invalid argument: #{flag} #{value}" unless value.match?(/\A\d+\z/)
+
+        value.to_i
+      end
+
+      def decimal(flag, value)
+        raise Error, "invalid argument: #{flag} #{value}" unless value.match?(DECIMAL)
+
+        value.to_f
+      end
+
       def validate
+        validate_family
         validate_mode
         validate_models
         validate_numbers
@@ -26,6 +58,24 @@ module Badline
         end
       end
 
+      def validate_family
+        if @family == :vic20
+          validate_vic20
+        elsif !@ram.nil?
+          raise Error, "--ram needs vic20"
+        end
+      end
+
+      # The VIC-20 is a PAL one, in the window, without the C64's SID and
+      # REU.
+      def validate_vic20
+        raise Error, "the NTSC VIC-20 isn't emulated yet" if @models.include?("ntsc")
+
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the VIC-20 needs the window" if headless?
+      end
+
       # `sid` takes directories as well as tunes.
       def validate_tune(path)
         return if !File.exist?(path) || File.extname(path).casecmp?(".sid")
@@ -37,7 +87,8 @@ module Badline
       # --model and --ntsc may be given more than once, but only for one
       # model.
       def validate_models
-        unknown = @models.find { |name| !MODELS.include?(name) }
+        names = @family == :vic20 ? VIC20_MODELS : MODELS
+        unknown = @models.find { |name| !names.include?(name) }
         raise Error, "invalid argument: --model #{unknown}" unless unknown.nil?
         raise Error, "conflicting models: #{@models.uniq.join(' and ')}" unless @models.uniq.size <= 1
       end