Files

disk.src
disk.src
  • MAX_FILE_CONTENT = 160000 // limited by the game
  • MAX_NESTED_FOLDERS = 16 // limited by the game
  • MAX_FILES = 249 // limited by the game
  • FOLDER_PER_BLOCK = 2
  • Block = {}
  • Block.init = function(disk, folder)
  • self.disk = disk
  • self.folder = folder
  • self.name = folder.name
  • self.path = folder.path
  • self.full_path = self.path + "/" + self.name
  • self.depth = self.path.split("/").len - 1
  • self.is_at_max_depth = self.depth == MAX_NESTED_FOLDERS
  • self.is_at_max_folders = self.folder.get_folders.len == FOLDER_PER_BLOCK
  • if self.folder.get_files.len == 0 then self.new_file
  • end function
  • Block.last_file = function()
  • return self.folder.get_files[-1]
  • end function
  • Block.new_file = function()
  • blob_name = "0"
  • if self.disk.blobs.len > 0 then blob_name = str(self.disk.blobs[-1].name.to_int + 1)
  • self.disk.computer.touch(self.path, blob_name)
  • self.disk.setup_blocks
  • end function
  • Block.is_full_of_folders = function()
  • if self.is_at_max_depth then
  • return true
  • else
  • if self.is_at_max_folders then
  • for f in self.folder.get_folders
  • n_block = new Block
  • n_block.init(self.disk, f)
  • if n_block.is_full_of_folders == false then return false
  • end for
  • return true
  • end if
  • return false
  • end if
  • end function
  • Disk = {}
  • Disk.init = function(data_folder_path = null, data_folder_name = ".disk")
  • self.shell = get_shell
  • self.computer = self.shell.host_computer
  • self.data_folder_path = data_folder_path
  • if self.data_folder_path == null then self.data_folder_path = home_dir
  • self.data_folder_name = data_folder_name
  • self.data_folder_full_path = self.data_folder_path + "/" + self.data_folder_name
  • self.computer.create_folder(self.data_folder_path, self.data_folder_name)
  • self.data_folder = self.computer.File(self.data_folder_full_path)
  • self.setup_blocks
  • // there is a bug in setup_blocks that when new_block.init creates a new file it will add it twice to blobs
  • // list so im calling this shit again :) instead of fixing it
  • self.setup_blocks
  • self.tape = ""
  • end function
  • Disk.setup_blocks = function()
  • self.blocks = []
  • self.blobs = []
  • self.computer.create_folder(self.data_folder_full_path, "blocks")
  • first_block_folder = self.computer.File(self.data_folder_full_path + "/blocks")
  • new_block = new Block
  • new_block.init(self, first_block_folder)
  • self.load_blocks(new_block)
  • end function
  • // this wont check for blocks already loaded and will load them again
  • Disk.load_blocks = function(block)
  • self.blocks.push(block)
  • for f in block.folder.get_files
  • self.blobs.push(f)
  • end for
  • for f in block.folder.get_folders
  • new_block = new Block
  • new_block.init(self, f)
  • self.load_blocks(new_block)
  • end for
  • end function
  • Disk.create_new_block = function(block = null)
  • if block == null then block = self.blocks[0]
  • count = self.blocks[-1].name.to_int + 1
  • if self.blocks[-1].name == "blocks" then count = 1
  • if block.folder.get_folders.len == 0 then
  • self.computer.create_folder(block.path, str(count))
  • self.setup_blocks
  • return 1
  • else
  • for f in block.folder.get_folders
  • n_block = new Block
  • n_block.init(block.disk, f)
  • if n_block.is_full_of_folders then continue
  • self.create_new_block(n_block)
  • self.setup_blocks
  • return 1
  • end for
  • self.computer.create_folder(block.path, str(count))
  • self.setup_blocks
  • return 1
  • end if
  • end function
  • Disk.last_block = function()
  • b = self.blocks[-1]
  • if MAX_FILES - b.folder.get_files.len < MAX_FILES then
  • return b
  • end if
  • if b.folder.get_files[-1].get_content.len == MAX_FILE_CONTENT then
  • self.create_new_block
  • return self.blocks[-1]
  • end if
  • end function
  • Disk.last_blob = function()
  • b = self.last_block
  • if b.last_file.get_content.len == MAX_FILE_CONTENT then
  • b.new_file
  • return b.last_file
  • else
  • return b.last_file
  • end if
  • end function
  • //TODO: alias it to update(last_char_index, content)
  • Disk.write = function(string)
  • last_blob = self.last_blob
  • available_chars = MAX_FILE_CONTENT - last_blob.get_content.len
  • if string.len <= available_chars then
  • last_blob.set_content(last_blob.get_content + string)
  • else
  • last_blob.set_content(last_blob.get_content + string[:available_chars])
  • string = string[(string.len - available_chars) * -1:]
  • self.write(string)
  • end if
  • end function
  • Disk.update = function(offset, string)
  • Disk.updated_blob_content = function(content, offset, string)
  • content_to_left = content[:offset]
  • content_in_middle = string
  • content_to_right = content[offset + string.len:]
  • // do not remove the ""
  • return "" + content_to_left + content_in_middle + content_to_right
  • end function
  • Disk.init()
  • //for i in range(19)
  • // Disk.create_new_block
  • //end for
  • Disk.update = function(offset, string)
  • blob_index = floor(offset / MAX_FILE_CONTENT)
  • inner_offset = offset % MAX_FILE_CONTENT
  • available_chars = MAX_FILE_CONTENT - inner_offset
  • if (self.blobs.hasIndex(blob_index) == false and inner_offset == 0 and self.blobs.len == blob_index) then
  • if self.blobs[-1].get_content.len < MAX_FILE_CONTENT then exit("error offset out of range")
  • self.last_block.new_file
  • end if
  • if (self.blobs.hasIndex(blob_index) == false) then exit("error offset out of range")
  • blob = self.blobs[blob_index]
  • if (blob.get_content.len < inner_offset) then exit("error offset out of range")
  • if string.len >= available_chars then
  • chars_to_write = string[:available_chars]
  • chars_left = string[(string.len - available_chars) * -1:]
  • blob.set_content(self.updated_blob_content(blob.get_content, inner_offset, chars_to_write))
  • new_offset = offset + chars_to_write.len
  • self.update(new_offset, chars_left)
  • else
  • blob.set_content(self.updated_blob_content(blob.get_content, inner_offset, string))
  • end if
  • end function
  • //Disk.create_new_block
  • //tests ?
  • //Disk.last_block
  • //Disk.last_blob
  • Disk.init()
  • // big string write test
  • char_100 = "1" * 100
  • char_10000 = char_100 * 100
  • char_100000 = char_10000 * 10
  • char_100000 = char_100000 + char_10000 * 6
  • char_100000 = char_100000 + "yes"
  • char_100000 = char_100000// + "yes"
  • Disk.write(char_100000)
  • for i in Disk.blobs
  • print(i.name)
  • print(i.get_content.len)
  • end for
  • b = Disk.update(0, "abcdefghi")
  • b = Disk.update(4, "111")
  • b = Disk.update(159995, "abcdefghi")
  • // do cat 0 and cat 1 to see the results
  • //b = Disk.update(160000, "abcdefghi")for