nwn-lib 0.4.5 → 0.4.6

data/lib/nwn/gff.rb

@@ -117,4 +117,3 @@ require 'nwn/gff/cexolocstr'
 require 'nwn/gff/reader'
 require 'nwn/gff/writer'
 require 'nwn/gff/api'
-require 'nwn/infer'

data/lib/nwn/gff/field.rb

@@ -1,7 +1,7 @@
 # A Field wraps a GFF label->value pair, providing:
 # * +.field_type+ describing the field type (e.g. :int)
 # * +.field_value+ holding the value of this Field
-
+#
 # and, if loaded by Gff::Reader or through YAML:
 # * +.field_label+ holding the label
 # * +.parent+ holding the struct this Field is child of.
@@ -21,6 +21,7 @@ module NWN::Gff::Field
     s = {}.extend(self)
     s['label'], s['type'], s['value'] = label, type, value
     s.extend_meta_classes
+    s.validate
     s
   end
 
@@ -62,7 +63,12 @@ module NWN::Gff::Field
   def path
     raise NWN::Gff::GffError, "field not bound to a parent" unless @parent
     parent_path = @parent.path
-    parent_path + "/" + field_label
+    if @parent.element && @parent.element.field_type == :list
+      idx = @parent.element.field_value.index(@parent)
+      parent_path + "[#{idx}]/" + field_label
+    else
+      parent_path + "/" + field_label
+    end
   end
 
   # This extends this field object and its' value with the
@@ -83,29 +89,62 @@ module NWN::Gff::Field
       field_value.is_a?(field_value_klass)
   end
 
+  # Validate if this field value is within the bounds of the set type.
+  def valid?
+    NWN::Gff::Field.valid_for? self.v, self.t
+  end
+
+  # Validate this field, and raise an Excpetion if not valid.
+  def validate
+    valid? or raise NWN::Gff::GffError,
+      "#{self.path rescue $!.to_s + '/' + self.l}: " +
+        "value '#{self.v.inspect}' not valid for type '#{self.t.inspect}'"
+  end
+
   # Validate if +value+ is within bounds of +type+.
   def self.valid_for? value, type
     case type
-      when :char, :byte
-        value.is_a?(Fixnum)
-      when :short, :word
-        value.is_a?(Fixnum)
-      when :int, :dword
-        value.is_a?(Fixnum)
-      when :int64, :dword64
-        value.is_a?(Fixnum)
+      when :byte, :char
+        value.is_a?(Integer) && value >= 0 && value <= 255
+
+      when :short
+        value.is_a?(Integer) && value >= -0x8000 && value <= 0x7fff
+      when :word
+        value.is_a?(Integer) && value >= 0 && value <= 0xffff
+
+      when :int
+        value.is_a?(Integer) && value >= -0x80000000 && value <= 0x7fffffff
+      when :dword
+        value.is_a?(Integer) && value >= 0 && value <= 0xffffffff
+
+      when :int64
+        value.is_a?(Integer) && value >= -0x800000000000 && value <= 0x7fffffffffff
+      when :dword64
+        value.is_a?(Integer) && value >= 0 && value <= 0xffffffffffff
+
       when :float, :double
         value.is_a?(Float)
+
       when :resref
-        value.is_a?(String) && (1..16).member?(value.size)
+        value.is_a?(String) && (0..16).member?(value.size)
+
       when :cexostr
         value.is_a?(String)
+
       when :cexolocstr
+        value.is_a?(Hash) &&
+          value.keys.reject {|x| x.is_a?(Fixnum) && x >= 0 }.size == 0 &&
+          value.values.reject {|x| x.is_a?(String) }.size == 0
+
+      when :struct
+        value.is_a?(Hash)
+
+      when :list
         value.is_a?(Array)
-      when :struct, :list
-        value.is_a?(Array)
+
       when :void
-        true
+        value.is_a?(String)
+
       else
         false
     end

data/lib/nwn/gff/reader.rb

@@ -166,8 +166,7 @@ class NWN::Gff::Reader
         }
         len = total_size + 4
         # Filter out empty strings.
-        exostr.reject! {|k,v| v.nil? || v.empty?} if
-          ENV['NWN_LIB_FILTER_EMPTY_EXOLOCSTR']
+        exostr.reject! {|k,v| v.nil? || v.empty?}
         exostr.taint
 
       when :void
@@ -214,6 +213,7 @@ class NWN::Gff::Reader
 
     # We extend all fields and field_values with matching classes.
     field.extend_meta_classes
+    field.validate
 
     [label, field]
   end

data/lib/nwn/gff/struct.rb

@@ -3,16 +3,21 @@
 module NWN::Gff::Struct
   DEFAULT_DATA_VERSION = "V3.2"
 
-  # The file-type this struct represents.
-  # This is usually the file extension for root structs,
-  # and nil for sub-structs.
+  # Each Gff::Struct has a data_type, which describes the type of data the struct contains.
+  # For top-level structs, this equals the data type written to the GFF file ("UTI",
+  # for example); for sub structures, this is usually the top-level data type + the
+  # field label ("UTI/PropertiesList", for example).
+  #
+  # This is set for completeness' sake, but is not required to save the struct.
+  # Scripts could use this, for example, to reliably re-attach a Item within
+  # /ItemList/ somewhere else, or export it as .uti.
   attr_accessor :data_type
 
   # The file version. Usually "V3.2" for root structs,
   # and nil for sub-structs.
   attr_accessor :data_version
 
