badline 0.13.0 → 0.15.0

data/lib/badline/frontend/menu/menu_media.rb

@@ -87,6 +87,13 @@ module Badline
         insert(:disk, set[index + step])
       end
 
+      # The extensions of the cartridges the machine takes: .crt, and on
+      # the Plus/4 raw .bin ROM images too.
+      def cartridge_extensions
+        extensions = Media::Extensions.of(%i[cartridge])
+        @computer.family == :plus4 ? extensions + [Media::Plus4Media::ROM_IMAGE] : extensions
+      end
+
       # Swaps the cartridge for the one at `path`, which power cycles the
       # machine, and says whether it went in.
       def attach_cartridge(path)
@@ -95,10 +102,11 @@ module Badline
 
       # What a save of the machine is named after: the cartridge, the disk,
       # the tape, or BASIC, without the bracketed parts of a file's name. A
-      # VIC-20's are named after its disk, or else the machine.
+      # VIC-20's are named after its disk, or else the machine, and a
+      # Plus/4's after its disk or tape.
       def game_name
         vic20 = @computer.family == :vic20
-        name = vic20 ? "" : cartridge_name
+        name = vic20 || @computer.family == :plus4 ? "" : cartridge_name
         disk = disk_path
         name = File.basename(disk, File.extname(disk)) if name.empty? && !disk.empty?
         name = tape_name if name.empty? && !vic20
@@ -114,8 +122,10 @@ module Badline
       end
 
       # The name the cartridge in the expansion port gives itself, or an
-      # empty one.
+      # empty one. A Plus/4's names the slots with a ROM in them.
       def cartridge_name
+        return @computer.cartridge_slots.map(&:upcase).join(", ") if @computer.family == :plus4
+
         cartridge = @computer.address_bus.cartridge
         cartridge.nil? ? "" : cartridge.name
       end

data/lib/badline/frontend/menu/menu_pages.rb

@@ -89,11 +89,7 @@ module Badline
 
       def vic20? = @computer.family == :vic20
 
-      # Says in the dim colour that the VIC-20 hasn't got what the page
-      # shows.
-      def note
-        @painter.text(@left, @top, "NOT ON THE VIC-20 YET", MenuTheme::DIM)
-      end
+      def plus4? = @computer.family == :plus4
 
       def draw_drive
         media = @media
@@ -128,10 +124,12 @@ module Badline
       def draw_expansion
         return info("RAM EXPANSION", RAM_NAMES.fetch(@computer.ram_configuration)) if vic20?
 
-        cartridge = @computer.address_bus.cartridge
-        info("CARTRIDGE", cartridge.nil? ? "" : cartridge.name)
+        info("CARTRIDGE", @media.cartridge_name)
         row("INSERT...", :insert_cartridge)
         row("REMOVE", :remove_cartridge)
+        return if plus4?
+
+        cartridge = @computer.address_bus.cartridge
         row("FREEZE", :freeze) if !cartridge.nil? && cartridge.freezer? && @computer.family == :c64
         return if @reu_kb.nil?
 
@@ -167,9 +165,11 @@ module Badline
         end
       end
 
-      # The C128 names its model and the mode it runs in first.
+      # The C128 names its model and the mode it runs in first, and the
+      # Plus/4 its model and RAM.
       def draw_power
         info("MACHINE", "#{@computer.model.name.upcase}, #{@computer.mode.to_s.upcase} MODE") if c128?
+        info("MACHINE", @computer.model_label) if plus4?
         row("RESET", :reset)
         row("POWER CYCLE", :power_cycle)
         skip

data/lib/badline/frontend/menu/menu_ports.rb

@@ -5,7 +5,7 @@ module Badline
     # The pause menu's PORTS page, which MenuPages draws: what each C64
     # control port has plugged in, a joystick or a pot device, and whether
     # the keys type or drive the joysticks. The VIC-20 has one port, a
-    # joystick's.
+    # joystick's, and the Plus/4 two joysticks and no pot devices.
     module MenuPorts
       PORT_DEVICES = %i[joystick mouse paddles].freeze
       PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
@@ -16,6 +16,7 @@ module Badline
 
       def draw_ports
         return draw_vic20_port if @computer.family == :vic20
