pgtools 1.0.0 → 1.0.1

data/lib/bayonetta/pkz.rb

@@ -1,63 +1,63 @@
-module Bayonetta
-
-  class PKZFile < LibBin::Structure
-
-    class FileDescriptor < LibBin::Structure
-      uint32 :offset_name
-      uint32 :offset_compression
-      uint64 :size
-      uint64 :offset
-      uint64 :compressed_size
-      string :name, offset: 'offset_name + ..\header.offset_file_descriptors + ..\header.num_files * 0x20'
-      string :compression, offset: 'offset_compression + ..\header.offset_file_descriptors + ..\header.num_files * 0x20'
-    end
-
-    class Header < LibBin::Structure
-      uint32 :id
-      int32  :unknown
-      uint64 :size
-      uint32 :num_files
-      uint32 :offset_file_descriptors
-      uint32 :length_file_name_table
-      uint32 :unknown
-    end
-
-    register_field :header, Header
-    register_field :file_descriptors, FileDescriptor, count: 'header.num_files',
-                   offset: 'header.offset_file_descriptors + __iterator * 0x20', sequence: true
-
-    def self.is_big?(f)
-      f.rewind
-      block = lambda { |int64|
-        id = f.read(4)
-        raise "Invalid id #{id.inspect}!" if id != "pkzl".b
-        f.read(4)
-        size = f.read(8).unpack(int64).first
-        size == f.size
-      }
-      big = block.call("q>")
-      f.rewind
-      small = block.call("q<")
-      f.rewind
-      raise "Invalid data!" unless big ^ small
-      return big
-    end
-
-    def self.load(input_name)
-      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
-        input = input_name
-      else
-        input = File.open(input_name, "rb")
-      end
-      input_big = is_big?(input)
-      pkz = self::new
-      pkz.instance_variable_set(:@__was_big, input_big)
-      pkz.__load(input, input_big)
-      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
-
-      pkz
-    end
-
-  end
-
-end
+module Bayonetta
+
+  class PKZFile < LibBin::Structure
+
+    class FileDescriptor < LibBin::Structure
+      uint32 :offset_name
+      uint32 :offset_compression
+      uint64 :size
+      uint64 :offset
+      uint64 :compressed_size
+      string :name, offset: 'offset_name + ..\header.offset_file_descriptors + ..\header.num_files * 0x20'
+      string :compression, offset: 'offset_compression + ..\header.offset_file_descriptors + ..\header.num_files * 0x20'
+    end
+
+    class Header < LibBin::Structure
+      uint32 :id
+      int32  :unknown
+      uint64 :size
+      uint32 :num_files
+      uint32 :offset_file_descriptors
+      uint32 :length_file_name_table
+      uint32 :unknown
+    end
+
+    register_field :header, Header
+    register_field :file_descriptors, FileDescriptor, count: 'header.num_files',
+                   offset: 'header.offset_file_descriptors + __iterator * 0x20', sequence: true
+
+    def self.is_big?(f)
+      f.rewind
+      block = lambda { |int64|
+        id = f.read(4)
+        raise "Invalid id #{id.inspect}!" if id != "pkzl".b
+        f.read(4)
+        size = f.read(8).unpack(int64).first
+        size == f.size
+      }
+      big = block.call("q>")
+      f.rewind
+      small = block.call("q<")
+      f.rewind
+      raise "Invalid data!" unless big ^ small
+      return big
+    end
+
+    def self.load(input_name)
+      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+        input = input_name
+      else
+        input = File.open(input_name, "rb")
+      end
+      input_big = is_big?(input)
+      pkz = self::new
+      pkz.instance_variable_set(:@__was_big, input_big)
+      pkz.__load(input, input_big)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+
+      pkz
+    end
+
+  end
+
+end

data/lib/bayonetta/tools/bxm_decoder.rb

@@ -1,23 +1,23 @@
-require 'optparse'
-require_relative '../../bayonetta'
-include Bayonetta
-
-OptionParser.new do |opts|
-  opts.banner = <<EOF
-Usage: bxm_decoder target_file
-  Decode the target bxm file into xml
-
-EOF
-  opts.on("-h", "--help", "Prints this help") do
-    puts opts
-    exit
-  end
-
-end.parse!
-
-input_file = ARGV[0]
-
-File::open(input_file, "rb") { |f|
-  bxm = BXMFile::load(f)
-  print bxm.to_xml
-}
+require 'optparse'
+require_relative '../../bayonetta'
+include Bayonetta
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: bxm_decoder target_file
+  Decode the target bxm file into xml
+
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+input_file = ARGV[0]
+
+File::open(input_file, "rb") { |f|
+  bxm = BXMFile::load(f)
+  print bxm.to_xml
+}

