nwn-lib 0.3.6 → 0.4.0

data/lib/nwn/gff/writer.rb

@@ -0,0 +1,201 @@
+class NWN::Gff::Writer
+  include NWN
+  include NWN::Gff
+
+  attr_reader :bytes
+
+  def initialize(gff, data_type = nil)
+    @gff = gff
+    @data_type = data_type
+
+    @structs = []
+    @fields = []
+    @labels = []
+    @field_indices = []
+    @list_indices = []
+    @field_data = ""
+
+    write_all
+  end
+
+  # Takes a NWN::Gff::Gff object and dumps it as raw bytes,
+  # including the header.
+  def self.dump(gff, data_type = nil)
+    self.new(gff, data_type).bytes
+  end
+
+private
+
+  def get_label_id_for_label str
+    @labels << str unless @labels.index(str)
+    @labels.index(str)
+  end
+
+  def add_data_field type, label, content
+    label_id = get_label_id_for_label label
+    @fields.push Types.index(type), label_id, content
+    (@fields.size - 1) / 3
+  end
+
+  def write_all
+    data = []
+    write_struct @gff
+
+    c_offset = 0
+    data << [
+      @data_type || @gff.data_type,
+      @gff.data_version,
+
+      # Offset of Struct array as bytes from the beginning of the file
+      c_offset += 56,
+      # Number of elements in Struct array
+      @structs.size / 3,
+
+      # Offset of Field array as bytes from the beginning of the file
+      fields_start = c_offset += @structs.size / 3 * 12,
+      # Number of elements in Field array
+      @fields.size / 3,
+
+      # Offset of Label array as bytes from the beginning of the file
+      c_offset += @fields.size / 3 * 12,
+      # Number of elements in Label array
+      @labels.size,
+
+      # Offset of Field Data as bytes from the beginning of the file
+      c_offset += @labels.size * 16,
+      # Number of bytes in Field Data block
+      @field_data.size,
+
+      # Offset of Field Indices array as bytes from the beginning of the file
+      c_offset += @field_data.size,
+      # Number of bytes in Field Indices array
+      @field_indices.size * 4,
+
+      # Offset of List Indices array as bytes from the beginning of the file
+      c_offset += @field_indices.size * 4,
+      # Number of bytes in List Indices array
+      @list_indices.size * 4
+
+    ].pack("A4a4 VV VV VV VV VV VV")
+
+    data << @structs.pack("V*")
+    data << @fields.pack("V*")
+    data << @labels.pack("a16" * @labels.size)
+    data << @field_data
+    data << @field_indices.pack("V*")
+    data << @list_indices.pack("V*")
+
+    @bytes = data.join("")
+  end
+
+  def write_struct struct
+    raise GffError, "struct invalid: #{struct.inspect}" unless struct.is_a?(NWN::Gff::Struct)
+    raise GffError, "struct_id missing from struct" unless struct.struct_id
+
+    # This holds all field label ids this struct has as a member
+    fields_of_this_struct = []
+
+    # This will hold the index of this struct
+    index = @structs.size / 3
+
+    @structs.push struct.struct_id, 0, 0
+
+    struct.sort.each {|k,v|
+      raise GffError, "Empty label." if !k || k == ""
+
+      case v.field_type
+        # simple data types
+        when :byte, :char, :word, :short, :dword, :int, :float
+          format = Formats[v.field_type]
+          fields_of_this_struct << add_data_field(v.field_type, k, [v.field_value].pack(format).unpack("V")[0])
+
+        # complex data types
+        when :dword64, :int64, :double, :void
+          fields_of_this_struct << add_data_field(v.field_type, k, @field_data.size)
+          format = Formats[v.field_type]
+          @field_data << case v.field_type
+            when :dword64
+              [
+                ( v.field_value / (2**32) ) & 0xffffffff,
+                v.field_value % (2**32)
+              ].pack("II")
+            when :void
+              [ v.field_value.size / 2, v.field_value ].pack("VH*")
+            else
+              [v.field_value].pack(format)
+          end
+
+        when :struct
+          raise GffError, "type = struct, but value not a hash" unless
+            v.field_value.is_a?(Gff::Struct)
+
+          fields_of_this_struct << add_data_field(v.field_type, k, write_struct(v.field_value))
+
+        when :list
+          raise GffError, "type = list, but value not an array" unless
+            v.field_value.is_a?(Array)
+
+          fields_of_this_struct << add_data_field(v.field_type, k, 4 * @list_indices.size)
+
+          count = v.field_value.size
+          tmp = @list_indices.size
+          @list_indices << count
+          count.times {
+            @list_indices << 0
+          }
+
+          v.field_value.each_with_index do |kk, idx|
+            vv = write_struct(kk)
+            @list_indices[ idx + tmp + 1 ] = vv
+          end
+
+        when :resref
+          fields_of_this_struct << add_data_field(v.field_type, k, @field_data.size)
+          @field_data << [v.field_value.size, v.field_value].pack("Ca*")
+
+        when :cexostr
+          fields_of_this_struct << add_data_field(v.field_type, k, @field_data.size)
+          @field_data << [v.field_value.size, v.field_value].pack("Va*")
+
+        when :cexolocstr
+          raise GffError, "type = cexolocstr, but value not a hash (#{v.field_value.class})" unless
+            v.field_value.is_a?(Hash)
+
+          fields_of_this_struct << add_data_field(v.field_type, k, @field_data.size)
+
+          # total size (4), str_ref (4), str_count (4)
+          total_size = 8
+          v.field_value.each {|kk,vv|
+            total_size += vv.size + 8
+          }
+          @field_data << [
+            total_size,
+            v.str_ref,
+            v.field_value.size
+          ].pack("VVV")
+
+          v.field_value.each {|k,v|
+            @field_data << [k, v.size, v].pack("VVa*")
+          }
+
+        else
+          raise GffError, "Unknown data type: #{v.field_type}"
+      end
+    }
+
+    # id/type, data_or_offset, nr_of_fields
+    @structs[3 * (index) + 2] = fields_of_this_struct.size
+
+    if fields_of_this_struct.size < 1
+    elsif fields_of_this_struct.size == 1
+      @structs[3 * (index) + 1] = fields_of_this_struct[0]
+    else
+      # Offset into field_indices starting where are number of nr_of_fields
+      # dwords as indexes into @fields
+      @structs[3 * (index) + 1] = 4 * (@field_indices.size)
+      @field_indices.push *fields_of_this_struct
+    end
+
+    index
+  end
+end

