rrb-common 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25249c7b5e3aa642c23637cc4e3bad8ce62434a1d77962287fe7cab331d016c9
-  data.tar.gz: 7592bacd9ddfb0d7371bfd24f87a84de502e2500f7a81a5ca3f8bbd5f1d888a5
+  metadata.gz: 0ce1791f92b3956911a84c638f8c6b55b1dc41b250321f0ee14a3aa2e70771d0
+  data.tar.gz: 1d80809c5a7633e2f379a3c6df03ad0cd278d127775a2ad76fae52c31f4ae534
 SHA512:
-  metadata.gz: 58a9a9da24f64061478f46982beb434b6a3e917c494bf36e437b50570593b2b05bb9870ad50bee4fb08cb82bfec4eb90e8377cae5504e513584582ce1030b6bf
-  data.tar.gz: b4810f557135b53ba88e89850d59076f24650df965ec0b497868ec41d7a47e8d47c635c6b5797c5297d994446335a479e1dad3c0f22da04c810503a571af8460
+  metadata.gz: 59abbc5acfb4daad674f5555d23adf9714987a448fbc6c051aee422977672206550973039df89f85dd27adc31b872763b3c700983022bf91333fe46232d7af0b
+  data.tar.gz: af50e56189702d9c4820ec9a78e04ec0a4dc042a825ff7015d736938dd6119610d75df3e16792d7329eb2c7cc46f3dc8359fcdc8e2179ff96ec6cc7ceca94819

data/lib/rune/cache/archive.rb

@@ -0,0 +1,63 @@
+module RuneRb::Cache
+  # An archive of data in the Cache.
+  class Archive
+    include RuneRb::Core::Logging
+
+    # @!attribute [r] entries
+    # @return [Array<Hash>] the entries in the archive
+    attr_reader :entries
+
+    # Constructs a new CacheArchive
+    # @param entries [Array<Hash>] the entries in the archive
+    def initialize(entries)
+      @entries = entries
+    end
+
+    # Decodes an archive from the specified buffer.
+    # @param buffer [RuneRb::Core::Buffer] the buffer to decode
+    def self.decode(buffer)
+      extracted_size = buffer.read(type: :int24)
+      size = buffer.read(type: :int24)
+      extracted = false
+
+      if size != extracted_size
+        data = buffer.data.slice!(0..size)
+        data = StringIO.new(data)
+        decompressor = RBzip2.default_adapter::Decompressor.new(data)
+        buffer = RuneRb::Core::Buffer.new(mode: 'r')
+        buffer << decompressor.read
+        extracted = true
+      end
+
+      entry_count = buffer.read(type: :short)
+      identifiers = Array.new(entry_count)
+      extracted_sizes = Array.new(entry_count)
+      sizes = Array.new(entry_count)
+
+      entry_count.times do |i|
+        identifiers[i] = buffer.read(type: :int)
+        extracted_sizes[i] = buffer.read(type: :int24)
+        sizes[i] = buffer.read(type: :int24)
+      end
+
+      entries = Array.new(entry_count)
+      entry_count.times do |entry|
+        entry_buffer = RuneRb::Core::Buffer.new(mode: 'r')
+
+        if extracted == false
+          data = buffer.data.slice!(0..sizes[entry])
+          data = StringIO.new(data)
+          decompressor = RBzip2.default_adapter::Decompressor.new(data)
+          entry_buffer << decompressor.read
+        else
+          data = buffer.data.slice!(0..extracted_sizes[entry])
+          entry_buffer << data 
+        end
+
+        entries[entry] = { id: identifiers[entry], buffer: entry_buffer }
+      end
+
+      RuneRb::Cache::Archive.new(entries)
+    end
+  end
+end

data/lib/rune/cache/constants.rb