data/lib/bayonetta/tools/bxm_encoder.rb

@@ -1,37 +1,37 @@
-require 'optparse'
-require 'nokogiri'
-require_relative '../../bayonetta'
-include Bayonetta
-
-options = {
-  tag: :BXM,
-  output: nil
-}
-
-opts = OptionParser.new do |parser|
-  parser.banner = <<EOF
-Usage: bxm_encoder [options] [XML_FILE]
-  Encode the pecified xml file int binary xml format. Unlessspecified
-  output will be along with the original file with a bxm extension.
-  If no file is given use stdin, but --output must be specified.
-EOF
-  parser.on("-t", "--tag TAG", [:XML, :BXM], "Select tag to use (BXM, XML) default BXM")
-  parser.on("-o", "--output filename", "Select output file name")
-end
-opts.parse!(into: options)
-
-tag = (options[:tag].to_s + "\0").b
-
-output_name = options[:output]
-if ARGV[0]
-  ouput_name = File.join(File.dirname(ARGV[0]), File.basename(ARGV[0], File.extname(ARGV[0])))+".bxm" unless output_name
-  input_file = File::open(ARGV[0], "rb")
-else
-  raise "unspecified output file" unless output_name
-  input_file = $stdin
-end
-
-bxm = BXMFile::from_xml(Nokogiri::XML(input_file.read), tag)
-bxm.dump(output_name)
-
-input_file.close if ARGV[0]
+require 'optparse'
+require 'nokogiri'
+require_relative '../../bayonetta'
+include Bayonetta
+
+options = {
+  tag: :BXM,
+  output: nil
+}
+
+opts = OptionParser.new do |parser|
+  parser.banner = <<EOF
+Usage: bxm_encoder [options] [XML_FILE]
+  Encode the pecified xml file int binary xml format. Unlessspecified
+  output will be along with the original file with a bxm extension.
+  If no file is given use stdin, but --output must be specified.
+EOF
+  parser.on("-t", "--tag TAG", [:XML, :BXM], "Select tag to use (BXM, XML) default BXM")
+  parser.on("-o", "--output filename", "Select output file name")
+end
+opts.parse!(into: options)
+
+tag = (options[:tag].to_s + "\0").b
+
+output_name = options[:output]
+if ARGV[0]
+  ouput_name = File.join(File.dirname(ARGV[0]), File.basename(ARGV[0], File.extname(ARGV[0])))+".bxm" unless output_name
+  input_file = File::open(ARGV[0], "rb")
+else
+  raise "unspecified output file" unless output_name
+  input_file = $stdin
+end
+
+bxm = BXMFile::from_xml(Nokogiri::XML(input_file.read), tag)
+bxm.dump(output_name)
+
+input_file.close if ARGV[0]

data/lib/bayonetta/tools/clh_convert.rb

@@ -1,60 +1,60 @@
-require 'optparse'
-require_relative '../../bayonetta'
-require 'yaml'
-include Bayonetta
-$bone_map = { }
-$options = {
-  remap_bones: false,
-  output: nil
-}
-OptionParser.new do |opts|
-  opts.banner = <<EOF
-Usage: clh_convert target_file [options]
-  Convert a Bayonetta 2 _clh.bxm file to bayonetta format, optionally
-  remapping the bones, or remap a Bayonetta 1 clh file. By default
-  output will be in the ./clx_output folder.
-EOF
-
-  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
-    $options[:remap_bones] = true
-    if File::exist?(bone_lists)
-      $bone_map.merge! YAML::load_file(bone_lists)
-    else
-      lists = bone_lists.split("/")
-      p input_list = eval(lists.first).to_a
-      p output_list = eval(lists.last).to_a
-      $bone_map.merge! input_list.zip(output_list).to_h
-    end
-  end
-
-  opts.on("-o", "--output=filename", "file to output result") do |name|
-    $options[:output] = name
-  end
-
-  opts.on("-h", "--help", "Prints this help") do
-    puts opts
-    exit
-  end
-
-end.parse!
-
-$bone_map.merge!( { 4095 => 4095 } )
-
-Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
-
-input_file = ARGV[0]
-raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
-
-output_file = $options[:output]
-
-if File.extname(ARGV[0]) == ".bxm"
-  raise "Invalid clh file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clh.bxm")
-  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clh.bxm",".clh")) unless output_file
-  clh = CLHFile::load_bxm(input_file)
-else
-  raise "Invalid clh file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clh")
-  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
-  clh = CLHFile::load(input_file)
-end
-clh.remap($bone_map) if $options[:remap_bones]
-clh.dump(output_file)
+require 'optparse'
+require_relative '../../bayonetta'
+require 'yaml'
+include Bayonetta
+$bone_map = { }
+$options = {
+  remap_bones: false,
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: clh_convert target_file [options]
+  Convert a Bayonetta 2 _clh.bxm file to bayonetta format, optionally
+  remapping the bones, or remap a Bayonetta 1 clh file. By default
+  output will be in the ./clx_output folder.
+EOF
+
+  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
+    $options[:remap_bones] = true
+    if File::exist?(bone_lists)
+      $bone_map.merge! YAML::load_file(bone_lists)
+    else
+      lists = bone_lists.split("/")
+      p input_list = eval(lists.first).to_a
+      p output_list = eval(lists.last).to_a
+      $bone_map.merge! input_list.zip(output_list).to_h
+    end
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+$bone_map.merge!( { 4095 => 4095 } )
+
+Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
+
+input_file = ARGV[0]
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+
+if File.extname(ARGV[0]) == ".bxm"
+  raise "Invalid clh file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clh.bxm")
+  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clh.bxm",".clh")) unless output_file
+  clh = CLHFile::load_bxm(input_file)
+else
+  raise "Invalid clh file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clh")
+  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
+  clh = CLHFile::load(input_file)
+end
+clh.remap($bone_map) if $options[:remap_bones]
+clh.dump(output_file)

