badline 0.2.1 → 0.4.0

data/lib/badline/kernal_trap/drive.rb

@@ -1,22 +1,35 @@
 # frozen_string_literal: true
 
+require "badline/kernal_trap/drive/block_commands"
+require "badline/kernal_trap/drive/channels"
+require "badline/kernal_trap/drive/memory"
+require "badline/kernal_trap/drive/parameters"
 require "badline/kernal_trap/drive/status"
+require "badline/kernal_trap/drive/writes"
+require "badline/kernal_trap/drive/write_file"
 
 module Badline
   module KernalTrap
     # The CBM DOS side of the serial bus. Keeps the open channels, the
     # command channel and its status message. `U1` reads a raw block into a
     # buffer channel, which is how block-access loaders bypass the KERNAL's
-    # LOAD.
+    # LOAD. A disk image whose host file takes writes takes files, blocks
+    # and BAM changes too. Other disks are write-protected, though storage
+    # that can write files still takes a SAVE handed over whole.
     class Drive
+      include BlockCommands
+      include Writes
+
       COMMAND_CHANNEL = 15
       BLOCK_SIZE = 256
 
       OK = 0
+      FILES_SCRATCHED = 1
       WRITE_PROTECT_ON = 26
       SYNTAX_ERROR = 30
       FILE_NOT_FOUND = 62
       FILE_EXISTS = 63
+      NO_BLOCK = 65
       ILLEGAL_TRACK_OR_SECTOR = 66
       NO_CHANNEL = 70
       DOS_VERSION = 73
@@ -24,17 +37,6 @@ module Badline
 
       MEMORY_COMMANDS = { "M-W" => :memory_write, "M-R" => :memory_read }.freeze
 
-      RAM_SIZE = 0x800
-
-      # The job queue: a job code for each of five buffers at $00, their
-      # track and sector pairs from $06, and the buffers from $0300. A job
-      # code is replaced by its result, 1 for success or an error table
-      # code: the DOS error less 18, or 15 for DRIVE NOT READY.
-      JOBS = 5
-      READ_JOB = 0x80
-      JOB_OK = 1
-      HEADER_NOT_FOUND = 20
-
       # A U command jumps through the user table at $FFEA, indexed by the
       # low nibble of its second character less one, so UA and UQ are U1.
       # U1 and U2 read and write a block. U3 to U8 run code in the buffer
@@ -44,7 +46,7 @@ module Badline
       # IRQ one, which restart the DOS with its RAM intact, except that a
       # + or - after U9 only switches the bus speed. U: takes the reset
       # vector, which runs the RAM test. U0 restores the table.
