wolftrans 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5810f165d8477fd00571f8cf4c0b599f4ee2bd7
-  data.tar.gz: d3fb00f064a84ef6f740329fe26ea98158522ecc
+  metadata.gz: c841512ed31767357a132f115dd9c9d5d4d85ae3
+  data.tar.gz: 13b81d6e79ce6e6e7a3ca202073dd4b8c2a22dd8
 SHA512:
-  metadata.gz: 11fa3045617bc45a79ca011ee8f42f44e5d05e1bc0b11917395936b2f22e12471e4010aabf623a1a775db050013d4a29b583e468c82b9ee6e9e737d4a1e5f7a4
-  data.tar.gz: 8741262f4c7622bb688554f2e65bcb6273c5cbb7d6b917e6d3770ce24b94f6010f87d59813da42d02bf02b3a53fb0fda92f860f3fcccafd1c7faff45c5b2ef0f
+  metadata.gz: 4b63ce1e61df8e456faf61ae7064c8732dfc8626b75262641a9afe76b5f271c5e813daa97042435ea237fedf923e7129b74e363c6fbac6b5322f41a6316a5901
+  data.tar.gz: faea22c7bbf27d5e4171fa3056306014e869e4c57e4ea9c5697c6359a0a84255ae1b0ccf5ea14ee9d474d2fb00b8f4328790a96e93bbff84443b408d687ea7bc

data/.gitignore