-  # GFF struct type
+  # GFF struct type. The default is 0xffffffff.
   attr_accessor :struct_id
 
   # The field this struct is value of.
@@ -43,11 +48,15 @@ module NWN::Gff::Struct
   # Create a new struct.
   # Usually, you can leave out data_type and data_version for non-root structs,
   # because that will be guess-inherited based on the existing associations.
+  #
+  # You can pass a block to this method, which will receive the newly-created
+  # Struct as the only argument.
   def self.new struct_id = 0xffffffff, data_type = nil, data_version = nil
     s = {}.extend(self)
     s.struct_id = struct_id
     s.data_type = data_type
     s.data_version = data_version
+    yield(s) if block_given?
     s
   end
 
@@ -58,17 +67,26 @@ module NWN::Gff::Struct
   #  some_struct.add_field 'ID', :byte, 5
   # is equivalent to:
   #  some_struct.add_byte 'ID', 5
+  #
+  # You can pass a block to this method, which will receive the newly-created
+  # Field as an argument.
+  #
+  # This allows for code like this:
+  #  Gff::Struct.new(0) do |s|
+  #    s.add_byte "Byte", 5
+  #    s.add_list "Some_List", [] do |l|
+  #      l.v << Gff::Struct.new ...
+  #      ..
+  #    end
+  #  end
   def add_field label, type, value, &block
     self[label] = NWN::Gff::Field.new(label, type, value)
     self[label].parent = self
-    if block_given?
-      yield(self[label])
-    end
+    yield(self[label]) if block_given?
     self[label]
   end
 
-  #:nodoc:
-  def method_missing meth, *av, &block
+  def method_missing meth, *av, &block # :nodoc:
     if meth.to_s =~ /^add_(.+)$/
       if NWN::Gff::Types.index($1.to_sym)
         av.size == 2 or super

data/lib/nwn/res.rb