+        return draw_plus4_ports if @computer.family == :plus4
 
         toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
         toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
@@ -37,6 +38,17 @@ module Badline
         info("WASD, LEFT SHIFT", "JOYSTICK")
       end
 
+      # The Plus/4's two joysticks, one for each set of keys.
+      def draw_plus4_ports
+        return unless draw_keys("PLUS/4")
+
+        row("SWAP JOYSTICKS", :swap)
+        skip
+        arrows = @controls.arrows_port
+        info("ARROWS, SPACE", "JOYSTICK #{arrows}")
+        info("WASD, LEFT SHIFT", "JOYSTICK #{3 - arrows}")
+      end
+
       # The toggle between the keyboard named and the joysticks, and
       # whether the keys drive the joysticks.
       def draw_keys(keyboard)

data/lib/badline/frontend/screen.rb

@@ -4,9 +4,10 @@ module Badline
   module Frontend
     # The visible part of the video chip's display, the crop of the
     # machine's timing, repacked for an SDL texture in XRGB8888 in the
-    # chip's palette. Spinel hands an Array of Integers to C as 64-bit
-    # words, as badline/ffi does on CRuby, so each word carries two
-    # neighbouring pixels, the left one in the low half.
+    # chip's palette, of 16 colours or the TED's 128. Spinel hands an Array
+    # of Integers to C as 64-bit words, as badline/ffi does on CRuby, so
+    # each word carries two neighbouring pixels, the left one in the low
+    # half.
     #
     # Each pixel shows `pixel_width` of the window's square pixels wide,
     # or with `dots`, that many pixels share one, as the VDC's dots do. The
@@ -14,18 +15,21 @@ module Badline
     # least MIN_WIDTH window pixels wide, and at least as high as PAL's C64
     # crop, 272 lines, so a C64 shows in the same window whatever its
     # region. A crop with fewer lines or pixels sits in the middle of the
-    # texture, between black bands. The VIC-20's 284 by 284 crop fills its
-    # own.
+    # texture, between black bands. The VIC-20's 284 by 284 crop and the
+    # TED's 384 by 288 fill their own.
+    #
+    # With `frame_lines`, the crop's lines run on past the frame's last
+    # line to its first, as the TED's do: its top border is the end of
+    # the frame.
     class Screen
       MIN_WIDTH = Region::PAL.crop[2]
       MIN_HEIGHT = Region::PAL.crop[3]
 
       attr_reader :pixels, :width, :height
 
-      def initialize(video, crop, pixel_width: 1, dots: 1)
+      def initialize(video, crop, pixel_width: 1, dots: 1, frame_lines: 0)
         @video = video
         @col_offset = crop[0]
-        @row_offset = crop[1]
         @lines = crop[3]
         @columns = crop[2] & ~1
         @pixel_width = pixel_width
@@ -37,8 +41,10 @@ module Badline
         @pair_count = @columns / 2
         @margin = (@row_words - @pair_count) / 2
         @band = (@height - @lines) / 2
-        palette = video.palette
-        @pairs = Array.new(256) { |pair| palette[pair & 0x0f] | (palette[pair >> 4] << 32) }
+        top = crop[1]
+        wrap = frame_lines.zero? ? top + @lines : frame_lines
+        @sources = Array.new(@lines) { |row| (row + top) % wrap }
+        pair_up(video.palette)
         @pixels = Array.new(@height * @row_words, 0)
         pack_all
       end
@@ -54,9 +60,10 @@ module Badline
         video = @video
         dirty = video.dirty_lines
         display = video.display
+        sources = @sources
         row = 0
         while row < @lines
-          pack_row(display, row) if dirty[row + @row_offset]
+          pack_row(display, row) if dirty[sources[row]]
           row += 1
         end
         video.clear_dirty_lines!
@@ -64,6 +71,18 @@ module Badline
 
       private
 
+      # The packed word for each pair of palette indices, the left one in
+      # the low bits.
+      def pair_up(palette)
+        colors = palette.size
+        shift = 4
+        shift += 1 while (1 << shift) < colors
+        mask = colors - 1
+        @shift = shift
+        @mask = mask
+        @pairs = Array.new(colors << shift) { |pair| palette[pair & mask] | (palette[(pair >> shift) & mask] << 32) }
+      end
+
       # Repacks every line, as a screen built for a display the chip has
       # already drawn starts with all of it.
       def pack_all