@@ -0,0 +1,21 @@
+module RuneRb::Cache::Constants
+  # The number of archives in the cache.
+  # @return [Integer]
+  ARCHIVE_COUNT = 0x9
+
+  # The size of a single index
+  # @return [Integer]
+  INDEX_SIZE = 0x6
+
+  # The size of a single data header
+  # @return [Integer]
+  HEADER_SIZE = 0x8
+
+  # The size of a chunk of data
+  # @return [Integer]
+  CHUNK_SIZE = 512
+
+  # The size of a single data block
+  # @return [Integer]
+  BLOCK_SIZE = HEADER_SIZE + CHUNK_SIZE;
+end

data/lib/rune/cache/file_system.rb

@@ -0,0 +1,182 @@
+module RuneRb::Cache
+  class FileSystem
+    include RuneRb::Core::Logging
+
+    # @attribute [r] cache
+    # @return [Hash<FileDescriptor, RuneRb::Cache::Archive>] a map of decoded archives.
+    attr_reader :cache
+
+    # @attribute [r] crc_table
+    # @return [RuneRb::Core::Buffer] the CRC table for the cache.
+    attr_reader :crc_table
+
+    # @attribute [r] crc
+    # @return [Array<Integer>] the CRC values for the cache.
+    attr_reader :crc
+
+    # @attribute [r] indicies
+    # @return [Array<StringIO>] the indicies for the cache.
+    attr_reader :indicies
+
+    # @attribute [r] data_file
+    # @return [StringIO] the data file for the cache.
+    attr_reader :data_file
+
+    # Constructs a new FileSystem instance.
+    # @param path [String] the path to the cache.
+    def initialize(path)
+      @indicies = Array.new
+      @crc_table = RuneRb::Core::Buffer.new(mode: 'r')
+      @crc = Array.new
+      @cache = Hash.new
+      @data_file = StringIO.new
+      read_layout(path)
+    end
+
+    # Retrieves an {RuneRb::Cache::Archive} by the specified {FileDescriptor}.
+    # @param type [Integer] the file type.
+    # @param file [Integer] the file identifier.
+    def archive(type, file)
+      descriptor = FileDescriptor.new(type, file)
+      cached = @cache[descriptor]
+      
+      if cached == nil
+        file = cache_file(descriptor)
+        cached = RuneRb::Cache::Archive.decode(file)
+        @cache[descriptor] = cached
+      end
+      
+      cached
+    end
+
+    # Retrieves a {RuneRb::Core::Buffer} that corresponds to the specified {FileDescriptor} in the cache.
+    # @param descriptor [FileDescriptor] the descriptor to retrieve.
+    # @raise [RuntimeError] if a Chunk id does not match what is expected during cache file read.
+    # @raise [RuntimeError] if a type does not match descriptor type during cache file read.
+    # @raise [RuntimeError] if a file identifier does not match descriptor file identifier during cache file read.
+    # @return [RuneRb::Core::Buffer] the buffer containing data that corresponds to the specified descriptor.
+    def cache_file(descriptor)
+      index = index_for(descriptor)
+      buffer = RuneRb::Core::Buffer.new(mode: 'r')
+      
+      position = index.block * RuneRb::Cache::BLOCK_SIZE
+      read = 0
+      size = index.size
+      blocks = size / RuneRb::Cache::CHUNK_SIZE
+
+      if size % RuneRb::Cache::CHUNK_SIZE != 0
+        blocks += 1
+      end
+
+      info "Reading #{blocks} blocks from position #{position}."
+
+      blocks.times do |i|
+        @data_file.seek(position)
+        header = @data_file.read
+        header_data = header.unpack('C*')
+      
+        position += RuneRb::Cache::HEADER_SIZE
+        
+        next_file     = header_data[0] << 8 | header_data[1]
+        current_chunk = header_data[2] << 8 | header_data[3]
+        next_block    = header_data[4] << 16 | header_data[5] << 8 | header_data[6]
+        next_type     = header_data[7]
+
+        raise "Chunk id mismatch! (Current #{current_chunk}, Expected #{i})" if current_chunk != i
+
+        chunk_size = size - read
+        chunk_size = RuneRb::Cache::CHUNK_SIZE if chunk_size > RuneRb::Cache::CHUNK_SIZE
+
+        @data_file.seek(position)
+        buffer << @data_file.read
+
+        read += chunk_size
+        position = next_block * RuneRb::Cache::BLOCK_SIZE
+
+        if size > read
+          raise "Next type (#{next_type}) does not match descriptor type (#{descriptor.type + 1})." if next_type != descriptor.type + 1
+          raise "Next file (#{next_file}) does not match descriptor file (#{descriptor.file})." if next_file != descriptor.file
+        end
+      end
+
+      info "Read #{buffer.length} from cache."
+
+      buffer
+    end
+
+    def index_for(descriptor)
+      idx = descriptor.type
+      raise "Index out of bounds. (#{idx})" if idx < 0 || idx >= @indicies.length
+
+      buffer = String.new
+      idx_file = @indicies[idx]
+      position = descriptor.file * RuneRb::Cache::INDEX_SIZE
+      info "Reading index from position #{position}"
+
+      if position >= 0 && (idx_file.length >= (position + RuneRb::Cache::INDEX_SIZE))
+        idx_file.seek(position, IO::SEEK_CUR)
+        buffer << idx_file.read
+      else
+        raise "Could not find index file at position #{position}."
+      end
+
+      info " Length: #{buffer.length}, Index data: #{buffer.bytes}"
+
+      RuneRb::Cache::Index.decode(buffer)
+    end
+    
+    def close
+      @indicies.each(&:close)
+      @data_file.close
+    end
+
+    # The number of index files in the cache.
+    # @return [Integer] the number of index files in the cache.
+    def cache_count
+      @indicies.length
+    end
+
+    # The number of files in a cache.
+    # @param cache [Integer] the cache to check.
+    def file_count(cache)
+      (@indicies[cache].size / RuneRb::Core::INDEX_SIZE) - 1
+    end
+
+    # Reads the layout of the cache from the specified path.
+    # @param path [String] the path to the cache directory.
+    # @raise [RuntimeError] if the cache archive is not found.
+    def read_layout(path)
+      raise "Cache archive not found. Please install them into the #{path} directory."  unless check_for_archives(path)
+
+      # Find how many index files exist
+      count = 0.upto(255).each do |i|
+        break i unless File.exist?(File.join(path, "main_file_cache.idx#{i}"))
+      end
+
+      # Gather file objects
+      @data_file = File.open(File.join(path, "main_file_cache.dat"), "r")
+
+      count.times do |i|
+        data = File.read("#{path}/main_file_cache.idx#{i}")
+        @indicies[i] = StringIO.new(data)
+      end
+    end
+
+    # Checks for the existence of cache archives in a path.
+    # @param path [String] the path to the cache directory.
+    def check_for_archives(path)
+      return false if path.nil?
+      return false unless File.directory?(path)
+      return false unless File.exist?(path)
+      return false unless File.readable?(path)
+      return false if Dir.empty?(path)
+      true
+    end
+
+    FileDescriptor = Struct.new(:type, :file) do
+      def equals(other)
+        other.file == file && other.type == type
+      end
+    end
+  end
+end