@@ -0,0 +1,6 @@
+# Ignore generated files
+*.gem
+
+# Ignore any zip archives or extracted data in test/
+test/*/*
+test/*.zip

data/Rakefile

@@ -17,6 +17,10 @@ task :install => :build do
   system "gem install #{GEM_FILENAME}"
 end
 
+task :uninstall do
+  system "gem uninstall wolftrans --version #{WolfTrans::VERSION}"
+end
+
 task :clean do
   File.delete(GEM_FILENAME) if File.exist? GEM_FILENAME
 end

data/lib/wolfrpg/command.rb

@@ -1,5 +1,7 @@
 require 'wolfrpg/route'
 
+# Special thanks to vgperson for mapping most of these command IDs out.
+
 module WolfRpg
   class Command
     attr_reader :cid
@@ -13,6 +15,9 @@ module WolfRpg
     class Blank < Command
     end
 
+    class Checkpoint < Command
+    end
+
     class Message < Command
       def text
         @string_args[0]
@@ -34,15 +39,27 @@ module WolfRpg
       end
     end
 
+    class ForceStopMessage < Command
+    end
+
     class DebugMessage < Command
       def text
         @string_args[0]
       end
     end
 
+    class ClearDebugText < Command
+    end
+
+    class VariableCondition < Command
+    end
+
     class StringCondition < Command
     end
 
+    class SetVariable < Command
+    end
+
     class SetString < Command
       def text
         if @string_args.length > 0
@@ -57,6 +74,24 @@ module WolfRpg
       end
     end
 
+    class InputKey < Command
+    end
+
+    class SetVariableEx < Command
+    end
+
+    class AutoInput < Command
+    end
+
+    class BanInput < Command
+    end
+
+    class Teleport < Command
+    end
+
+    class Sound < Command
+    end
+
     class Picture < Command
       def type
         case (args[0] >> 4) & 0x07
@@ -111,25 +146,51 @@ module WolfRpg
       end
     end
 
-    #class
+    class ChangeColor < Command
+    end
 
-    private
-    ##########################
-    # Map of CIDs to classes #
+    class SetTransition < Command
+    end
 
-    CID_TO_CLASS = {
-      0   => Command::Blank,
-      101 => Command::Message,
-      102 => Command::Choices,
-      103 => Command::Comment,
-      106 => Command::DebugMessage,
-      112 => Command::StringCondition,
-      122 => Command::SetString,
-      150 => Command::Picture,
-    }
-    CID_TO_CLASS.default = Command
+    class PrepareTransition < Command
+    end
+
+    class ExecuteTransition < Command
+    end
+
+    class StartLoop < Command
+    end
+
+    class BreakLoop < Command
+    end
+
+    class BreakEvent < Command
+    end
+
+    class EraseEvent < Command
+    end
+
+    class ReturnToTitle < Command
+    end
+
+    class EndGame < Command
+    end
+
+    class LoopToStart < Command
+    end
+
+    class StopNonPic < Command
+    end
+
+    class ResumeNonPic < Command
+    end
+
+    class LoopTimes < Command
+    end
+
+    class Wait < Command
+    end
 
-    public
     class Move < Command
       def initialize(cid, args, string_args, indent, coder)
         super(cid, args, string_args, indent)
@@ -162,6 +223,155 @@ module WolfRpg
       end
     end
 
+    class WaitForMove < Command
+    end
+
+    class CommonEvent < Command
+    end
+
+    class CommonEventReserve < Command
+    end
+
+    class SetLabel < Command
+    end
+
+    class JumpLabel < Command
+    end
+
+    class SaveLoad < Command
+    end
+
+    class LoadGame < Command
+    end
+
+    class SaveGame < Command
+    end
+
+    class MoveDuringEventOn < Command
+    end
+
+    class MoveDuringEventOff < Command
+    end
+
+    class Chip < Command
+    end
+
+    class ChipSet < Command
+    end
+
+    class ChipOverwrite < Command
+    end
+
+    class Database < Command
+    end
+
+    class ImportDatabase < Command
+    end
+
+    class Party < Command
+    end
+
+    class MapEffect < Command
+    end
+
+    class ScrollScreen < Command
+    end
+
+    class Effect < Command
+    end
+
+    class CommonEventByName < Command
+    end
+
+    class ChoiceCase < Command
+    end
+
+    class SpecialChoiceCase < Command
+    end
+
+    class ElseCase < Command
+    end
+
+    class CancelCase < Command
+    end
+
+    class LoopEnd < Command
+    end
+
+    class BranchEnd < Command
+    end
+
+    #class
+
+    private
+    ##########################
+    # Map of CIDs to classes #
+
+    CID_TO_CLASS = {
+      0   => Command::Blank,
+      99  => Command::Checkpoint,
+      101 => Command::Message,
+      102 => Command::Choices,
+      103 => Command::Comment,
+      105 => Command::ForceStopMessage,
+      106 => Command::DebugMessage,
+      107 => Command::ClearDebugText,
+      111 => Command::VariableCondition,
+      112 => Command::StringCondition,
+      121 => Command::SetVariable,
+      122 => Command::SetString,
+      123 => Command::InputKey,
+      124 => Command::SetVariableEx,
+      125 => Command::AutoInput,
+      126 => Command::BanInput,
+      130 => Command::Teleport,
+      140 => Command::Sound,
+      150 => Command::Picture,
+      151 => Command::ChangeColor,
+      160 => Command::SetTransition,
+      161 => Command::PrepareTransition,
+      162 => Command::ExecuteTransition,
+      170 => Command::StartLoop,
+      171 => Command::BreakLoop,
+      172 => Command::BreakEvent,
+      173 => Command::EraseEvent,
+      174 => Command::ReturnToTitle,
+      175 => Command::EndGame,
+      176 => Command::StartLoop,
+      177 => Command::StopNonPic,
+      178 => Command::ResumeNonPic,
+      179 => Command::LoopTimes,
+      180 => Command::Wait,
+      201 => Command::Move, # special case
+      202 => Command::WaitForMove,
+      210 => Command::CommonEvent,
+      211 => Command::CommonEventReserve,
+      212 => Command::SetLabel,
+      213 => Command::JumpLabel,
+      220 => Command::SaveLoad,
+      221 => Command::LoadGame,
+      222 => Command::SaveGame,
+      230 => Command::MoveDuringEventOn,
+      231 => Command::MoveDuringEventOff,
+      240 => Command::Chip,
+      241 => Command::ChipSet,
+      250 => Command::Database,
+      251 => Command::ImportDatabase,
+      270 => Command::Party,
+      280 => Command::MapEffect,
+      281 => Command::ScrollScreen,
+      290 => Command::Effect,
+      300 => Command::CommonEventByName,
+      401 => Command::ChoiceCase,
+      402 => Command::SpecialChoiceCase,
+      420 => Command::ElseCase,
+      421 => Command::CancelCase,
+      498 => Command::LoopEnd,
+      499 => Command::BranchEnd
+    }
+    CID_TO_CLASS.default = Command
+
+    public
     # Load from the file and create the appropriate class object
     def self.create(coder)
       # Read all data for this command from file

data/lib/wolfrpg/common_events.rb

@@ -87,7 +87,8 @@ module WolfRpg
           raise "expected 0x91, got 0x#{indicator.to_s(16)}"
         end
         @unknown9 = coder.read_string
-        if (indicator = coder.read_byte) != 0x92
+        return if (indicator = coder.read_byte) == 0x91
+        unless indicator == 0x92
           raise "expected 0x92, got 0x#{indicator.to_s(16)}"
         end
         @unknown10 = coder.read_string
@@ -138,10 +139,14 @@ module WolfRpg
         end
         coder.write_byte(0x91)
         coder.write_string(@unknown9)
-        coder.write_byte(0x92)
-        coder.write_string(@unknown10)
-        coder.write_int(@unknown12)
-        coder.write_byte(0x92)
+        if @unknown10
+          coder.write_byte(0x92)
+          coder.write_string(@unknown10)
+          coder.write_int(@unknown12)
+          coder.write_byte(0x92)
+        else
+          coder.write_byte(0x91)
+        end
       end
 
       private

data/lib/wolfrpg/database.rb

@@ -2,6 +2,12 @@ module WolfRpg
   class Database
     attr_accessor :types
 
+    def encrypted?
+      @crypt_header != nil
+    end
+
+    DAT_SEED_INDICES = [0, 3, 9]
+
     def initialize(project_filename, dat_filename)
       FileCoder.open(project_filename, :read) do |coder|
         @types = Array.new(coder.read_int)
@@ -9,8 +15,13 @@ module WolfRpg
           @types[i] = Type.new(coder)
         end
       end
-      FileCoder.open(dat_filename, :read) do |coder|
-        coder.verify(DAT_MAGIC_NUMBER)
+      FileCoder.open(dat_filename, :read, DAT_SEED_INDICES) do |coder|
+        if coder.encrypted?
+          @crypt_header = coder.crypt_header
+          @unknown_encrypted_1 = coder.read_byte
+        else
+          coder.verify(DAT_MAGIC_NUMBER)
+        end
         num_types = coder.read_int
         unless num_types == @types.size
           raise "database project and dat Type count mismatch (#{@types.size} vs. #{num_types})"
@@ -30,8 +41,12 @@ module WolfRpg
             type.dump_project(coder)
           end
         end
-        FileCoder.open(dat_filename, :write) do |coder|
-          coder.write(DAT_MAGIC_NUMBER)
+        FileCoder.open(dat_filename, :write, DAT_SEED_INDICES, @crypt_header) do |coder|
+          if encrypted?
+            coder.write_byte(@unknown_encrypted_1)
+          else
+            coder.write(DAT_MAGIC_NUMBER)
+          end
           coder.write_int(@types.size)
           @types.each do |type|
             type.dump_dat(coder)
@@ -300,7 +315,7 @@ module WolfRpg
     end
 
     DAT_MAGIC_NUMBER = [
-      0x00, 0x57, 0x00, 0x00, 0x4F, 0x4C, 0x00, 0x46, 0x4D, 0x00, 0xC1
+      0x57, 0x00, 0x00, 0x4F, 0x4C, 0x00, 0x46, 0x4D, 0x00, 0xC1
     ].pack('C*')
     DAT_TYPE_SEPARATOR = [
       0xFE, 0xFF, 0xFF, 0xFF

data/lib/wolfrpg/filecoder.rb

@@ -1,19 +1,49 @@
 module WolfRpg
   class FileCoder
+    ##############
+    # Attributes #
     attr_reader :io
-
-    def initialize(io)
-      @io = io
+    attr_reader :crypt_header
+    def encrypted?
+      @crypt_header != nil
     end
 
-    def self.open(filename, mode)
+    #############
+    # Constants #
+    CRYPT_HEADER_SIZE = 10
+    DECRYPT_INTERVALS = [1, 2, 5]
+
+    #################
+    # Class methods #
+    def self.open(filename, mode, seed_indices = nil, crypt_header = nil)
       case mode
       when :read
-        file = File.open(filename, 'rb')
+        coder = FileCoder.new(File.open(filename, 'rb'))
+
+        # If encryptable,
+        # we need to make an extra check to see if it needs decrypting
+        if seed_indices
+          unless (indicator = coder.read_byte) == 0
+            header = [indicator]
+            (CRYPT_HEADER_SIZE - 1).times { |i| header << coder.read_byte }
+            seeds = seed_indices.map { |i| header[i] }
+            data = crypt(coder.read, seeds)
+            coder = FileCoder.new(StringIO.new(data, 'rb'), header)
+          end
+        end
       when :write
-        file = File.open(filename, 'wb')
+        # If encryptable, open a StringIO and pass the encryption options
+        # to the FileCoder
+        if seed_indices && crypt_header
+          coder = FileCoder.new(StringIO.new(''.force_encoding('BINARY'), 'wb'),
+                                crypt_header, filename, seed_indices)
+          coder.write(crypt_header.pack('C*'))
+        else
+          coder = FileCoder.new(File.open(filename, 'wb'))
+          coder.write_byte(0) if seed_indices
+        end
       end
-      coder = FileCoder.new(file)
+
       if block_given?
         begin
           yield coder
@@ -24,6 +54,14 @@ module WolfRpg
       return coder
     end
 
+    ##############
+    # Initialize #
+    def initialize(io, crypt_header = nil, filename = nil, seed_indices = nil)
+      @io = io
+      @crypt_header = crypt_header
+      @filename = filename
+    end
+
     ########
     # Read #
     def read(size = nil)
@@ -50,6 +88,30 @@ module WolfRpg
       return str
     end
 
+    def read_byte_array
+      bytes = Array.new(read_int)
+      bytes.each_index do |i|
+        bytes[i] = read_byte
+      end
+      return bytes
+    end
+
+    def read_int_array
+      ints = Array.new(read_int)
+      ints.each_index do |i|
+        ints[i] = read_int
+      end
+      return ints
+    end
+
+    def read_string_array
+      strings = Array.new(read_int)
+      strings.each_index do |i|
+        strings[i] = read_string
+      end
+      return strings
+    end
+
     def verify(data)
       got = read(data.length)
       if got != data
@@ -84,12 +146,15 @@ module WolfRpg
     def write(data)
       @io.write(data)
     end
+
     def write_byte(data)
       @io.write(data.chr)
     end
+
     def write_int(data)
       @io.write([data].pack('l<'))
     end
+
     def write_string(str)
       str = str.encode(Encoding::WINDOWS_31J, Encoding::UTF_8)
       write_int(str.bytesize + 1)
@@ -97,9 +162,37 @@ module WolfRpg
       write_byte(0)
     end
 
+    def write_byte_array(bytes)
+      write_int(bytes.size)
+      bytes.each do |b|
+        write_byte(b)
+      end
+    end
+
+    def write_int_array(ints)
+      write_int(ints.size)
+      ints.each do |i|
+        write_int(i)
+      end
+    end
+
+    def write_string_array(strings)
+      write_int(strings.size)
+      strings.each do |s|
+        write_string(s)
+      end
+    end
+
     #########
     # Other #
     def close
+      if @crypt_header && @filename && @seed_indices
+        File.open(@filename, 'wb') do |file|
+          file.write(@crypt_header.pack('C*'))
+          seeds = @seed_indices.map { |i| crypt_header[i] }
+          file.write(FileCoder.crypt(@io.string, seeds))
+        end
+      end
       @io.close
     end
 
@@ -108,7 +201,25 @@ module WolfRpg
     end
 
     def tell
-      @io.tell
+      if encrypted?
+        @io.tell + CRYPT_HEADER_SIZE
+      else
+        @io.tell
+      end
+    end
+
+    #################
+    # Private class #
+    private
+    def self.crypt(data_str, seeds)
+      data = data_str.unpack('C*')
+      seeds.each_with_index do |seed, s|
+        (0...data.size).step(DECRYPT_INTERVALS[s]) do |i|
+          seed = (seed * 0x343FD + 0x269EC3) & 0xFFFFFFFF
+          data[i] ^= (seed >> 28) & 7
+        end
+      end
+      return data.pack('C*')
     end
   end
 end

data/lib/wolfrpg/game_dat.rb

@@ -2,11 +2,8 @@ require 'stringio'
 
 module WolfRpg
   class GameDat
-    attr_reader :legacy
-    alias_method :legacy?, :legacy
-
     attr_accessor :unknown1
-    attr_accessor :unknown4
+    attr_accessor :file_version # only a guess
     attr_accessor :title
     attr_accessor :unknown2
     attr_accessor :font
@@ -15,40 +12,29 @@ module WolfRpg
     attr_accessor :version
     attr_accessor :unknown3
 
+    def encrypted?
+      @crypt_header != nil
+    end
+
+    SEED_INDICES = [0, 8, 6]
+    #XSEED_INDICES = [3, 4, 5]
+
     def initialize(filename)
-      FileCoder.open(filename, :read) do |coder|
-        if (first_byte = coder.read_byte) == 0
-          @legacy = false
-          coder.verify(MAGIC_NUMBER)
+      FileCoder.open(filename, :read, SEED_INDICES) do |coder|
+        if coder.encrypted?
+          @crypt_header = coder.crypt_header
         else
-          @legacy = true
-          @seeds = Array.new(3)
-          @xseeds = Array.new(3)
-          @seeds[0] = first_byte
-          coder.skip(1) # garbage
-          @xseeds[0] = coder.read_byte
-          @xseeds[1] = coder.read_byte
-          @xseeds[2] = coder.read_byte
-          coder.skip(1) # garbage
-          @seeds[2] = coder.read_byte
-          coder.skip(1) # garbage
-          @seeds[1] = coder.read_byte
-          coder.skip(1) # garbage
-          coder = FileCoder.new(StringIO.new(crypt(coder.read)))
+          coder.verify(MAGIC_NUMBER)
         end
 
         #TODO what is most of the junk in this file?
-        unknown1_size = coder.read_int
-        @unknown1 = coder.read(unknown1_size)
-        @unknown4 = coder.read_int
-
+        @unknown1 = coder.read_byte_array
+        @file_version = coder.read_int
         @title = coder.read_string
         if (magic_string = coder.read_string) != MAGIC_STRING
           raise "magic string invalid (got #{magic_string})"
         end
-
-        unknown2_size = coder.read_int
-        @unknown2 = coder.read(unknown2_size)
+        @unknown2 = coder.read_byte_array
 
         @font = coder.read_string
         @subfonts = Array.new(3)
@@ -57,7 +43,11 @@ module WolfRpg
         end
 
         @default_pc_graphic = coder.read_string
-        @version = coder.read_string
+        if @file_version >= 9
+          @version = coder.read_string
+        else
+          @version = ''
+        end
 
         # This is the size of the file minus one.
         # We don't need it, so discard it.
@@ -71,61 +61,23 @@ module WolfRpg
     end
 
     def dump(filename)
-      begin
-        if @legacy
-          coder = FileCoder.new(StringIO.new('', 'wb'))
-        else
-          coder = FileCoder.open(filename, :write)
-          coder.write_byte(0)
-          coder.write(MAGIC_NUMBER)
-        end
+      FileCoder.open(filename, :write, SEED_INDICES, @crypt_header) do |coder|
+        coder.write(MAGIC_NUMBER) unless encrypted?
 
-        coder.write_int(@unknown1.size)
-        coder.write(@unknown1)
-        coder.write_int(@unknown4)
+        coder.write_byte_array(@unknown1)
+        coder.write_int(@file_version)
         coder.write_string(@title)
         coder.write_string(MAGIC_STRING)
-        coder.write_int(@unknown2.bytesize)
-        coder.write(@unknown2)
+        coder.write_byte_array(@unknown2)
         coder.write_string(@font)
         @subfonts.each do |subfont|
           coder.write_string(subfont)
         end
         coder.write_string(@default_pc_graphic)
-        coder.write_string(@version)
-        coder.write_int(coder.tell + 4 + @unknown3.bytesize - 1 + (@legacy ? 10 : 0))
+        coder.write_string(@version) if @file_version >= 9
+        coder.write_int(coder.tell + 4 + @unknown3.bytesize - 1)
         coder.write(@unknown3)
-
-        if @legacy
-          data = crypt(coder.io.string)
-          FileCoder.open(filename, :write) do |coder|
-            coder.write_byte(@seeds[0])
-            coder.write_byte(0) # garbage
-            coder.write_byte(@xseeds[0])
-            coder.write_byte(@xseeds[1])
-            coder.write_byte(@xseeds[2])
-            coder.write_byte(0) # garbage
-            coder.write_byte(@seeds[2])
-            coder.write_byte(0) # garbage
-            coder.write_byte(@seeds[1])
-            coder.write_byte(0) # garbage
-            coder.write(data)
-          end
-        end
-      ensure
-        coder.close
-      end
-    end
-
-    def crypt(data_str)
-      data = data_str.unpack('C*')
-      @seeds.each_with_index do |seed, s|
-        (0...data.size).step(DECRYPT_INTERVALS[s]) do |i|
-          seed = (seed * 0x343FD + 0x269EC3) & 0xFFFFFFFF
-          data[i] ^= (seed >> 28) & 7
-        end
       end
-      return data.pack('C*')
     end
 
     private
@@ -133,6 +85,5 @@ module WolfRpg
       0x57, 0x00, 0x00, 0x4f, 0x4c, 0x00, 0x46, 0x4d, 0x00
     ].pack('C*')
     MAGIC_STRING = "0000-0000" # who knows what this is supposed to be
-    DECRYPT_INTERVALS = [1, 2, 5]
   end
 end

data/lib/wolfrpg/map.rb

@@ -18,7 +18,8 @@ module WolfRpg
         # Read basic data
         @width = coder.read_int
         @height = coder.read_int
-        @events = Array.new(coder.read_int)
+        coder.skip(4) # skip event count
+        @events = []
 
         # Read tiles
         #TODO: interpret this data later
@@ -26,8 +27,7 @@ module WolfRpg
 
         # Read events
         while (indicator = coder.read_byte) == 0x6F
-          event = Event.new(coder)
-          @events[event.id] = event
+          @events << Event.new(coder)
         end
         if indicator != 0x66
           raise "unexpected event indicator: #{indicator.to_s(16)}"

data/lib/wolftrans.rb

@@ -83,27 +83,6 @@ module WolfTrans
     end
   end
 
-  # IO functions
-  module IO
-    def self.read_txt(filename)
-      # Read file into memory, forcing UTF-8 without BOM.
-      text = nil
-      File.open(filename, 'rb:UTF-8') do |file|
-        if text = file.read(3)
-          if text == "\xEF\xBB\xBF"
-            raise "UTF-8 BOM detected; refusing to read file"
-          end
-          text << file.read
-        else
-          STDERR.puts "warning: empty patch file '#{filename}'"
-          return ''
-        end
-      end
-      # Convert Windows newlines and return
-      text.gsub(/\r\n?/, "\n")
-    end
-  end
-
   # Latest patch version format that can be read
   TXT_VERSION = Version.new(major: 1, minor: 0)
 end

data/lib/wolftrans/patch_data.rb

@@ -36,6 +36,7 @@ module WolfTrans
             load_map(filename) if extension == '.mps'
           when 'basicdata'
             if basename_downcase == 'game.dat'
+              @game_dat_filename = 'Data/BasicData/Game.dat'
               load_game_dat(filename)
             elsif extension == '.project'
               next if basename_downcase == 'sysdatabasebasic.project'
@@ -48,19 +49,34 @@ module WolfTrans
           end
         end
       end
+
+      # Game.dat is in a different place on older versions
+      unless @game_dat
+        Dir.entries(@game_dir).each do |entry|
+          if entry.downcase == 'game.dat'
+            @game_dat_filename = 'Game.dat'
+            load_game_dat("#{@game_dir}/#{entry}")
+            break
+          end
+        end
+      end
     end
 
     # Apply the patch to the files in the game path and write them to the
     # output directory
+    DATA_FILE_EXTENSIONS = ['png','jpg','jpeg','bmp','ogg',
+                            'mp3','wav','mid','midi',
+                            'dat','project','xxxxx']
     def apply(out_dir)
       out_dir = Util.sanitize_path(out_dir)
       out_data_dir = "#{out_dir}/Data"
 
       # Clear out directory
       FileUtils.rm_rf(out_dir)
+      FileUtils.mkdir_p("#{out_data_dir}/BasicData")
+      FileUtils.mkdir_p("#{out_data_dir}/MapData")
 
       # Patch all the maps and dump them
-      FileUtils.mkdir_p("#{out_data_dir}/MapData")
       @maps.each do |map_name, map|
         map.events.each do |event|
           next unless event
@@ -75,7 +91,6 @@ module WolfTrans
       end
 
       # Patch the databases
-      FileUtils.mkdir_p("#{out_data_dir}/BasicData")
       @databases.each do |db_name, db|
         db.types.each_with_index do |type, type_index|
           next if type.name.empty?
@@ -102,43 +117,40 @@ module WolfTrans
       @common_events.dump("#{out_data_dir}/BasicData/CommonEvent.dat")
 
       # Patch Game.dat
-      FileUtils.mkdir_p("#{out_data_dir}/BasicData")
       patch_game_dat
-      @game_dat.dump("#{out_data_dir}/BasicData/Game.dat")
-
-      # Copy image files
-      [
-        'BattleEffect',
-        'CharaChip',
-        'EnemyGraphic',
-        'Fog',
-        'Fog_BackGround',
-        'MapChip',
-        'Picture',
-        'SystemFile',
-        'SystemGraphic',
-      ].each do |dirname|
-        copy_data_files(out_data_dir, dirname, ['png','jpg','jpeg','bmp'])
-      end
+      @game_dat.dump("#{out_dir}/#{@game_dat_filename}")
 
-      # Copy sound/music files
-      [
-        'BGM',
-        'SE',
-        'SystemFile',
-      ].each do |dirname|
-        copy_data_files(out_data_dir, dirname, ['ogg','mp3','wav','mid','midi'])
-      end
+      # Copy image/sound/music files
+      Dir.entries(@game_data_dir).each do |entry|
+        # Skip dot and dot-dot and non-directories
+        next if entry == '.' || entry == '..'
+        path = "#{@game_data_dir}/#{entry}"
+        next unless FileTest.directory? path
 
-      # Copy BasicData
-      copy_data_files(out_data_dir, 'BasicData', ['dat','project','xxxxx','png'])
+        # Find the corresponding folder in the out dir
+        unless (out_path = Util.join_path_nocase(out_data_dir, entry))
+          out_path = "#{out_data_dir}/#{entry}"
+          FileUtils.mkdir_p(out_path)
+        end
+
+        # Find the corresponding folder in the patch
+        if @patch_data_dir && (asset_entry = Util.join_path_nocase(@patch_data_dir, entry))
+          copy_data_files("#{@patch_data_dir}/#{asset_entry}", DATA_FILE_EXTENSIONS, out_path)
+        end
+
+        # Copy the original game files
+        copy_data_files(path, DATA_FILE_EXTENSIONS, out_path)
+      end
 
       # Copy fonts
-      copy_data_files(out_data_dir, '', ['ttf','ttc'])
+      if @patch_data_dir
+        copy_data_files(@patch_data_dir, ['ttf','ttc','otf'], out_data_dir)
+      end
+      copy_data_files(@game_data_dir, ['ttf','ttc','otf'], out_data_dir)
 
       # Copy remainder of files in the base patch/game dirs
-      copy_files(@patch_assets_dir, @patch_data_dir, out_dir)
-      copy_files(@game_dir, @game_data_dir, out_dir)
+      copy_files(@patch_assets_dir, out_dir)
+      copy_files(@game_dir, out_dir)
     end
 
     private
@@ -214,20 +226,20 @@ module WolfTrans
     def strings_of_command(command)
       case command
       when WolfRpg::Command::Message
-        yield command.text unless command.text.empty?
+        yield command.text if Util.translatable? command.text
       when WolfRpg::Command::Choices
         command.text.each do |s|
-          yield s
+          yield s if Util.translatable? s
         end
       when WolfRpg::Command::StringCondition
         command.string_args.each do |s|
-          yield s unless s.empty?
+          yield s if Util.translatable? s
         end
       when WolfRpg::Command::SetString
-        yield command.text unless command.text.empty?
+        yield command.text if Util.translatable? command.text
       when WolfRpg::Command::Picture
         if command.type == :text
-          yield command.text unless command.text.empty?
+          yield command.text if Util.translatable? command.text
         end
       end
     end
@@ -284,63 +296,53 @@ module WolfTrans
 
     # Yield a translation for the given string and context if it exists
     def yield_translation(string, context)
-      return if string.empty?
+      return unless Util.translatable? string
       if @strings.include? string
-        unless @strings[string][context].string.empty?
-          yield @strings[string][context].string
-        end
+        str = @strings[string][context].string
+        yield str if Util.translatable? str
       end
     end
 
     # Copy normal, non-data files
-    def copy_files(src_dir, src_data_dir, out_dir)
+    def copy_files(src_dir, out_dir)
       Find.find(src_dir) do |path|
-        next if path == src_dir
-        Find.prune if path == src_data_dir
+        basename = File.basename(path)
+        basename_downcase = basename.downcase
+
+        # Don't do anything in Data/
+        Find.prune if basename_downcase == 'data' && File.dirname(path) == src_dir
+
+        # Skip directories
+        next if FileTest.directory? path
+
+        # "Short name", relative to the game base dir
         short_path = path[src_dir.length+1..-1]
         Find.prune if @file_blacklist.include? short_path.downcase
+
         out_path = "#{out_dir}/#{short_path}"
-        if FileTest.directory? path
-          FileUtils.mkdir_p(out_path)
-        else
-          next if ['thumbs.db', 'desktop.ini', '.ds_store'].include? File.basename(path).downcase
-          FileUtils.cp(path, out_path) unless File.exist? out_path
-        end
+        next if ['thumbs.db', 'desktop.ini', '.ds_store'].include? basename_downcase
+        next if File.exist? out_path
+        # Make directory only only when copying a file to avoid making empty directories
+        FileUtils.mkdir_p(File.dirname(out_path))
+        FileUtils.cp(path, out_path)
       end
     end
 
     # Copy data files
-    def copy_data_files(out_data_dir, dirname, extensions)
-      copy_data_files_from(@game_data_dir, out_data_dir, dirname, extensions)
-      if @patch_data_dir
-        copy_data_files_from(@patch_data_dir, out_data_dir, dirname, extensions)
-      end
-    end
+    def copy_data_files(src_dir, extensions, out_dir)
+      Dir.entries(src_dir).each do |entry|
+        # Don't care about directories
+        next if entry == '.' || entry == '..'
+        path = "#{src_dir}/#{entry}"
+        next if FileTest.directory? path
 
-    def copy_data_files_from(src_data_dir, out_data_dir, dirname, extensions)
-      out_dir = File.join(out_data_dir, dirname)
+        # Skip invalid file extensions
+        next unless extensions.include? File.extname(entry)[1..-1]
 
-      Find.find(src_data_dir) do |path|
-        if dirname.empty?
-          if FileTest.directory? path
-            Find.prune if path != src_data_dir
-            next
-          end
-        else
-          next if path == src_data_dir
-          if FileTest.directory?(path)
-            Find.prune unless File.basename(path).casecmp(dirname) == 0
-            next
-          end
-          next if File.dirname(path) == src_data_dir
-        end
-        basename = File.basename(path)
-        next unless extensions.include? File.extname(basename)[1..-1]
-        next if @file_blacklist.include? "data/#{dirname.downcase}/#{basename.downcase}"
-        out_name = "#{out_dir}/#{basename}"
-        next if File.exist? out_name
-        FileUtils.mkdir_p(out_dir)
-        FileUtils.cp(path, out_name)
+        # Copy the file if it doesn't already exist
+        next if Util.join_path_nocase(out_dir, entry)
+
+        FileUtils.cp(path, "#{out_dir}/#{entry}")
       end
     end
   end

data/lib/wolftrans/patch_text.rb

@@ -24,7 +24,7 @@ module WolfTrans
       # Load blacklist
       @file_blacklist = []
       if File.exists? "#{patch_dir}/blacklist.txt"
-        IO.read_txt("#{patch_dir}/blacklist.txt").each_line do |line|
+        Util.read_txt("#{patch_dir}/blacklist.txt").each_line do |line|
           line.strip!
           next if line.empty?
           if line.include? '\\'
@@ -87,7 +87,7 @@ module WolfTrans
 
       if File.exists? filename
         output_write = true if mode == :update
-        IO.read_txt(filename).each_line.with_index do |pristine_line, index|
+        Util.read_txt(filename).each_line.with_index do |pristine_line, index|
           # Remove comments and strip
           pristine_line.gsub!(/\n$/, '')
           line = pristine_line.gsub(/(?!\\)#.*$/, '').rstrip

data/lib/wolftrans/util.rb

@@ -10,7 +10,8 @@ module WolfTrans
 
     # Get the name of a path case-insensitively
     def self.join_path_nocase(parent, child)
-      child_case = Dir.entries(parent).select { |e| e.downcase == child }.first
+      child_downcase = child.downcase
+      child_case = Dir.entries(parent).select { |e| e.downcase == child_downcase }.first
       return nil unless child_case
       return "#{parent}/#{child_case}"
     end
@@ -25,5 +26,30 @@ module WolfTrans
     def self.escape_path(path)
       full_strip(path).gsub(/[\x00\/\\:\*\?\"<>\|]/, '_')
     end
+
+    # Determine if a string should be added to the translation map.
+    # All non-nill, non-empty, and "black square" character strings are good.
+    def self.translatable?(string)
+      string && !string.empty? && string != "\u25A0"
+    end
+
+    # Read all lines of a txt file as UTF-8, rejecting
+    # anything with a BOM
+    def self.read_txt(filename)
+      text = nil
+      File.open(filename, 'rb:UTF-8') do |file|
+        if text = file.read(3)
+          if text == "\xEF\xBB\xBF"
+            raise "UTF-8 BOM detected; refusing to read file"
+          end
+          text << file.read
+        else
+          STDERR.puts "warning: empty patch file '#{filename}'"
+          return ''
+        end
+      end
+      # Convert Windows newlines and return
+      text.gsub(/\r\n?/, "\n")
+    end
   end
 end

data/lib/wolftrans/version.rb

@@ -1,3 +1,3 @@
 module WolfTrans
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wolftrans
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mathew Velasquez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-16 00:00:00.000000000 Z
+date: 2015-12-01 00:00:00.000000000 Z
 dependencies: []
 description: A utility to translate Wolf RPG Editor games
 email: mathewvq@gmail.com
@@ -17,6 +17,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - LICENSE
 - README.md
 - Rakefile