data/lib/nwn/helpers.rb

@@ -2,38 +2,9 @@ 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
 
+    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

data/lib/nwn/infer.rb

@@ -0,0 +1,125 @@
+module NWN::Gff
+  @YAMLStructDefaults = {}
+
+#:stopdoc:
+  # This gets called for each parsed struct to set their container element
+  # values (see also gff/reader.rb, line 233-ish).
+  def self.__yaml_postparse parent, struct
+    struct.each {|label,element|
+      case element.field_type
+        when :list, :struct
+          [element.field_value].flatten.each {|item|
+            __yaml_postparse(element, item)
+            item.element = element
+          }
+      end
+    }
+  end
+#:startdoc:
+
+  # This loads structs defaults from the given file, which will
+  # be used for field_type inferring and autocompletion/filtering of default values.
+  # A sample file has been provided with nwn-lib, called gff-bioware.yml
+  def self.load_struct_defaults file
+    @YAMLStructDefaults = YAML.load(IO.read(file))
+    new = {}
+    @YAMLStructDefaults.each {|k,v|
+      new[Regexp.new(k + '$')] = v
+    }
+    @YAMLStructDefaults = new
+  end
+
+  def self.get_struct_defaults
+    @YAMLStructDefaults || {}
+  end
+
+  def self.get_struct_defaults_for path, key
+    sd = NWN::Gff.get_struct_defaults
+    sd.keys.each {|rx|
+      next unless path =~ rx
+      return sd[rx][key] if sd[rx][key] != nil
+    }
+    nil
+  end
+
+  def self.get_struct_default_type path, key
+    dd = get_struct_defaults_for(path, key)
+    dd.is_a?(Array) ? dd[0] : dd
+  end
+
+  def self.get_struct_default_value path, key
+    dd = get_struct_defaults_for(path, key)
+    dd.is_a?(Array) ? dd[1] : nil
+  end
+end
+
+module NWN::Gff::Struct
+  # Returns true if we can later infer the struct_id with the given path.
+  def can_infer_struct_id?
+    v = NWN::Gff.get_struct_defaults_for(self.path, '__struct_id')
+    v == @struct_id || v == "iterative" || v == "inline"
+  end
+
+  # Returns true if we can infer the data version of this struct (if it has parent).
+  def can_infer_data_version?
+    @data_version == DEFAULT_DATA_VERSION || (
+      @element && @element.parent && @element.parent.data_version == @data_version
+    )
+  end
+end
+
+module NWN::Gff::Cexolocstr
+  def field_value_as_compact
+    !can_infer_str_ref? ? field_value.merge({'str_ref' => str_ref}) : field_value
+  end
+end
+
+module NWN::Gff::Field
+  YAMLCompactableFields = [:byte, :char, :word, :short, :dword, :int, :void,
+    :dword64, :int64, :float, :double, :cexostr, :resref, :cexolocstr, :list]
+
+  # Returns true if we can later infer the field type.
+  def can_infer_type?
+    expected = NWN::Gff.get_struct_default_type(@parent.path, field_label)
+
+    raise NWN::Gff::GffError, "#{field_label} has field_type " +
+      "#{field_type.inspect}, but infer data says #{expected.inspect}." if
+        expected && expected != field_type
+
+    expected == field_type
+  end
+
+  # Returns true if we can later infer the default value.
+  def can_infer_value?
+    NWN::Gff.get_struct_default_value(@parent.path, field_label) == field_value
+  end
+
+  # Returns true if we can infer the str ref later on.
+  def can_infer_str_ref?
+    !has_str_ref? || (d = NWN::Gff.get_struct_defaults_for(@parent.path, field_label) && d && d[2] != nil)
+  end
+
+  # Can we print this field without any syntactic gizmos?
+  def can_compact_print?
+
+    YAMLCompactableFields.index(field_type) &&
+      # exolocs print their str_ref along with their language keys
+      (field_type == :cexolocstr || can_infer_str_ref?) &&
+      can_infer_type?
+  end
+
+  def can_compact_as_list?
+     NWN::Gff.get_struct_defaults_for(self.path, '__compact') != nil &&
+      field_value.reject {|x|
+        x.can_infer_struct_id?
+      }.size == 0
+  end
+
+  def get_compact_as_list_field
+    NWN::Gff.get_struct_defaults_for(self.path, '__compact')
+  end
+
+  def field_value_as_compact
+    field_value
+  end
+end