@@ -78,11 +97,13 @@ module Badline
       def pack_row(display, row)
         pixels = @pixels
         pairs = @pairs
-        from = ((row + @row_offset) * @stride) + @col_offset
+        mask = @mask
+        shift = @shift
+        from = (@sources[row] * @stride) + @col_offset
         to = ((row + @band) * @row_words) + @margin
         last = to + @pair_count
         while to < last
-          pixels[to] = pairs[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
+          pixels[to] = pairs[(display[from] & mask) | ((display[from + 1] & mask) << shift)]
           from += 2
           to += 1
         end

data/lib/badline/frontend/screens.rb

@@ -70,7 +70,8 @@ module Badline
           @screen = Screen.new(vdc, vdc.crop, dots: 2)
         else
           timing = @computer.timing
-          @screen = Screen.new(@computer.video, timing.crop, pixel_width: timing.pixel_width)
+          @screen = Screen.new(@computer.video, timing.crop,
+                               pixel_width: timing.pixel_width, frame_lines: timing.lines_per_frame)
         end
       end
 

data/lib/badline/frontend/snapshots.rb

@@ -20,6 +20,7 @@ module Badline
       def initialize(computer, options)
         @computer = computer
         @at_finish = options.save_snapshot
+        @vice = options.vice?
         @autosave = options.frames.zero?
         @autosave_at = AUTOSAVE_FRAMES
       end
@@ -128,11 +129,21 @@ module Badline
       end
 
       def finish
-        save(@at_finish) unless @at_finish.empty?
+        return if @at_finish.empty?
+
+        @vice ? export(@at_finish) : save(@at_finish)
       end
 
       private
 
+      # Saves the machine with VICE's modules too, and warns when it can't.
+      def export(path)
+        @computer.export_snapshot(path)
+        puts "Saved #{path} for badline and VICE"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
       def restore_from(path)
         @computer = Snapshot.load(path) { |line| puts line }
         puts "Restored #{name_of(path)} from #{path}"

data/lib/badline/frontend/sound.rb

@@ -2,9 +2,9 @@
 
 module Badline
   module Frontend
-    # The machine's sound source, the C64's SID or the VIC-20's VIC, on
-    # SDL's audio queue, as mono signed 16-bit samples. Both take
-    # #record(rate:, clock_hz:) and #drain_samples.
+    # The machine's sound source, the C64's SID, the VIC-20's VIC or the
+    # Plus/4's TED, on SDL's audio queue, as mono signed 16-bit samples.
+    # Each takes #record(rate:, clock_hz:) and #drain_samples.
     # Once the device plays, it is the clock: #wait holds each frame until
     # the queue is down to `AHEAD`, so the machine runs at the device's pace.
     #
@@ -16,7 +16,7 @@ module Badline
     #
     # Each frame's samples go to a mono AudioDevice. The chip's cycles are
     # converted at `clock_hz`, the machine's clock, so an NTSC or Drean
-    # machine plays at its own pitch.
+    # machine plays at its own pitch, and the TED's at its single clock.
     class Sound
       RATE = 44_100
       AHEAD = 0.08

data/lib/badline/frontend/timeline.rb

@@ -21,10 +21,13 @@ module Badline
         @failed = false
       end
 
-      # What's wrong with the events, the first key or menu page that
-      # names nothing, or an empty string.
-      def self.error(events)
-        event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument) }
+      # The C128's two locking keys, outside its matrix.
+      LOCKS = %w[caps_lock forty_eighty].freeze
+
+      # What's wrong with the events for the family's machine, the first
+      # key or menu page that names nothing, or an empty string.
+      def self.error(events, family)
+        event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument, family) }
         return "no such key: #{event.argument}" unless event.nil?
 
         event = events.find { |candidate| candidate.action == "menu" && !page?(candidate.argument) }
@@ -35,12 +38,30 @@ module Badline
       # sound. An empty one is its first.
       def self.page?(name) = name.empty? || PauseMenu::PAGES.any? { |page| page.to_s == name }
 