data/lib/bayonetta/tools/clp_convert.rb

@@ -1,70 +1,70 @@
-require 'optparse'
-require_relative '../../bayonetta'
-require 'yaml'
-include Bayonetta
-$bone_map = { }
-$options = {
-  remap_bones: false,
-  fix: true,
-  poly: true,
-  output: nil
-}
-OptionParser.new do |opts|
-  opts.banner = <<EOF
-Usage: clp_convert target_file [options]
-  Convert a Bayonetta 2 _clp.bxm file to bayonetta format, optionally
-  remapping the bones, or remap a Bayonetta 1 clp file. By default
-  output will be in the ./clx_output folder.
-EOF
-
-  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
-    $options[:remap_bones] = true
-    if File::exist?(bone_lists)
-      $bone_map.merge! YAML::load_file(bone_lists)
-    else
-      lists = bone_lists.split("/")
-      p input_list = eval(lists.first).to_a
-      p output_list = eval(lists.last).to_a
-      $bone_map.merge! input_list.zip(output_list).to_h
-    end
-  end
-
-  opts.on("-f", "--[no-]fix", "Map no_fix values (default true)") do |fix|
-    $options[:fix] = fix
-  end
-
-  opts.on("-p", "--[no-]poly", "Map no_poly values (default true)") do |poly|
-    $options[:poly] = poly
-  end
-
-  opts.on("-o", "--output=filename", "file to output result") do |name|
-    $options[:output] = name
-  end
-
-  opts.on("-h", "--help", "Prints this help") do
-    puts opts
-    exit
-  end
-
-end.parse!
-
-$bone_map.merge!( { 4095 => 4095 } )
-
-Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
-
-input_file = ARGV[0]
-raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
-
-output_file = $options[:output]
-
-if File.extname(ARGV[0]) == ".bxm"
-  raise "Invalid clp file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clp.bxm")
-  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clp.bxm",".clp")) unless output_file
-  clp = CLPFile::load_bxm(input_file)
-else
-  raise "Invalid clp file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clp")
-  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
-  clp = CLPFile::load(input_file)
-end
-clp.remap($bone_map, $options[:poly], $options[:fix]) if $options[:remap_bones]
-clp.dump(output_file)
+require 'optparse'
+require_relative '../../bayonetta'
+require 'yaml'
+include Bayonetta
+$bone_map = { }
+$options = {
+  remap_bones: false,
+  fix: true,
+  poly: true,
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: clp_convert target_file [options]
+  Convert a Bayonetta 2 _clp.bxm file to bayonetta format, optionally
+  remapping the bones, or remap a Bayonetta 1 clp file. By default
+  output will be in the ./clx_output folder.
+EOF
+
+  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
+    $options[:remap_bones] = true
+    if File::exist?(bone_lists)
+      $bone_map.merge! YAML::load_file(bone_lists)
+    else
+      lists = bone_lists.split("/")
+      p input_list = eval(lists.first).to_a
+      p output_list = eval(lists.last).to_a
+      $bone_map.merge! input_list.zip(output_list).to_h
+    end
+  end
+
+  opts.on("-f", "--[no-]fix", "Map no_fix values (default true)") do |fix|
+    $options[:fix] = fix
+  end
+
+  opts.on("-p", "--[no-]poly", "Map no_poly values (default true)") do |poly|
+    $options[:poly] = poly
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+$bone_map.merge!( { 4095 => 4095 } )
+
+Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
+
+input_file = ARGV[0]
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+
+if File.extname(ARGV[0]) == ".bxm"
+  raise "Invalid clp file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clp.bxm")
+  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clp.bxm",".clp")) unless output_file
+  clp = CLPFile::load_bxm(input_file)
+else
+  raise "Invalid clp file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clp")
+  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
+  clp = CLPFile::load(input_file)
+end
+clp.remap($bone_map, $options[:poly], $options[:fix]) if $options[:remap_bones]
+clp.dump(output_file)