-      USER_TABLE = [:block_read, :write_protected, *[:initialized] * 6,
+      USER_TABLE = [:block_read, :block_write, *[:initialized] * 6,
                     :warm_reset, :cold_reset, :warm_reset, *[:initialized] * 5].freeze
 
       COMMANDS = {
@@ -52,50 +54,95 @@ module Badline
         /\AU.\s*:?\s*(.*)/i => :user,
         /\AB-R\s*:?\s*(.*)/i => :counted_block_read,
         /\AB-P\s*:?\s*(.*)/i => :buffer_pointer,
-        /\A[IV]/i => :initialized,
-        /\AB-[WAF]/i => :write_protected
+        /\AB-W\s*:?\s*(.*)/i => :counted_block_write,
+        /\AI/i => :initialize_disk,
+        /\AV/i => :initialized,
+        /\AB-A\s*:?\s*(.*)/i => :block_allocate,
+        /\AB-F\s*:?\s*(.*)/i => :block_free,
+        /\AS[^:]*:(.*)/im => :scratch
       }.freeze
 
-      # A drive powers on reporting its DOS version, as a reset does.
-      def initialize(storage)
-        @storage = storage
-        @channels = {}
+      # Commands that take their argument as text rather than numbers.
+      TEXT_COMMANDS = %i[scratch].freeze
+
+      # A drive powers on reporting its DOS version, as a reset does. It
+      # can take the RAM of a drive it replaces, and initializes its disk.
+      def initialize(storage, memory = Memory.new)
+        @channels = Channels.new
         @status = Status.new
-        @ram = Array.new(RAM_SIZE, 0)
+        @memory = memory
+        insert(storage)
         report(DOS_VERSION)
       end
 
+      # Changes the disk. The drive keeps its RAM and its status, closes
+      # its channels, and initializes the new disk.
+      def insert(storage)
+        @storage = storage
+        @channels.clear
+        @memory.storage = storage
+        @memory.read_bam
+      end
+
+      # Whether the disk takes a SAVE handed over whole.
+      def saves? = @storage.respond_to?(:write_file)
+
       # A name on the command channel is a command, "#" opens a block
       # buffer, anything else opens a file for reading. The name comes as
       # the bytes sent, because a memory command's arguments are binary.
+      # Opening a data channel initializes a disk a reset left uninitialized.
       def open(secondary, name)
+        @memory.read_bam unless @memory.bam? || secondary == COMMAND_CHANNEL
         if secondary == COMMAND_CHANNEL
           command(name.bytes) unless name.empty?
         elsif name.start_with?("#")
-          @channels[secondary] = Channel.new(Array.new(BLOCK_SIZE, 0))
-          report(OK)
+          opened = @channels.open_buffer(secondary, Parameters.parse(name[1..]).first, @memory)
+          report(opened ? OK : NO_CHANNEL)
         else
-          open_file(secondary, Storage.ascii(name.bytes))
+          open_file(secondary, Storage.ascii(without_return(name.bytes)))
         end
       end
 
-      # Closing the command channel closes every other channel with it.
+      # Closing the command channel closes every other channel with it,
+      # and a file open for writing is lost. Closing a file open for
+      # writing writes it to the disk.
       def close(secondary)
-        secondary == COMMAND_CHANNEL ? @channels.clear : @channels.delete(secondary)
+        return @channels.clear if secondary == COMMAND_CHANNEL
+
+        channel = @channels.close(secondary)
+        writing { channel.store(@storage) } if channel.is_a?(WriteFile)
       end
 
+      # A buffer channel takes the bytes into its block, and a file open for
+      # writing gathers them. A file open for reading fails as a
+      # write-protected disk does.
       def write(secondary, bytes)
         return command(bytes) if secondary == COMMAND_CHANNEL
 
-        report(WRITE_PROTECT_ON) if listening?(secondary)
+        channel = @channels[secondary]
+        return unless channel
+
+        channel.writable? ? channel.write(bytes) : report(WRITE_PROTECT_ON)
+      end
+
+      # A SAVE the trap hands over whole, to storage that can write files.
+      # A disk image refuses a name it already has unless `replace` asks to
+      # write over it, and a write the host refuses fails as a
+      # write-protected disk does. Returns whether the file was written.
+      def save(name, bytes, replace: false)
+        writing { @storage.write_file(name, bytes, type: :prg, replace:) }
       end
 
       # Whether data sent on the channel reaches the drive. The command
       # channel always listens, other channels once they are open.
       def listening?(secondary)
-        secondary == COMMAND_CHANNEL || @channels.key?(secondary)
+        secondary == COMMAND_CHANNEL || @channels.open?(secondary)
       end
 
+      # The serial bus's RESET line restarts the DOS through its reset
+      # vector, as U: does.
+      def reset! = reset(cold: true)
+
       # Returns the next byte and whether it is the channel's last, or nil
       # when there is nothing left to send.
       def read(secondary)
@@ -109,39 +156,30 @@ module Badline
 
       private
 
+      # The DOS cuts a name of two or more bytes at a carriage return in
+      # its last or second-to-last byte, as PRINT# ends a line with one.
+      def without_return(bytes)
+        cut = bytes.rindex(0x0d)
+        cut && bytes.length > 1 && cut >= bytes.length - 2 ? bytes[0, cut] : bytes
+      end
+
       # Secondary addresses 0 and 1 are LOAD and SAVE, which look for a PRG
       # file unless the name asks for another type. Other channels take any
-      # type the name doesn't pin down.
+      # type the name doesn't pin down, and write a SEQ file.
       def open_file(secondary, name)
         file, type = Storage.parse_name(name)
-        return refuse_write(secondary, name, file) if writing?(secondary, name)
-
         type ||= :prg if secondary < 2
-        channel = @channels[secondary] = Channel.for_file(@storage, file, type)
-        channel.exhausted? && channel.error ? report(*channel.error) : report(OK)
-      end
+        return open_write(secondary, name, file, type) if secondary == 1 || mode?(name, "W")
+        return open_append(secondary, file, type) if mode?(name, "A")
 
-      # SAVE's secondary address 1 and a W mode open a file for writing.
-      def writing?(secondary, name)
-        secondary == 1 || name.split(",").drop(1).any? { |field| field.strip.match?(/\AW/i) }
-      end
+        channel = @channels.open_file(secondary, Channel.for_name(@storage, @memory, secondary, name, type))
+        return report(NO_CHANNEL) unless channel
 
-      # The disk is write-protected, so an open for writing fails and leaves
-      # the channel closed. A name already on the disk fails as FILE EXISTS
-      # unless @ asks to replace it, anything else as WRITE PROTECT ON.
-      def refuse_write(secondary, name, file)
-        @channels.delete(secondary)
-        return report(FILE_EXISTS) if !name.start_with?("@") && @storage.read_file(file, type: nil)
-
-        report(WRITE_PROTECT_ON, *protected_block(secondary))
+        channel.failed? ? report(*channel.error) : report(OK)
       end
 
-      # SAVE's channel fails at the directory block its entry would go to,
-      # a W mode open at the disk's header block.
-      def protected_block(secondary)
-        return [] unless @storage.respond_to?(:header_block)
-
-        secondary == 1 ? @storage.new_entry_block : @storage.header_block
+      def mode?(name, mode)
+        name.split(",").drop(1).any? { |field| field.strip[0]&.upcase == mode }
       end
 
       def execute(text)
@@ -150,11 +188,8 @@ module Badline
         return report(SYNTAX_ERROR) unless action
 
         action = USER_TABLE[(command.getbyte(1) - 1) & 0x0f] if action == :user
-        run_command(action, arguments(pattern.match(command)[1]))
-      end
-
-      def arguments(text)
-        text.to_s.scan(/\d+/).map(&:to_i)
+        argument = pattern.match(command)[1]
+        run_command(action, TEXT_COMMANDS.include?(action) ? argument : Parameters.parse(argument))
       end
 
       def command(bytes)
@@ -165,10 +200,15 @@ module Badline
       def run_command(action, arguments)
         case action
         when :block_read then block_read(arguments)
+        when :block_write then block_write(arguments)
+        when :counted_block_write then counted_block_write(arguments)
         when :counted_block_read then counted_block_read(arguments)
         when :buffer_pointer then buffer_pointer(arguments)
         when :initialized then report(OK)
-        when :write_protected then write_protected(arguments)
+        when :initialize_disk then initialize_disk
+        when :block_allocate then block_allocate(arguments)
+        when :block_free then block_free(arguments)
+        when :scratch then scratch(arguments)
         when :cold_reset then reset(cold: true)
         when :warm_reset then reset(cold: false)
         when :memory_write then memory_write(arguments)
@@ -176,61 +216,19 @@ module Badline
         end
       end
 
-      def block_read(arguments, counted: false)
-        channel, _drive, track, sector = arguments
-        buffer = @channels[channel]
-        return report(NO_CHANNEL) unless buffer
-        return report(DRIVE_NOT_READY) unless @storage.respond_to?(:read_block)
-
-        data = sector && @storage.read_block(track, sector)
-        return report(ILLEGAL_TRACK_OR_SECTOR, track, sector) unless data
-
-        buffer.replace(counted ? data[0, data[0] + 1] : data)
-        buffer.pointer = 1 if counted
-        report_block_error(track, sector)
-      end
-
-      # A block the image's error table marks bad still fills the buffer,
-      # but the read reports its error, which copy protection checks for.
-      def report_block_error(track, sector)
-        error = @storage.block_error(track, sector)
-        error ? report(error, track, sector) : report(OK)
-      end
-
-      # B-R takes the block's first byte as the index of its last one, and
-      # hands out the bytes from the second up to there.
-      def counted_block_read(arguments)
-        block_read(arguments, counted: true)
-      end
-
-      def buffer_pointer(arguments)
-        channel, position = arguments
-        buffer = @channels[channel]
-        return report(NO_CHANNEL) unless buffer
-
-        buffer.pointer = position.to_i
-        report(OK)
-      end
-
-      # M-W takes an address, a count and that many bytes. Writes past the
-      # RAM are dropped, since the rest of the address space is I/O and ROM.
+      # M-W takes an address, a count and that many bytes.
       def memory_write(arguments)
-        address = word(arguments)
-        arguments[3, arguments[2].to_i].to_a.each.with_index(address) do |byte, target|
-          @ram[target] = byte if target < RAM_SIZE
-        end
-        run_jobs
+        @memory.write(word(arguments), arguments[3, arguments[2].to_i].to_a)
         report(OK)
       end
 
       # M-R takes an address and a count, and answers on the command
       # channel. Without a count, or with only the carriage return PRINT#
-      # ends a line with, it reads one byte. Only the RAM reads back.
+      # ends a line with, it reads one byte.
       def memory_read(arguments)
-        address = word(arguments)
         count = arguments[2..] == ["\r".ord] ? 1 : arguments.fetch(2, 1)
         count = BLOCK_SIZE if count.zero?
-        @status.replace(Array.new(count) { |i| @ram.fetch(address + i, 0) })
+        @status.replace(@memory.read(word(arguments), count))
         nil
       end
 
@@ -238,39 +236,19 @@ module Badline
         arguments[0].to_i | (arguments[1].to_i << 8)
       end
 
-      def run_jobs
-        JOBS.times do |job|
-          next unless @ram[job] == READ_JOB
-
-          track, sector = @ram[6 + (job * 2), 2]
-          @ram[job] = read_job(0x300 + (job * BLOCK_SIZE), track, sector)
-        end
-      end
-
-      def read_job(buffer, track, sector)
-        data = @storage.respond_to?(:read_block) && @storage.read_block(track, sector)
-        return job_result(HEADER_NOT_FOUND) unless data
-
-        @ram[buffer, BLOCK_SIZE] = data
-        job_result(@storage.block_error(track, sector))
-      end
-
-      def job_result(error)
-        return JOB_OK unless error
-
-        error == DRIVE_NOT_READY ? 15 : error - 18
-      end
-
-      def write_protected(_arguments)
-        report(WRITE_PROTECT_ON)
-      end
-
       def reset(cold:)
-        @ram.fill(0) if cold
+        @memory.clear if cold
         @channels.clear
         report(DOS_VERSION)
       end
 
+      # I closes the data channels and reads the BAM again.
+      def initialize_disk
+        @channels.clear
+        @memory.read_bam
+        report(OK)
+      end
+
       def report(...) = @status.report(...)
     end
   end

data/lib/badline/kernal_trap/file.rb

@@ -3,31 +3,23 @@
 module Badline
   module KernalTrap
     class File < Routine
-      MISSING_FILENAME = 0x08
-
-      def initialize(cpu:, bus:, storage: nil)
-        super(cpu:, bus:)
-        @storage = storage
-      end
-
       private
 
       def active?
         kernal? && @bus.peek(0xba) == DEVICE
       end
 
-      # Filename pointer at $BB/$BC, length at $B7
       def filename
+        Storage.strip_drive_prefix(full_filename)
+      end
+
+      # Filename pointer at $BB/$BC, length at $B7
+      def full_filename
         pointer = uint16(@bus.peek(0xbb), @bus.peek(0xbc))
         bytes = Array.new(@bus.peek(0xb7)) do |i|
           @bus.peek((pointer + i) & 0xffff)
         end
-        Storage.strip_drive_prefix(Storage.ascii(bytes))
-      end
-
-      def error(code)
-        @cpu.a = code
-        @cpu.status.carry = true
+        Storage.ascii(bytes)
       end
     end
   end

data/lib/badline/kernal_trap/load.rb

@@ -30,6 +30,11 @@ module Badline
       VERIFY_MISMATCH = 0x10
       READ_TIMEOUT = 0x02
 
+      # The ROM opens the file with secondary address $60 and leaves it in
+      # $B9, so a second LOAD without a SETLFS loads to the file's own
+      # address even when the first one relocated.
+      LOAD_SECONDARY = 0x60
+
       def initialize(cpu:, bus:, drive:)
         super(cpu:, bus:)
         @drive = drive
@@ -80,6 +85,7 @@ module Badline
           @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
           continue_with(SEARCHING_MESSAGE, LOADING_MESSAGE, complete ? LOAD_DONE : BYTE_LOOP)
         end
+        @bus.poke(0xb9, LOAD_SECONDARY)
       end
 
       def low_memory?(data)

data/lib/badline/kernal_trap/save.rb

@@ -3,14 +3,17 @@
 module Badline
   module KernalTrap
     # PC trap on the KERNAL serial SAVE routine ($F5ED, the default ISAVE
-    # vector target). Writes device 8 saves to a storage backend as a PRG
+    # vector target). Hands device 8 saves to the virtual drive as a PRG
     # (load address followed by the memory range); other devices fall
-    # through to the ROM. The ROM prints SAVING in direct mode and returns
+    # through to the ROM, and so do saves to a disk that doesn't take them
+    # whole. The ROM prints SAVING in direct mode and returns
     # into the trap, which then writes the file and leaves through the
     # ROM's own tail with the registers its UNLISTEN and return leave. A
-    # host write that fails ends the way a 1541 ends a SAVE it can't
+    # write that fails, to a full disk, a name already on it or a host file
+    # that can't be written, ends the way a 1541 ends a SAVE it can't
     # write: the drive stops listening, so ST reads DEVICE NOT PRESENT,
-    # and the ROM returns without an error.
+    # and the ROM returns without an error. A "@" before the drive prefix
+    # writes over a file of the same name.
     class Save < File
       ADDRESS = 0xf5ed
 
@@ -28,14 +31,16 @@ module Badline
       # ST bit at $90
       DEVICE_NOT_PRESENT = 0x80
 
-      def initialize(cpu:, bus:, storage:)
-        super
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
         @saving = false
       end
 
       def call
         return unless active?
         return finish if @saving
+        return unless @drive.saves?
 
         @bus.poke(0xb9, SECONDARY)
         return @cpu.program_counter = MISSING_FILE_NAME_EXIT if name.empty?
@@ -53,7 +58,8 @@ module Badline
 
       def finish
         @saving = false
-        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless @storage.write_file(name, payload)
+        saved = @drive.save(name, payload, replace: full_filename.start_with?("@"))
+        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless saved
         @bus.poke(0xac, @bus.peek(0xae))
         @bus.poke(0xad, @bus.peek(0xaf))
         @cpu.y = 0

data/lib/badline/keyboard.rb

@@ -11,6 +11,14 @@ module Badline
   class Keyboard
     include IntegerHelper
 
+    # Keys the C64 types as a combination: cursor up and cursor left are the
+    # shifted cursor keys. Pressing one holds both of its matrix keys, while
+    # a shift key held on its own stays down when it is released.
+    COMBINATIONS = {
+      cursor_up: %i[lshift cursor_v],
+      cursor_left: %i[lshift cursor_h]
+    }.freeze
+
     attr_reader :keys, :matrix
 
     def initialize
@@ -70,13 +78,21 @@ module Badline
 
     # Columns held down per row, as a bit mask of port B lines.
     def row_masks
-      @row_masks ||= matrix.map do |row|
-        row.each_with_index.sum { |key, column| keys.include?(key) ? 1 << column : 0 }
+      @row_masks ||= begin
+        pressed = held
+        matrix.map do |row|
+          row.each_with_index.sum { |key, column| pressed.include?(key) ? 1 << column : 0 }
+        end
       end
     end
 
+    # The matrix keys held down, with each combination expanded.
+    def held
+      keys.flat_map { |key| COMBINATIONS[key] || [key] }
+    end
+
     def valid_key?(key)
-      matrix.flatten.include?(key)
+      COMBINATIONS.key?(key) || matrix.flatten.include?(key)
     end
   end
 end

data/lib/badline/media.rb

@@ -14,25 +14,39 @@ module Badline
     }.freeze
 
     class << self