-      def self.key?(name) = name == "restore" || !keyboard_key(name).nil? || !joystick_direction(name).nil?
+      # Whether the family's machine has a key of the name. The Plus/4 has
+      # no RESTORE.
+      def self.key?(name, family)
+        (name == "restore" && family != :plus4) || (family == :c128 && LOCKS.include?(name)) ||
+          !keyboard_key(name, family).nil? || !joystick_direction(name).nil?
+      end
+
+      # The family's Keyboard key for a name such as space, return or a,
+      # on the C128 esc or keypad1, or on the Plus/4 help or crsr_up. The
+      # shifted cursor keys, such as cursor_up, are the C64's and the
+      # C128's.
+      def self.keyboard_key(name, family)
+        key = keyboard_matrix(family).flatten.find { |candidate| candidate.to_s == name }
+        return key unless key.nil? && family != :plus4
+
+        Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name }
+      end
 
-      # The Keyboard's key for a name such as space, return or a.
-      def self.keyboard_key(name)
-        key = Input::Keyboard.new.matrix.flatten.find { |candidate| candidate.to_s == name }
-        key.nil? ? Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name } : key
+      def self.keyboard_matrix(family)
+        case family
+        when :c128 then C128::KEYBOARD_MATRIX
+        when :plus4 then Plus4::KeyboardPort::MATRIX
+        else Input::Keyboard::C64_MATRIX
+        end
       end
 
       # The direction of joy1-NAME or joy2-NAME, such as up or fire.
@@ -130,6 +151,8 @@ module Badline
 
       def press(computer, event)
         name = event.argument
+        return lock(computer, name) if LOCKS.include?(name)
+
         if name == "restore"
           computer.press_restore
           return hold(event)
@@ -137,13 +160,21 @@ module Badline
 
         direction = Timeline.joystick_direction(name)
         if direction.nil?
-          computer.keyboard.press(Timeline.keyboard_key(name))
+          computer.keyboard.press(Timeline.keyboard_key(name, computer.family))
         else
           joystick(computer, name).press(direction)
         end
         hold(event)
       end
 
+      # CAPS LOCK and 40/80 DISPLAY lock: a push puts one down if it was up,
+      # and up if it was down.
+      def lock(computer, name)
+        return unless computer.family == :c128
+
+        name == "caps_lock" ? computer.push_caps_lock : computer.push_display_key
+      end
+
       # The VIC-20 and the C128 have no cartridge with a button yet.
       def freeze(computer, event)
         return unless computer.family == :c64
@@ -164,7 +195,7 @@ module Badline
 
         direction = Timeline.joystick_direction(name)
         if direction.nil?
-          computer.keyboard.release(Timeline.keyboard_key(name))
+          computer.keyboard.release(Timeline.keyboard_key(name, computer.family))
         else
           joystick(computer, name).release(direction)
         end
@@ -197,7 +228,7 @@ module Badline
 
       def inserted?(computer, what)
         return !computer.datasette.tape.nil? if what == "tape"
-        return !computer.address_bus.cartridge.nil? if what == "cartridge"
+        return MediaSlots.cartridge?(computer) if what == "cartridge"
 
         MediaSlots.disk?(computer)
       end

