nwn-lib 0.2.2 → 0.3.0

data/BINARIES

@@ -0,0 +1,35 @@
+== nwn-gff-print
+
+ Usage: nwn-gff-print [options] file/- [path]
+    -y, --yaml                       Dump as yaml
+    -k, --kivinen                    Dump as kivinens dump format (like the perl tools)
+    -f, --kivinen-full-path          Print the full path (implies -k)
+    -m, --marshal                    Native ruby marshalling. Warning: raw bytes
+    -t, --types                      Dump types as well (only applies to -k, for now)
+        --type filetype              Override the file type (implies --struct 0xffffffff)
+        --struct id                  Override struct id (as hex, please)
+
+This prints out the given file (or stdin, if -) as the specified format (-k, -f, -y, -m).
+[-k] is the same as gffprint.pl
+[-f] is the same as gffprint.pl -t
+[-m] is the native ruby marshal format (_Marshal.dump(obj)_)
+[-y] is standard YAML
+
+== nwn-gff-import
+
+ Usage: nwn-gff-import [options] file/- outfile/-
+    -y, --yaml                       Import as yaml
+    -m, --marshal                    Import as native ruby marshal data
+
+This is the equivalent to gffencode.pl, and takes all output formats that nwn-gff-print
+provides. This can be used to transform marshalled gff data back into gff binary data.
+
+Example (save to run on a shell, prints out hex data):
+
+ nwn-gff-print -y my_item.uti | nwn-gff-import.rb -y - - | xxd
+
+== nwn-gff-irb
+
+ Usage: nwn-gff-irb file
+
+nwn-gff-irb allows interactive editing of gff files. There are some examples on the CHEATSHEET.

data/CHANGELOG

@@ -1,3 +1,12 @@
+=== 0.3.0
+
+* Binary: nwn-gff-import
+* Binary: nwn-gff-print supports -m, ruby marshalling
+* helper: NWN::Gff::Helpers.item_property
+* TwoDA: Cache, more compatibility to slightly broken 2da files
+* CExoLocString: now has its own proper class for a more convenient API
+* Gff::Struct: has changed its internal API (transparent to the outside)
+
 === 0.2.2
 
 * Binary: nwn-gff-irb: interactive gff inspection/editing shell

data/CHEATSHEET