@@ -0,0 +1,275 @@
+module NWN
+  module Resources
+
+    # This is a generic index to a resource.
+    class ContentObject
+      attr_accessor :resref
+      attr_accessor :res_type
+      attr_accessor :io
+      attr_accessor :offset
+      attr_accessor :size_override
+
+      # Create a new index to +filename+, optionally specifying +io+.
+      def self.new_from filename, io = nil
+        filename = File.expand_path(filename)
+        base = File.basename(filename).split(".")[0..-2].join(".").downcase
+        ext = File.extname(filename)[1..-1].downcase
+        res_type = NWN::Resources::Extensions[ext] or raise ArgumentError,
+          "Not a valid extension: #{ext.inspect} (while packing #{filename})"
+
+        ContentObject.new(base, res_type, io || filename, 0, io.size || File.stat(filename).size)
+      end
+
+      def initialize resref, res_type, io = nil, offset = nil, size = nil
+        @resref, @res_type = resref.downcase, res_type
+        @io, @offset = io, offset
+        @size_override = size
+
+        raise ArgumentError, "Invalid object passed: responds_to :read, want @offset, but does not respond_to :seek" if
+          @io.respond_to?(:read) && @offset && @offset != 0 && !@io.respond_to?(:seek)
+      end
+
+      # Get the size in bytes of this object.
+      def size
+        @size_override || (@io.is_a?(IO) ? @io.stat.size : File.stat(@io).size)
+      end
+
+      # Get the contents of this object. This is a costly operation, loading
+      # the whole buffer. If you want fine-grained access, use ContentObject#io
+      # and do it yourself, observing ContentObject#offset and ContentObject#size.
+      def get
+        if @io.respond_to?(:read)
+          @io.seek(@offset) if @offset
+          d = @io.read(self.size)
+          raise IOError,
+            "not enough data available while reading #{self.filename}" if
+              d.size != self.size
+          d
+        else
+          IO.read(@io)
+        end
+      end
+
+      # Get the canonical filename of this object.
+      def filename
+        @resref + "." + self.extension
+      end
+
+      # Get the extension of this object.
+      def extension
+        NWN::Resources::Extensions.index(@res_type)
+      end
+    end
+
+    # Wraps n ContentObjects; a baseclass for erf/key encapsulation.
+    class Container
+      attr_reader :content
+
+      def initialize
+        @content = []
+      end
+
+      def has?(filename)
+        base = File.basename(filename)
+        @content.each {|f|
+          return true if f.filename.downcase == base.downcase
+        }
+        return false
+      end
+
+      # Add a content object giving a +filename+ and a optional
+      # +io+.
+      def add_file filename, io = nil
+        @content << ContentObject.new_from(filename, io)
+      end
+
+      # Add a content object giving the ContentObject
+      def add o
+        @content << o
+      end
+
+      # Returns a list of filenames
+      def filenames
+        @content.map {|x| x.filename }
+      end
+
+      # Get the ContentObject pointing to the given filename.
+      # Raises ENOENT if not mapped.
+      def get_content_object filename
+        ret = @content.select {|x| filename.downcase == x.filename }
+        raise Errno::ENOENT,
+          "No ContentObject with the given filename found." if
+            ret.size == 0
+        ret[0]
+      end
+
+      # Get the contents of the given filename.
+      # Raises ENOENT if not mapped.
+      def get filename
+        get_content_object(filename.downcase).get
+      end
+    end
+
+    # A Container that directly wraps a directory (e.g. override/).
+    # Does not update on changes - caches the directory entries on initialize.
+    class DirectoryContainer < Container
+      def initialize path
+        super()
+        @path = path
+        Dir[path + "/*.*"].each {|x|
+          add_file x
+        }
+      end
+    end
+
+    # The resource manager, providing ordered access to Container objects.
+    class Manager
+      def initialize
+        @path = []
+        @_content_cache = nil
+      end
+
+      def add_container c
+        @path << c
+      end
+
+      # Get the ContentObject pointing to the given filename.
+      # Raises ENOENT if not mapped.
+      def get_content_object filename
+        @path.reverse.each {|con|
+          con.has?(filename) or next
+          return con.get_content_object(filename)
+        }
+        raise Errno::ENOENT, "No ContentObject with the given filename found."
+      end
+
+      # Get the contents of the given filename.
+      # Raises ENOENT if not mapped.
+      def get filename
+        get_content_object(filename).get
+      end
+
+      # Get a list of filenames contained inside.
+      def content
+        @_content_cache ||= @path.inject([]) {|a, x|
+          a |= x.filenames
+        }
+      end
+    end
+
+    Extensions = {
+      'res' => 0,
+      'bmp' => 1,
+      'mve' => 2,
+      'tga' => 3,
+      'wav' => 4,
+      'wfx' => 5,
+      'plt' => 6,
+      'ini' => 7,
+      'mp3' => 8,
+      'mpg' => 9,
+      'txt' => 10,
+      'plh' => 2000,
+      'tex' => 2001,
+      'mdl' => 2002,
+      'thg' => 2003,
+      'fnt' => 2005,
+      'lua' => 2007,
+      'slt' => 2008,
+      'nss' => 2009,
+      'ncs' => 2010,
+      'mod' => 2011,
+      'are' => 2012,
+      'set' => 2013,
+      'ifo' => 2014,
+      'bic' => 2015,
+      'wok' => 2016,
+      '2da' => 2017,
+      'tlk' => 2018,
+      'txi' => 2022,
+      'git' => 2023,
+      'bti' => 2024,
+      'uti' => 2025,
+      'btc' => 2026,
+      'utc' => 2027,
+      'dlg' => 2029,
+      'itp' => 2030,
+      'btt' => 2031,
+      'utt' => 2032,
+      'dds' => 2033,
+      'bts' => 2034,
+      'uts' => 2035,
+      'ltr' => 2036,
+      'gff' => 2037,
+      'fac' => 2038,
+      'bte' => 2039,
+      'ute' => 2040,
+      'btd' => 2041,
+      'utd' => 2042,
+      'btp' => 2043,
+      'utp' => 2044,
+      'dft' => 2045,
+      'gic' => 2046,
+      'gui' => 2047,
+      'css' => 2048,
+      'ccs' => 2049,
+      'btm' => 2050,
+      'utm' => 2051,
+      'dwk' => 2052,
+      'pwk' => 2053,
+      'btg' => 2054,
+      'utg' => 2055,
+      'jrl' => 2056,
+      'sav' => 2057,
+      'utw' => 2058,
+      '4pc' => 2059,
+      'ssf' => 2060,
+      'hak' => 2061,
+      'nwm' => 2062,
+      'bik' => 2063,
+      'ndb' => 2064,
+      'ptm' => 2065,
+      'ptt' => 2066,
+      'bak' => 2067,
+      'osc' => 3000,
+      'usc' => 3001,
+      'trn' => 3002,
+      'utr' => 3003,
+      'uen' => 3004,
+      'ult' => 3005,
+      'sef' => 3006,
+      'pfx' => 3007,
+      'cam' => 3008,
+      'lfx' => 3009,
+      'bfx' => 3010,
+      'upe' => 3011,
+      'ros' => 3012,
+      'rst' => 3013,
+      'ifx' => 3014,
+      'pfb' => 3015,
+      'zip' => 3016,
+      'wmp' => 3017,
+      'bbx' => 3018,
+      'tfx' => 3019,
+      'wlk' => 3020,
+      'xml' => 3021,
+      'scc' => 3022,
+      'ptx' => 3033,
+      'ltx' => 3034,
+      'trx' => 3035,
+      'mdb' => 4000,
+      'mda' => 4001,
+      'spt' => 4002,
+      'gr2' => 4003,
+      'fxa' => 4004,
+      'fxe' => 4005,
+      'jpg' => 4007,
+      'pwc' => 4008,
+      'ids' => 9996,
+      'erf' => 9997,
+      'bif' => 9998,
+      'key' => 9999,
+    }.freeze
+
+  end
+end