data/lib/badline/input/matrix_typist.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Badline
+  module Input
+    # Types PETSCII codes on a Keyboard's matrix, one key at a time, for
+    # software that scans the keys itself instead of reading a KERNAL's
+    # keyboard buffer: each code's keys go down for HOLD cycles, then up for
+    # GAP cycles. Codes it has no key for are skipped.
+    class MatrixTypist
+      HOLD = 100_000
+      GAP = 40_000
+
+      # The keys typed without SHIFT, by PETSCII code.
+      PLAIN = {
+        0x0d => :return, 0x20 => :space, 0x2a => :*, 0x2b => :+, 0x2c => :",", 0x2d => :-, 0x2e => :".",
+        0x2f => :/, 0x3a => :":", 0x3b => :";", 0x3d => :"=", 0x40 => :"@"
+      }.freeze
+
+      # The keys typed with SHIFT, by PETSCII code.
+      SHIFTED = {
+        0x21 => :"1", 0x22 => :"2", 0x23 => :"3", 0x24 => :"4", 0x25 => :"5", 0x26 => :"6", 0x27 => :"7",
+        0x28 => :"8", 0x29 => :"9", 0x3c => :",", 0x3e => :".", 0x3f => :/, 0x5b => :":", 0x5d => :";"
+      }.freeze
+
+      DIGITS = %i[0 1 2 3 4 5 6 7 8 9].freeze
+      LETTERS = %i[a b c d e f g h i j k l m n o p q r s t u v w x y z].freeze
+
+      # The keys that type the PETSCII code, SHIFT first, or none.
+      def self.keys(code)
+        return [DIGITS[code - 0x30]] if code.between?(0x30, 0x39)
+        return [LETTERS[code - 0x41]] if code.between?(0x41, 0x5a)
+        return [:lshift, LETTERS[code - 0xc1]] if code.between?(0xc1, 0xda)
+        return [PLAIN[code]] if PLAIN.key?(code)
+        return [:lshift, SHIFTED[code]] if SHIFTED.key?(code)
+
+        []
+      end
+
+      def initialize(keyboard)
+        @keyboard = keyboard
+        @held = []
+        @code = 0
+        @wait = 0
+        @typing = false
+      end
+
+      # Whether it is part way through codes: from the first key down until
+      # the last one is up and its gap has passed.
+      def typing? = @typing
+
+      # A cycle of typing +codes+, taking each code off its front as its keys
+      # go down.
+      def cycle!(codes)
+        @wait -= 1 if @wait.positive?
+        return unless @wait.zero?
+
+        if @held.empty?
+          press(codes)
+        else
+          @held.each { |key| @keyboard.release(key) }
+          @held = []
+          @wait = GAP
+        end
+      end
+
+      # Where it is in its typing, in a keyed snapshot module under `prefix`:
+      # the code whose keys are down, if any, the cycles left before they
+      # go up or the next code's go down, and whether it is part way
+      # through. The keys go down again on load.
+      def save_fields(out, prefix)
+        out.optional_int("#{prefix}code", @held.empty? ? nil : @code)
+        out.int("#{prefix}wait", @wait).bool("#{prefix}typing", @typing)
+      end
+
+      def load_fields(input, prefix)
+        @held.each { |key| @keyboard.release(key) }
+        code = input.optional_int("#{prefix}code")
+        @code = code || 0
+        @held = code.nil? ? [] : MatrixTypist.keys(code)
+        @held.each { |key| @keyboard.press(key) }
+        @wait = input.int("#{prefix}wait", @wait)
+        @typing = input.bool("#{prefix}typing", @typing)
+      end
+
+      private
+
+      def press(codes)
+        @typing = !codes.empty?
+        return unless @typing
+
+        @code = codes.shift
+        @held = MatrixTypist.keys(@code)
+        @held.each { |key| @keyboard.press(key) }
+        @wait = @held.empty? ? 1 : HOLD
+      end
+    end
+  end
+end

data/lib/badline/input.rb

@@ -5,3 +5,4 @@ require "badline/input/joystick"
 require "badline/input/control_ports"
 require "badline/input/mouse1351"
 require "badline/input/paddles"
+require "badline/input/matrix_typist"

data/lib/badline/kernal_trap/chrout.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # Observe-only PC trap on the KERNAL CHROUT routine ($FFD2). Records each
+    # character written while the layout finds the KERNAL mapped in, then lets execution fall
+    # through to the ROM, so the screen output is unaffected. Used for headless
+    # capture of program output.
+    class Chrout
+      ADDRESS = 0xffd2
+
+      attr_reader :output
+
+      # The KERNAL layout whose mapping the trap checks.
+      attr_writer :layout
+
+      def initialize(cpu:, bus:, layout:)
+        @cpu = cpu
+        @bus = bus
+        @layout = layout
+        @output = +""
+      end
+
+      def call
+        @output << ascii(@cpu.a) if @layout.kernal_mapped?(@bus)
+      end
+
+      def inspect
+        "#<#{self.class.name} output=#{@output.inspect}>"
+      end
+
+      private
+
+      def ascii(byte)
+        case byte
+        when 0x0d then "\n"
+        when 0x41..0x5a then (byte + 0x20).chr
+        when 0xc1..0xda then (byte - 0x80).chr
+        when 0x20..0x7e then byte.chr
+        else ""
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/dos/channel.rb