@@ -0,0 +1,50 @@
+==== Extract item from creature inventory
+
+ nwn-gff-print --type UTI -k -t creature.bic 'ItemList[12]' | gffencode.pl -o item.uti
+
+==== Quick-edit a item
+ 
+ your/prompt$ nwn-gff-irb my_item.uti
+ Your GFF file is in `GFF' (type: "UTI ").
+ Type `save' to save to the filename it came from (make a backup!), `exit' (or Ctrl+D) to exit (without saving).
+ To save to a different location, type `save "path/to/new/location.ext"'.
+
+ irb(main):001:0> GFF.root_struct.keys
+ => ["ModelPart2", "Cursed", "ModelPart3", "Cost", "StackSize", "Charges", "Comment", "PaletteID", "BaseItem", "Tag", "DescIdentified", "Identified", "Plot", "TemplateResRef", "PropertiesList", "AddCost", "Stolen", "Description", "LocalizedName", "ModelPart1"]
+
+ irb(main):002:0> GFF['LocalizedName/4']
+ => "Mundane Feuerpfeile (aus Eibe)"
+
+ irb(main):003:0> GFF['LocalizedName/4'] = 'New Name'
+ => "New Name"
+
+ irb(main):004:0> GFF['LocalizedName']
+ => #<NWN::Gff::Element:0xb790641c @type=:cexolocstr, @value=[#<struct NWN::Gff::CExoLocString language=4, text="New Name">, #<struct NWN::Gff::CExoLocString language=0, text="Pfeil">], @_str_ref=1517, @label="LocalizedName">
+
+ irb(main):005:0> save
+ Saving to `/home/elven/code/nwn/nwn-lib.git/my_item.uti' ..
+ saved.
+ => nil
+
+ irb(main):006:0> exit
+
+==== Add a item property, the semi-human way
+
+ irb(main):001:0> Helpers.item_property('Cast_Spell')
+ ArgumentError: Property Cast_Spell needs subtype of type IPRP_SPELLS, but none given.
+ from /var/lib/gems/1.8/gems/nwn-lib-0.2.3/lib/nwn/helpers.rb:108:in `item_property'
+ from (irb):1
+
+ irb(main):002:0> Helpers.item_property('Cast_Spell', 'Invisib')
+ ArgumentError: Cannot resolve invisib. Partial matches: ["Improved_Invisibility", "Invisibility", "Invisibility_Purge", "Invisibility_Sphere", "See_Invisibility"].
+ from /var/lib/gems/1.8/gems/nwn-lib-0.2.3/lib/nwn/helpers.rb:79:in `resolve_or_match_partial'
+ from /var/lib/gems/1.8/gems/nwn-lib-0.2.3/lib/nwn/helpers.rb:116:in `item_property'
+ from (irb):2
+
+ irb(main):003:0> Helpers.item_property('Cast_Spell', 'Invisibility')
+ ArgumentError: Property Cast_Spell requires a cost value of type IPRP_CHARGECOST, but none given
+ from /var/lib/gems/1.8/gems/nwn-lib-0.2.3/lib/nwn/helpers.rb:122:in `item_property'
+ from (irb):3
+
+ irb(main):004:0> Helpers.item_property('Cast_Spell', 'Invisibility', 'Unlimi')
+ => {"PropertyName"=>#<NWN::Gff::Element:0xb75f4e68 ..

data/README

@@ -5,12 +5,9 @@ This package provides a library for reading, changing, and writing common file f
 They should work with NWN2 just as well, since the file format specifications did not change.
 
 There are various things included in this distribution:
-* some binaries under bin/
+* some binaries under bin/ (see BINARIES)
 * the actual library under lib/nwn
 
-== Supplied binaries
-* nwn-gff-print
-
 == Quickstart
 
 It is easiest to just use the gem, which is available through rubyforge (<tt>sudo gem install nwn-lib</tt>).

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "nwn-lib"
-VERS = "0.2.2"
+VERS = "0.3.0"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'nwn-lib: a ruby library for accessing NWN resource files', \
@@ -18,7 +18,7 @@ RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add ["README", "CHEATSHEET", "CHANGELOG", "COPYING", "doc/*.rdoc", "lib/**/*.rb"]
+  rdoc.rdoc_files.add ["README", "BINARIES", "CHEATSHEET", "CHANGELOG", "COPYING", "doc/*.rdoc", "lib/**/*.rb"]
 end
 
 desc "Packages up nwn-lib"
@@ -30,14 +30,14 @@ spec = Gem::Specification.new do |s|
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"]
+  s.extra_rdoc_files = ["README", "BINARIES", "CHEATSHEET", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"]
   s.rdoc_options += RDOC_OPTS + ["--exclude", "^(examples|extras)\/"]
   s.summary = "a ruby library for accessing Neverwinter Nights resource files"
   s.description = s.summary
   s.author = "Bernhard Stoeckner"
   s.email = "elven@swordcoast.net"
   s.homepage = "http://nwn-lib.elv.es"
-  s.executables = ["nwn-gff-print", "nwn-gff-irb"]
+  s.executables = ["nwn-gff-print", "nwn-gff-irb", "nwn-gff-import"]
   s.required_ruby_version = ">= 1.8.4"
   s.files = %w(COPYING CHANGELOG README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
   s.require_path = "lib"

data/bin/nwn-gff-import

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'optparse'
+require 'nwn/gff'
+require 'nwn/helpers'
+require 'yaml'
+
+format = nil
+
+OptionParser.new do |o|
+  o.banner = "Usage: nwn-gff-import [options] file/- outfile/-"
+  o.on "-y", "--yaml", "Import as yaml" do
+    format = :yaml
+  end
+  o.on "-m", "--marshal", "Import as native ruby marshal data" do
+    format = :marshal
+  end
+end.parse!
+
+infile = ARGV.shift or begin
+  $stderr.puts "Required argument: filename to read, or - for stdin (try -h)."
+  exit 1
+end
+outfile = ARGV.shift or begin
+  $stderr.puts "Required argument: filename to write, or - for stdout (try -h)."
+  exit 1
+end
+
+if infile == "-"
+  inbytes = $stdin.read
+else
+  inbytes = IO.read(infile)
+end
+
+data = nil
+
+case format
+  when :yaml
+    data = YAML.load(inbytes)
+  when :marshal
+    data = Marshal.load(inbytes)
+  else
+    raise ArgumentError, "Unknown format; try -h"
+end
+
+raise ArgumentError, "Input stream is NOT a valid gff object" unless
+  data.is_a?(NWN::Gff::Gff)
+
+outbytes = NWN::Gff::Writer.dump(data)
+if outfile == "-"
+  puts outbytes
+else
+  File.open(outfile, "w") {|f| f.write(outbytes) }
+end

data/bin/nwn-gff-irb

@@ -5,6 +5,7 @@ require 'nwn/gff'
 require 'nwn/twoda'
 require 'yaml'
 require 'irb'
+require 'irb/completion'
 
 OptionParser.new do |o|
   o.banner = "Usage: nwn-gff-irb file"
@@ -34,7 +35,16 @@ def save destination = nil
   puts "saved."
 end
 
+if __cache_location = ENV['NWN2DAHOME']
+  require 'nwn/helpers'
+  puts "Setting up 2da cache at #{__cache_location} .."
+  NWN::TwoDA::Cache.setup __cache_location
+else
+  puts "Warning: Environment variable `NWN2DAHOME' is not available, not using 2da cache (helpers not available)."
+end
+
 include NWN::Gff
+include NWN::TwoDA
 
 puts "Your GFF file is in `GFF' (type: #{GFF.type.inspect})."
 puts "Type `save' to save to the filename it came from (make a backup!), `exit' (or Ctrl+D) to exit (without saving)."

data/bin/nwn-gff-print

@@ -2,6 +2,7 @@
 require 'rubygems'
 require 'optparse'
 require 'nwn/gff'
+require 'nwn/helpers'
 require 'yaml'
 
 format = nil
@@ -19,9 +20,12 @@ OptionParser.new do |o|
     format = :kivinen
   end
   o.on "-f", "--kivinen-full-path", "Print the full path (implies -k)" do
-  format = :kivinen
+    format = :kivinen
     full = true
   end
+  o.on "-m", "--marshal", "Native ruby marshalling. Warning: raw bytes" do
+    format = :marshal
+  end
   o.on "-t", "--types", "Dump types as well (only applies to -k, for now)" do
     types_too = true
   end
@@ -69,6 +73,8 @@ case format
     NWN::Gff.kivinen_format g, "/", types_too, full, file_type, struct_id do |label, value|
       puts "%s:\t%s" % [label, value]
     end
+  when :marshal
+    puts Marshal.dump(g)
   else
     puts "Unknown format; try -h"
 end

data/lib/nwn/gff.rb

@@ -98,8 +98,8 @@ module NWN
 
         when :cexolocstr
 
-          s.value.each {|vv|
-            yield(prefix + s.label + "/" + vv.language.to_s, vv.text.gsub(/([\000-\037\177-\377%])/) {|v| "%" + v.unpack("H2")[0] })
+          s.value.each {|kk,vv|
+            yield(prefix + s.label + "/" + kk.to_s, vv.gsub(/([\000-\037\177-\377%])/) {|v| "%" + v.unpack("H2")[0] })
           }
           yield(prefix + s.label + ". ____string_ref", s._str_ref)
 
@@ -372,25 +372,52 @@ end
 
 # A Gff::Struct is a hash of label->Element pairs,
 # with an added +.struct_id+.
-class NWN::Gff::Struct < Hash
+class NWN::Gff::Struct
   attr_accessor :struct_id
-  def initialize *a
+  attr_accessor :hash
+
+  def initialize
     @struct_id = 0
+    @hash = {}
     super
   end
+
+  def method_missing meth, *a
+    @hash.method(meth).call(*a)
+  end
 end
 
 # A CExoLocString is a localised CExoString.
-#
-# Attributes:
-# [+language+] The language ID
-# [+text+]     The text for this language.
-#
-# ExoLocStrings in the wild are usually arrays of NWN::Gff:CExoLocString
-# (one for each language supplied).
-# Note that a CExoLocString is NOT a GFF list, although both are
-# represented as arrays.
-class NWN::Gff::CExoLocString < Struct.new(:language, :text)
+# It contains pairs of language => text pairs,
+# where language is a language_id as specified in the GFF
+# documentation pdf.
+class NWN::Gff::CExoLocString
+  attr_reader :languages
+  def initialize
+    @languages = {}
+  end
+
+  # Retrieve the text for a given language.
+  # Returns "" if no text is set for the given
+  # language.
+  def [] language_id
+    @languages[language_id.to_i] || ""
+  end
+
+  # Sets a new language text.
+  def []= language_id, text
+    @languages[language_id.to_i] = text
+  end
+
+  def size
+    @languages.reject {|k,v| v == ""}.size
+  end
+
+  def each
+    @languages.reject {|k,v| v == ""}.each {|k,v|
+      yield k, v
+    }
+  end
 end
 
 # A class that parses binary GFF bytes into ruby-friendly data structures.
@@ -540,20 +567,20 @@ class NWN::Gff::Reader
         @field_data[data_or_offset + 1, len]
 
       when :cexolocstr
+        exostr = Gff::CExoLocString.new
         total_size, str_ref, str_count =
           @field_data[data_or_offset, 12].unpack("VVV")
         all = @field_data[data_or_offset + 12, total_size]
         field._str_ref = str_ref
 
-        r = []
         str_count.times {
           id, len = all.unpack("VV")
           str = all[8, len].unpack("a*")[0]
           all = all[(8 + len)..-1]
-          r << Gff::CExoLocString.new(id, str)
+          exostr[id] = str
         }
         len = total_size + 4
-        r
+        exostr
 
       when :void
         len = @field_data[data_or_offset, 4].unpack("V")[0]
@@ -763,24 +790,26 @@ private
           @field_data << [v.value.size, v.value].pack("Va*")
 
         when :cexolocstr
-          raise GffError, "type = cexolocstr, but value not an array" unless
-            v.value.is_a?(Array)
+          raise GffError, "type = cexolocstr, but value not a exolocstr" unless
+            v.value.is_a?(NWN::Gff::CExoLocString)
 
           fields_of_this_struct << add_data_field(v.type, k, @field_data.size)
 
           # total size (4), str_ref (4), str_count (4)
-          total_size = 8 + v.value.inject(0) {|t,x| t + x.text.size + 8}
+          total_size = 8
+          v.value.each {|kk,vv|
+            total_size += vv.size + 8
+          }
           @field_data << [
             total_size,
             v._str_ref,
             v.value.size
           ].pack("VVV")
 
-          v.value.each {|s|
-            @field_data << [s.language, s.text.size, s.text].pack("VVa*")
+          v.value.each {|k,v|
+            @field_data << [k, v.size, v].pack("VVa*")
           }
 
-
         else
           raise GffError, "Unknown data type: #{v.type}"
       end

data/lib/nwn/helpers.rb

@@ -0,0 +1,180 @@
+require 'nwn/gff'
+require 'nwn/twoda'
+
+module NWN
+
+  module TwoDA
+
+    # This is a simple 2da cache.
+    module Cache
+
+      @_cache = {}
+      @_root = nil
+
+      # Set the file system path where all 2da files reside.
+      # Call this on application startup.
+      def self.setup root
+        @_root = root
+      end
+
+      # Get the 2da file with the given name. +name+ is without extension.
+      def self.get(name)
+        raise Exception, "You need to set up the cache first through Cache.setup." unless @_root
+        @_cache[name.downcase] ||= read_2da(name.downcase)
+      end
+
+      def self.read_2da name # :nodoc:
+        Table.parse IO.read(@_root + '/' + name + '.2da')
+      end
+
+      private_class_method :read_2da
+    end
+  end
+
+  module Gff
+    module Helpers
+
+      # This sets up the IPRP cache. Used internally; no need to call this yourself.
+      def self._ip_cache_setup #:nodoc:
+        return if defined? @costtables
+        @costtables = {}
+        @paramtables = {}
+        @costtable_index = NWN::TwoDA::Cache.get('iprp_costtable')
+        @paramtable_index = NWN::TwoDA::Cache.get('iprp_paramtable')
+        @costtable_index.by_col('Name').each_with_index {|p,idx|
+          next if @costtables[p.downcase]
+          @costtables[p.downcase] = @costtables[idx] = NWN::TwoDA::Cache.get(p.downcase)
+        }
+        @paramtable_index.by_col('TableResRef').each_with_index {|p,idx|
+          next if @paramtables[p.downcase]
+          @paramtables[p.downcase] = @paramtables[idx] = NWN::TwoDA::Cache.get(p.downcase)
+        }
+        @properties = NWN::TwoDA::Cache.get('itemprops')
+        @propdef = NWN::TwoDA::Cache.get('itempropdef')
+        @subtypes = []
+        @propdef.by_col('SubTypeResRef').each_with_index {|st, idx|
+          @subtypes[idx] = NWN::TwoDA::Cache.get(st.downcase) if st != "****"
+        }
+        @prop_id_to_costtable = []
+        @propdef.by_col('CostTableResRef').each_with_index {|st, idx|
+          @prop_id_to_costtable[idx] = st.to_i if st != "****"
+        }
+        @prop_id_to_param1 = []
+        @propdef.by_col('Param1ResRef').each_with_index {|st, idx|
+          @prop_id_to_param1[idx] = st.to_i if st != "****"
+        }
+      end
+
+      def self.resolve_or_match_partial name_spec, list #:nodoc:
+        name_spec = name_spec.downcase
+
+        list.each {|l|
+          return l if l.downcase == name_spec
+        }
+
+        substrings = list.select {|l| l.downcase.index(name_spec) }
+        if substrings.size == 1
+          return substrings[0]
+        elsif substrings.size > 1
+          raise ArgumentError, "Cannot resolve #{name_spec}. Partial matches: #{substrings.inspect}."
+        end
+
+        raise ArgumentError, "Cannot resolve #{name_spec}."
+      end
+
+      # This creates a NWN::Gff::Struct describing the item property in question.
+      #
+      # [+name+]    The iprp name to resolve, for example <tt>Damage_Bonus_vs_Racial_Group</tt>
+      # [+subtype+] The iprp subtype, for example <tt>Elf</tt>
+      # [+value+]   The iprp value, for example <tt>2d12</tt>
+      # [+param+]  The iprp param1, for example <tt>Acid</tt>
+      # [+chance+]  The iprp appearance chance (whats this?)
+      #
+      # Depends on the 2da cache set up correctly.
+      #
+      # Note that the given arguments can be resolved with partial matches as well, as long
+      # as they are unique. (<tt>Fir -> Fire</tt>)
+      #
+      # Arguments are case-insensitive.
+      def self.item_property name, subtype = nil, value = nil, param1 = nil, chance_appear = 100
+        self._ip_cache_setup
+
+        struct = NWN::Gff::Struct.new
+
+        name = resolve_or_match_partial name, @properties.by_col('Label')
+        index = @properties.by_col('Label').index(name)
+        raise ArgumentError, "Cannot find property #{name}" unless index
+
+        raise ArgumentError, "Property #{name} needs subtype of type #{NWN::TwoDA::Cache.get('itempropdef').by_col('SubTypeResRef', index)}, but none given." if
+          @subtypes[index] && !subtype
+        raise ArgumentError, "Property #{name} does not need subtype, but subtype given." if
+          !@subtypes[index] && subtype
+
+        subindex = 255
+
+        if subtype
+          subtype = resolve_or_match_partial subtype, @subtypes[index].by_col('Label')
+
+          subindex = @subtypes[index].by_col('Label').index(subtype)
+          raise ArgumentError, "Cannot find subtype #{subtype} for property #{name}" unless
+            subindex
+
+          raise ArgumentError, "Property #{name} requires a cost value of type #{@costtable_index.by_row(@prop_id_to_costtable[index], 'Name')}, but none given" if
+            !value && @prop_id_to_costtable[index]
+          raise ArgumentError, "Property #{name} does not require a cost value, but value given" if
+            value && !@prop_id_to_costtable[index]
+        end
+
+        _cost = 255
+        _cost_value = 0
+
+        if value
+          ct = @prop_id_to_costtable[index]
+          value = resolve_or_match_partial value, @costtables[ct.to_i].by_col('Label')
+
+          costvalue = @costtables[ct.to_i].by_col('Label').index(value)
+          raise ArgumentError, "Cannot find CostValue for #{value}" unless costvalue
+          _cost = ct
+          _cost_value = costvalue
+        end
+        struct.merge!({
+          'CostTable' => Element.new('CostTable', :byte, _cost),
+          'CostValue' => Element.new('CostValue', :word, _cost_value)
+        })
+
+
+        raise ArgumentError, "Property #{name} requires a param1 value of type #{@paramtable_index.by_row(@prop_id_to_param1[index], 'TableResRef')}, but none given" if
+          !param1 && @prop_id_to_param1[index]
+        raise ArgumentError, "Property #{name} does not require a param1 value, but value given" if
+          param1 && !@prop_id_to_param1[index]
+
+        _param1 = 255
+        _param1_value = 0
+
+        if param1
+          pt = @prop_id_to_param1[index]
+          param1 = resolve_or_match_partial param1, @paramtables[pt.to_i].by_col('Label')
+
+          param1value = @paramtables[pt.to_i].by_col('Label').index(param1)
+          raise ArgumentError, "Cannot find Param1 for #{param1}" unless param1value
+          _param1 = pt
+          _param1_value = param1value
+        end
+        struct.merge!({
+          'Param1' => Element.new('Param1', :byte, _param1),
+          'Param1Value' => Element.new('Param1Value', :byte, _param1_value)
+        })
+
+        struct.merge!({
+          'PropertyName' => Element.new('PropertyName', :word, index),
+          'Subtype' => Element.new('Subtype', :word, subindex),
+          'ChanceAppear' => Element.new('ChanceAppear', :byte, chance_appear)
+        })
+
+        struct.struct_id = 0
+        struct
+      end
+
+    end
+  end
+end

data/lib/nwn/twoda.rb

@@ -44,22 +44,34 @@ module NWN
         raise ArgumentError, "Not valid 2da: No valid header found" if
           magic != "2DA V2.0"
 
-        raise ArgumentError,
-          "Not avalid 2da: Second line should be empty."  unless
-            empty == ""
+
+        if empty != ""
+          $stderr.puts "Warning: second line of 2da not empty, continuing anyways."
+          data = [header].concat(data)
+          header = empty
+        end
 
         header = Shellwords.shellwords(header.strip)
         data.map! {|line|
           Shellwords.shellwords(line.strip)
         }
 
+        data.reject! {|line|
+          line.size == 0
+        }
+
+        offset = 0
         data.each_with_index {|row, idx|
-          raise ArgumentError, "2da non-continoous: row #{idx} has a non-matching ID #{row[0]}." if idx != row[0].to_i
+          if (idx + offset) != row[0].to_i
+            $stderr.puts "Warning: row #{idx} has a non-matching ID #{row[0]} (while parsing #{row[0,3].join(' ')})."
+            offset += (row[0].to_i - idx)
+          end
+
           # [1..-1]: Strip off the ID
-          data[idx] = row = row[1..-1]
+          data[row[0].to_i] = row = row[1..-1]
 
           raise ArgumentError,
-            "Row #{idx} does not have the appropriate amount of cells (has: #{row.size}, want: #{header.size})." if
+            "Row #{idx} does not have the appropriate amount of cells (has: #{row.size}, want: #{header.size}) (while parsing #{row[0,3].join(' ')})." if
               row.size != header.size
         }
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: nwn-lib
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2008-07-03 00:00:00 +02:00
+  version: 0.3.0
+date: 2008-07-08 00:00:00 +02:00
 summary: a ruby library for accessing Neverwinter Nights resource files
 require_paths: 
 - lib
@@ -35,11 +35,15 @@ files:
 - Rakefile
 - bin/nwn-gff-irb
 - bin/nwn-gff-print
+- bin/nwn-gff-import
 - spec/spec.opts
 - spec/rcov.opts
 - lib/nwn
 - lib/nwn/twoda.rb
 - lib/nwn/gff.rb
+- lib/nwn/helpers.rb
+- BINARIES
+- CHEATSHEET
 test_files: []
 
 rdoc_options: 
@@ -54,11 +58,14 @@ rdoc_options:
 - ^(examples|extras)/
 extra_rdoc_files: 
 - README
+- BINARIES
+- CHEATSHEET
 - CHANGELOG
 - COPYING
 executables: 
 - nwn-gff-print
 - nwn-gff-irb
+- nwn-gff-import
 extensions: []
 
 requirements: []