-      # `cartridge` sets the jumpers of a .crt cartridge that has them, such
-      # as `{ flash_jumper: true }` for the Retro Replay's flash mode.
-      def attach(computer, path, autostart: true, song: nil, cartridge: {})
+      # The options are the medium's own. `cartridge:` sets the jumpers of a
+      # .crt cartridge that has them, such as `{ flash_jumper: true }` for
+      # the Retro Replay's flash mode, and `disk: { read_only: true }` mounts
+      # a disk image write-protected, so nothing the program does writes to
+      # its file. Media they don't apply to ignore them.
+      def attach(computer, path, autostart: true, song: nil, **options)
         if File.directory?(path)
           computer.mount(Storage::HostDirectory.new(path))
           "Mounted #{path} as device 8"
         elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path, cartridge)
+          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
         elsif File.extname(path).downcase == ".sid"
           attach_sid(computer, path, autostart:, song:)
         elsif File.extname(path).downcase == ".tap"
           attach_tape(computer, path, autostart:)
-        elsif (storage = MOUNT_TYPES[File.extname(path).downcase])
-          attach_storage(computer, storage.new(path), 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
 
+      # Swaps the disk in device 8 for a disk image or a host directory,
+      # while the machine runs, without loading anything. The drive keeps
+      # its RAM and its status. `read_only` inserts a disk image
+      # write-protected.
+      def insert_disk(computer, path, read_only: false)
+        raise ArgumentError, "#{path} is not a disk image or a directory" unless disk?(path)
+
+        computer.mount(open_storage(path, { read_only: }))
+        "Inserted #{path} in device 8"
+      end
+
       # The SID a machine for `path` should be built with. A .sid tune names
       # its own; everything else gets the 6581.
       def sid_model(path)
@@ -43,6 +57,20 @@ module Badline
 
       private
 
+      def disk?(path)
+        storage = MOUNT_TYPES[File.extname(path).downcase]
+        File.directory?(path) || (!storage.nil? && storage < Storage::DiskImage)
+      end
+
+      # Disk images take the `disk` options. A .t64 is read-only whatever
+      # it's given.
+      def open_storage(path, disk)
+        return Storage::HostDirectory.new(path) if File.directory?(path)
+
+        storage = MOUNT_TYPES[File.extname(path).downcase]
+        storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
+      end
+
       def attach_cartridge(computer, path, options)
         computer.attach_cartridge(Cartridge.from_file(path, **options))
         "Attached cartridge #{path}"
@@ -59,8 +87,8 @@ module Badline
 
       def start_tune(computer, tune, autostart:, song:)
         computer.ram.write(tune.load_address, tune.data)
-        computer.ram.write(tune.driver_address, tune.driver(song:))
-        computer.type_text("sys#{tune.driver_address}\r") if autostart
+        tune.boot_memory(song:).each { |address, bytes| computer.ram.write(address, bytes) }
+        computer.type_text(tune.boot_command) if autostart
       end
 
       def attach_tape(computer, path, autostart:)
@@ -70,8 +98,8 @@ module Badline
         "Inserted #{path} in the datasette"
       end
 
-      def attach_storage(computer, storage, path, autostart:)
-        computer.mount(storage)
+      def attach_storage(computer, path, disk, autostart:)
+        computer.mount(open_storage(path, disk))
         computer.type_text(AUTOSTART) if autostart
         "Mounted #{path} as device 8"
       end
@@ -85,11 +113,14 @@ module Badline
 
       def start_prg(computer, data, autostart:)
         load_addr = computer.load_prg(data)
-        # Run only makes sense for programs at BASIC start.
-        return unless autostart && load_addr == BASIC_START
+        # Run only makes sense for programs at BASIC start, or a byte ahead
+        # of it, where BASIC keeps the zero before its first line.
+        return unless autostart && (load_addr == BASIC_START || load_addr == BASIC_START - 1)
 
+        # The end of the program, where BASIC's variables start, and where
+        # the KERNAL's LOAD leaves its end address.
         end_addr = load_addr + data.length - 2
-        computer.ram.write(0x2d, [end_addr & 0xff, end_addr >> 8])
+        [0x2d, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
         computer.type_text("run\r")
       end
     end

data/lib/badline/memory.rb

@@ -10,11 +10,11 @@ module Badline
     end
 
     def peek(addr)
-      @storage[index(addr)]
+      @storage[offset_of(addr)]
     end
 
     def poke(addr, value)
-      @storage[index(addr)] = value
+      @storage[offset_of(addr)] = value
       value
     end