@@ -81,33 +81,6 @@ module Badline
           data ? new(data) : new([], error: [ILLEGAL_TRACK_OR_SECTOR, track, sector])
         end
 
-        # Reads what save_state wrote after the flag that marks a file open
-        # for writing (Channels.channel_from_state). A buffer channel
-        # takes its block in `ram`, the drive's RAM, again.
-        def self.from_state(input, ram)
-          new.tap { |channel| channel.load_state(input, ram) }
-        end
-
-        # A buffer channel's bytes are the drive's RAM, which the drive
-        # writes itself.
-        def save_state(out)
-          out.boolean(false).boolean(@writable).int(@base).int(@length).int(@pointer)
-          out.optional_int(@lead).optional_int(@buffer).boolean(!@error.nil?)
-          out.ints(@error) if @error
-          out.blob(@bytes) unless @writable
-        end
-
-        def load_state(input, ram)
-          @writable = input.boolean?
-          @base = input.int
-          @length = input.int
-          @pointer = input.int
-          @lead = input.optional_int
-          @buffer = input.optional_int
-          @error = input.boolean? ? input.ints : nil
-          @bytes = @writable ? ram : input.blob
-        end
-
         def replace(bytes, length = bytes.length)
           @bytes = bytes
           rewind(length)

data/lib/badline/kernal_trap/dos/channels.rb

@@ -22,31 +22,6 @@ module Badline
 
         def clear = @channels.clear
 
-        # Each open channel with its secondary address, in the order they
-        # opened.
-        def save_state(out)
-          out.int(@channels.length)
-          @channels.each do |secondary, channel|
-            out.int(secondary)
-            channel.save_state(out)
-          end
-        end
-
-        # Buffer channels take their block in the drive's RAM again.
-        def load_state(input, memory)
-          @channels.clear
-          input.int.times do
-            secondary = input.int
-            @channels[secondary] = Channels.channel_from_state(input, memory.ram)
-          end
-        end
-
-        # A channel save_state wrote: a file open for writing, or a Channel
-        # whose buffer, if it has one, is in `ram`.
-        def self.channel_from_state(input, ram)
-          input.boolean? ? WriteFile.from_state(input) : Channel.from_state(input, ram)
-        end
-
         # Opens a buffer channel on the buffer a "#n" name asks for, or on
         # the highest free one. Returns nil when that buffer isn't free,
         # which leaves a channel asking again for its own buffer open.

data/lib/badline/kernal_trap/dos/memory.rb

@@ -62,15 +62,6 @@ module Badline
           load_buffer(Channels::BAM_BUFFER, block) if block
         end
 
-        def save_state(out)
-          out.blob(@ram).boolean(@bam)
-        end
-
-        def load_state(input)
-          input.blob_into(@ram)
-          @bam = input.boolean?
-        end
-
         # Whether the BAM has been read since the last reset.
         def bam? = @bam
 

data/lib/badline/kernal_trap/dos/status.rb

@@ -37,14 +37,6 @@ module Badline
           nil
         end
 
-        def save_state(out)
-          @channel.save_state(out)
-        end
-
-        def load_state(input)
-          @channel = Channels.channel_from_state(input, [])
-        end
-
         def replace(bytes)
           @channel.replace(bytes)
         end

data/lib/badline/kernal_trap/dos/write_file.rb

@@ -14,14 +14,6 @@ module Badline
         TYPES = %i[del seq prg usr rel].freeze
         MODES = %i[write replace append].freeze
 
-        # Reads what save_state wrote after the flag that marks a file
-        # open for writing.
-        def self.from_state(input)
-          name = input.string
-          type = TYPES.fetch(input.int).to_sym
-          new(name, type, mode: MODES.fetch(input.int).to_sym).tap { |file| file.load_state(input) }
-        end
-
         def initialize(name, type, mode: :write)
           @name = name
           @type = type
@@ -29,16 +21,6 @@ module Badline
           @bytes = []
         end
 
-        def save_state(out)
-          out.boolean(true).string(@name).int(TYPES.index(@type)).int(MODES.index(@mode))
-          out.blob(@bytes).optional_int(@buffer)
-        end
-
-        def load_state(input)
-          @bytes = input.blob
-          @buffer = input.optional_int
-        end
-
         def write(bytes) = @bytes.concat(bytes)
 
         def writable? = true