data/lib/rune/cache/index.rb

@@ -0,0 +1,37 @@
+module RuneRb::Cache
+  # An instance of a {CacheIndex} points to a file in the `main_file_cache.dat` file.
+  class Index
+    include RuneRb::Core::Logging
+
+    # @!attribute [r] size
+    # @return [Integer] the size of the file.
+    # @note This attribute is read-only.
+    attr_reader :size
+
+    # @!attribute [r] block
+    # @return [Integer] the block of the file.
+    # @note This attribute is read-only.
+    attr_reader :block
+    
+    # Constructs a new Cache Index given the block size and identifier.
+    # @param size [Integer] the size of the block file
+    # @param block [Integer] the first block of the file
+    def initialize(size, block)
+      @size = size
+      @block = block
+    end
+
+    # Decodes a buffer into an index.
+    # @param buffer [String] the buffer to decode.
+    def self.decode(buffer)
+      #raise "Unexpected buffer length. Buffer #{buffer.bytesize}, Expected: #{RuneRb::Core::INDEX_SIZE}" unless buffer.bytesize == RuneRb::Core::INDEX_SIZE
+
+      bytes = buffer.unpack('C*')
+      size =  bytes[0] << 16 | bytes[1] << 8 | bytes[2]
+      block = bytes[3] << 16 | bytes[4] << 8 | bytes[5]
+      info "Decoded index: size: #{size}, block: #{block}"
+
+      RuneRb::Cache::Index.new(size, block)
+    end
+  end
+end