data/lib/nwn/kivinen.rb

@@ -0,0 +1,55 @@
+module NWN::Gff::Struct
+
+    # yield (key, value) for each element, recursing into substructs.
+
+    # Parses +s+ as an arbitary GFF object and yields for each field found,
+    # with the proper prefix.
+    #
+    # [+prefix+]     Supply a prefix to add to the output.
+    # [+types_too+]  Yield type definitions as well (gffprint.pl -t).
+    # [+add_prefix+] Add a prefix <tt>(unknown type)</tt> of no type information can be derived from the input.
+    # [+file_type+]  File type override. If non-null, add a global struct header with the given file type (useful for passing to gffencode.pl)
+    # [+struct_id+]  Provide a struct_id override (if printing a struct).
+    def kivinen_format types_too = false, add_prefix = true, file_type = nil, struct_id = nil, &block
+
+      if types_too
+        yield("/", "")
+
+        ftype = file_type ? file_type : self.data_type
+        yield("/ ____file_type", ftype) if ftype
+        yield("/ ____file_version", self.data_version) if self.data_version
+
+        yield("/ ____struct_type", self.struct_id)
+      end
+
+      self.each_by_flat_path {|path, field|
+        case field
+          when String
+            yield(path, field)
+
+          when NWN::Gff::Struct
+            yield(path + "/", path)
+            yield(path + "/ ____struct_type", field.struct_id)
+
+          when NWN::Gff::Field
+
+            case field.field_type
+              when :list
+              when :struct
+                yield(path + "/", path)
+                yield(path + "/ ____struct_type", field.field_value.struct_id)
+              when :cexolocstr
+              else
+                yield(path, field.field_value)
+            end
+
+            yield(path + ". ____string_ref",field.str_ref) if
+              field.has_str_ref? || field.field_type == :cexolocstr
+
+            yield(path + ". ____type", NWN::Gff::Types.index(field.field_type)) if
+              types_too
+
+        end
+      }
+    end
+end