data/lib/bayonetta/tools/clw_convert.rb

@@ -1,60 +1,60 @@
-require 'optparse'
-require_relative '../../bayonetta'
-require 'yaml'
-include Bayonetta
-$bone_map = { }
-$options = {
-  remap_bones: false,
-  output: nil
-}
-OptionParser.new do |opts|
-  opts.banner = <<EOF
-Usage: clw_convert target_file [options]
-  Convert a Bayonetta 2 _clw.bxm file to bayonetta format, optionally
-  remapping the bones, or remap a Bayonetta 1 clw file. By default
-  output will be in the ./clx_output folder.
-EOF
-
-  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
-    $options[:remap_bones] = true
-    if File::exist?(bone_lists)
-      $bone_map.merge! YAML::load_file(bone_lists)
-    else
-      lists = bone_lists.split("/")
-      p input_list = eval(lists.first).to_a
-      p output_list = eval(lists.last).to_a
-      $bone_map.merge! input_list.zip(output_list).to_h
-    end
-  end
-
-  opts.on("-o", "--output=filename", "file to output result") do |name|
-    $options[:output] = name
-  end
-
-  opts.on("-h", "--help", "Prints this help") do
-    puts opts
-    exit
-  end
-
-end.parse!
-
-$bone_map.merge!( { -1 => -1 } )
-
-Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
-
-input_file = ARGV[0]
-raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
-
-output_file = $options[:output]
-
-if File.extname(ARGV[0]) == ".bxm"
-  raise "Invalid clw file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clw.bxm")
-  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clw.bxm",".clw")) unless output_file
-  clw = CLWFile::load_bxm(input_file)
-else
-  raise "Invalid clw file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clw")
-  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
-  clw = CLWFile::load(input_file)
-end
-clw.remap($bone_map) if $options[:remap_bones]
-clw.dump(output_file)
+require 'optparse'
+require_relative '../../bayonetta'
+require 'yaml'
+include Bayonetta
+$bone_map = { }
+$options = {
+  remap_bones: false,
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: clw_convert target_file [options]
+  Convert a Bayonetta 2 _clw.bxm file to bayonetta format, optionally
+  remapping the bones, or remap a Bayonetta 1 clw file. By default
+  output will be in the ./clx_output folder.
+EOF
+
+  opts.on("-r", "--remap-bones=BONELISTS", "Remap specified bones, either lists separated by / or a yaml hash table") do |bone_lists|
+    $options[:remap_bones] = true
+    if File::exist?(bone_lists)
+      $bone_map.merge! YAML::load_file(bone_lists)
+    else
+      lists = bone_lists.split("/")
+      p input_list = eval(lists.first).to_a
+      p output_list = eval(lists.last).to_a
+      $bone_map.merge! input_list.zip(output_list).to_h
+    end
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+$bone_map.merge!( { -1 => -1 } )
+
+Dir.mkdir("clx_output") unless Dir.exist?("clx_output")
+
+input_file = ARGV[0]
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+output_file = $options[:output]
+
+if File.extname(ARGV[0]) == ".bxm"
+  raise "Invalid clw file #{input_file}" unless File.basename(ARGV[0]).end_with?("_clw.bxm")
+  output_file = File.join("clx_output", File.basename(ARGV[0]).gsub("_clw.bxm",".clw")) unless output_file
+  clw = CLWFile::load_bxm(input_file)
+else
+  raise "Invalid clw file #{input_file}" unless File.basename(ARGV[0]).end_with?(".clw")
+  output_file = File.join("clx_output", File.basename(ARGV[0])) unless output_file
+  clw = CLWFile::load(input_file)
+end
+clw.remap($bone_map) if $options[:remap_bones]
+clw.dump(output_file)