data/lib/rune/common.rb

@@ -35,6 +35,15 @@ module RuneRb
     autoload :SetRefinements,     'rune/patches/set_refinements'
   end
 
+  module Cache
+    autoload :Archive,            'rune/cache/archive'
+    autoload :Constants,          'rune/cache/constants'
+    autoload :FileSystem,         'rune/cache/file_system'
+    autoload :Index,              'rune/cache/index'
+
+    include RuneRb::Cache::Constants
+  end
+
   # The Logger utility for the RuneRb framework.
   # @return [Console::Logger] the logger instance.
   def self.logger

data/lib/rune/core/buffer.rb

@@ -3,6 +3,11 @@ module RuneRb::Core
   # A Buffer encapsulates raw data in a String instance. Depending on the mode, the buffer can be read from or written to.
   class Buffer
 
+    # @!attribute [r] data
+    # @return [String] the data contained in the buffer.
+    # @note This attribute is read-only.
+    attr_reader :data
+
     # Constructs a new Buffer instance.
     # @param mode [String] the mode of the buffer.
     def initialize(mode: 'rw')

data/lib/rune/core/constants.rb

@@ -19,6 +19,10 @@ module RuneRb::Core::Constants
   # @return [Array<Integer>]
   BIT_MASK_OUT = (0...32).collect { (1 << _1) - 1 }.freeze
 
+  # The number of archives in the cache.
+  # @return [Integer]
+  ARCHIVE_COUNT = 0x9
+
   # The size of a single index
   # @return [Integer]
   INDEX_SIZE = 0x6
@@ -41,4 +45,4 @@ module RuneRb::Core::Constants
     BIG: [0, 1, 2].freeze,
     LITTLE: [2, 1, 0].freeze
   }.freeze
-end
+end

data/lib/rune/core/ruby_isaac.rb

@@ -10,11 +10,7 @@ module RuneRb::Core
       @cc = 0
       @mm = []
       @randrsl = Array.new(256, 0)
-
-      seed.each_with_index do |element, i|
-        @randrsl[i] = element
-      end
-
+      seed.each_with_index { |element, i| @randrsl[i] = element }
       randinit
     end
 

data/lib/rune/core/writeable_buffer.rb

@@ -52,18 +52,14 @@ module RuneRb::Core::WriteableBuffer
   # @param value [Integer] the medium value to write.
   # @param mutation [String] the mutation made to the byte.
   # @param order [String] the order in which bytes will be written.
-  def write_int24(value, mutation: :STD, signed: false, order: :BIG)
+  def write_int24(value, mutation: :STD, order: :BIG)
     case order
     when :BIG
       write_byte(value >> 16)
       write_byte(value >> 8)
-      write_byte(value, mutation: mutation, signed: signed)
-    when :MIDDLE
-      write_byte(value >> 8)
-      write_byte(value, mutation: mutation, signed: signed)
-      write_byte(value >> 16)
+      write_byte(value, mutation: mutation)
     when :LITTLE
-      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value, mutation: mutation)
       write_byte(value >> 8)
       write_byte(value >> 16)
     else raise "Unrecognized byte order: #{order}"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rrb-common
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Patrick W.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-09 00:00:00.000000000 Z
+date: 2024-04-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbzip2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -156,6 +170,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/rune/cache/archive.rb
+- lib/rune/cache/constants.rb
+- lib/rune/cache/file_system.rb
+- lib/rune/cache/index.rb
 - lib/rune/common.rb
 - lib/rune/core/archive.rb
 - lib/rune/core/buffer.rb
@@ -187,7 +205,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Common utilities for RuneRb.