data/lib/nwn/scripting.rb

@@ -0,0 +1,129 @@
+# This module contains scripting functions and helpers.
+#
+# Include this if you want to eval nwn-gff-dsl scripts.
+module NWN::Gff::Scripting
+
+  class Sandbox
+    include NWN
+    include NWN::Gff::Scripting
+  end
+
+  # Run a script in a sandboxish environ.
+  # Returns true if the code modified run_on in any way.
+  def self.run_script code, run_on = nil, arguments = []
+    $code = code
+    $argv = arguments
+    $standalone = run_on.nil?
+    run_on ||= Sandbox.new
+
+    $script_obj_hash = run_on.hash
+    catch(:exit) {
+      begin
+        run_on.instance_eval $code
+      rescue => e
+        raise
+      end
+    }
+    $script_obj_hash != run_on.hash
+  end
+
+  # This script only runs for the following conditions (see #satisfy).
+  def want *what
+    obj = satisfy(*what)
+    unless obj
+      log "Wants #{what.inspect}, cannot satisfy - continuing."
+      throw(:exit)
+    end
+    obj
+  end
+
+  # Same as want, but error out (don't continue processing).
+  def need *what
+    satisfy(*what) or raise ArgumentError, "Needs #{what.inspect}, cannot satisfy - aborting."
+  end
+
+  # Call this to prevent nwn-gff from emitting output.
+  def stop_output
+    if $standalone
+      log "warn: no need to stop_output on standalone scripts"
+    else
+      log "#{$base_script}: not emitting any data."
+    end
+    $stop_output = true
+  end
+  
+  def will_output?
+    !$stop_output
+  end
+
+  # This checks if the currently-operating field or struct
+  # satisfies one of the given conditions.
+  #
+  # When you're running in standalone mode, the first argument
+  # is expected to be a file or IO stream that needs to satisfy
+  # the given conditions.
+  #
+  # Example:
+  #  need ARGV.shift, :bic, :utc, :uti
+  # will require the user to supply a filename as the first argument
+  # to the standalone script, which needs to resolve to a bic, utc, or
+  # uti data_type.
+  #
+  # Conditions can be:
+  # * A symbol describing the data_type, eg :utc
+  # * A symbol describing the field_type, eg :int
+  # * A module or class name
+  #
+  # Returns the object that satisfies the asked-for conditions,
+  # or nil if none can be given.
+  def satisfy *what
+    if $standalone
+      fn = what.shift
+      io = case fn
+        when String
+          IO.read(fn)
+        when IO
+          fn
+        else
+          return nil
+          #raise ArgumentError, "When running in standalone mode, " +
+          #  "`need', `want' and `satisfy' need a filename or a IO " +
+          #  "object to read from (usually the first script argument)."
+      end
+      obj = NWN::Gff.read(io, NWN::Gff.guess_file_format(fn))
+    else
+      obj = self
+    end
+
+    what.each {|w|
+      case w
+        when Class, Module
+          return obj if obj.is_a?(w)
+
+        when Symbol
+          case obj
+            when NWN::Gff::Struct
+              return obj if obj.data_type.downcase == w.to_s.downcase
+            when NWN::Gff::Field
+              return obj if obj.field_type.to_sdowncase == w.to_s.downcase
+          end
+      end
+
+    }
+
+    return nil
+  end
+
+
+  # Log a friendly message to stderr.
+  # Use this instead of puts, since SAFE levels greater than 0
+  # will prevent you from doing logging yourself.
+  def log *args
+    if $options
+      $stderr.puts [$base_script, " on ", $options[:infile], ": ", *args].join("")
+    else
+      $stderr.puts [$base_script, ": ", *args].join("")
+    end
+  end
+
+end