wolftrans 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc48e4d190cfaf39833cdf6018e8e81bda4db9cb
-  data.tar.gz: 145782eb683c76dfcf20a91ee31538afe0b8f128
+  metadata.gz: e5810f165d8477fd00571f8cf4c0b599f4ee2bd7
+  data.tar.gz: d3fb00f064a84ef6f740329fe26ea98158522ecc
 SHA512:
-  metadata.gz: 569e7ce66fe6503d8d2c08a7bdadfb36a86687cdf23688ba8cd712c34383a763c56e27e8641812402dc1d9f956314d0e26c591058f7405740143a7f5e53e61fc
-  data.tar.gz: 6390d794310b3aa6fb0f23a4cf499e6bba638a5f84659e0eb5dd30ba2265371630ba4b5c61b7db4c3421a01c08cb48585fd9dde9a2c2b1619bda72dafac4bb24
+  metadata.gz: 11fa3045617bc45a79ca011ee8f42f44e5d05e1bc0b11917395936b2f22e12471e4010aabf623a1a775db050013d4a29b583e468c82b9ee6e9e737d4a1e5f7a4
+  data.tar.gz: 8741262f4c7622bb688554f2e65bcb6273c5cbb7d6b917e6d3770ce24b94f6010f87d59813da42d02bf02b3a53fb0fda92f860f3fcccafd1c7faff45c5b2ef0f

data/Rakefile

@@ -1,8 +1,28 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
 require 'rake/testtask'
+require 'wolftrans/version'
+
+GEM_FILENAME = "wolftrans-#{WolfTrans::VERSION}.gem"
+
+task :build do
+  system "gem build wolftrans.gemspec"
+end
+
+task :release => :build do
+  system "gem push #{GEM_FILENAME}"
+end
+
+task :install => :build do
+  system "gem install #{GEM_FILENAME}"
+end
+
+task :clean do
+  File.delete(GEM_FILENAME) if File.exist? GEM_FILENAME
+end
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
 end
 
-desc 'Run tests'
-task :default => :test
+task :default => :build

data/bin/wolftrans

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift File.expand_path('../../lib', __FILE__)
+
 require 'wolftrans'
 
 if ARGV.size != 3

data/lib/wolfrpg.rb

@@ -1,65 +1,11 @@
+require 'wolfrpg/filecoder'
+
+require 'wolfrpg/route'
+require 'wolfrpg/command'
+
 require 'wolfrpg/map'
 require 'wolfrpg/game_dat'
 require 'wolfrpg/database'
 require 'wolfrpg/common_events'
 
-module WolfRpg
-  # Find strings in binary string and return them inline in an array
-  def self.parse_strings(data)
-    result = []
-
-    # Scan for strings
-    str_len = 0
-    can_seek_multibyte = false
-    data.each_byte.with_index do |c, i|
-      result << c
-
-      if can_seek_multibyte
-        if (c >= 0x40 && c <= 0x9E && c != 0x7F) ||
-            (c >= 0xA0 && c <= 0xFC)
-          str_len += 1
-          next
-        end
-      end
-      if (c >= 0x81 && c <= 0x84) || (c >= 0x87 && c <= 0x9F) ||
-          (c >= 0xE0 && c <= 0xEA) || (c >= 0xED && c <= 0xEE) ||
-          (c >= 0xFA && c <= 0xFC)
-        # head of multibyte character
-        str_len += 1
-        can_seek_multibyte = true
-        next
-      end
-
-      can_seek_multibyte = false
-      if c == 0x0A || c == 0x0D || c == 0x09 || # newline, CR, tab
-          (c >= 0x20 && c <= 0x7E) || # printable ascii
-          (c >= 0xA1 && c <= 0xDF) # half-width katakana
-        str_len += 1
-      else
-        str = ''
-        if c == 0 && str_len > 0
-          # End of the string. Make sure it's valid by checking for
-          # a length prefix.
-          str_len_check = data[i - str_len - 4,4].unpack('V').first
-          if str_len_check == str_len + 1
-            begin
-              str = data[i - str_len,str_len].encode(Encoding::UTF_8, Encoding::WINDOWS_31J)
-            rescue
-              #do nothing
-            end
-          end
-        end
-
-        # Either append the string or hex bytes
-        unless str.empty?
-          result.slice!(-(4 + str_len + 1)..-1)
-          result << str
-        end
-
-        # Reset str length
-        str_len = 0
-      end
-    end
-    return result
-  end
-end
+require 'wolfrpg/debug'

data/lib/wolfrpg/command.rb

@@ -131,55 +131,55 @@ module WolfRpg
 
     public
     class Move < Command
-      def initialize(cid, args, string_args, indent, file)
+      def initialize(cid, args, string_args, indent, coder)
         super(cid, args, string_args, indent)
         # Read unknown data
         @unknown = Array.new(5)
         @unknown.each_index do |i|
-          @unknown[i] = IO.read_byte(file)
+          @unknown[i] = coder.read_byte
         end
         # Read known data
         #TODO further abstract this
-        @flags = IO.read_byte(file)
+        @flags = coder.read_byte
 
         # Read route
-        @route = Array.new(IO.read_int(file))
+        @route = Array.new(coder.read_int)
         @route.each_index do |i|
-          @route[i] = RouteCommand.create(file)
+          @route[i] = RouteCommand.create(coder)
         end
       end
 
-      def dump_terminator(file)
-        IO.write_byte(file, 1)
+      def dump_terminator(coder)
+        coder.write_byte(1)
         @unknown.each do |byte|
-          IO.write_byte(file, byte)
+          coder.write_byte(byte)
         end
-        IO.write_byte(file, @flags)
-        IO.write_int(file, @route.size)
+        coder.write_byte(@flags)
+        coder.write_int(@route.size)
         @route.each do |cmd|
-          cmd.dump(file)
+          cmd.dump(coder)
         end
       end
     end
 
     # Load from the file and create the appropriate class object
-    def self.create(file)
+    def self.create(coder)
       # Read all data for this command from file
-      args = Array.new(IO.read_byte(file) - 1)
-      cid = IO.read_int(file)
+      args = Array.new(coder.read_byte - 1)
+      cid = coder.read_int
       args.each_index do |i|
-        args[i] = IO.read_int(file)
+        args[i] = coder.read_int
       end
-      indent = IO.read_byte(file)
-      string_args = Array.new(IO.read_byte(file))
+      indent = coder.read_byte
+      string_args = Array.new(coder.read_byte)
       string_args.each_index do |i|
-        string_args[i] = IO.read_string(file)
+        string_args[i] = coder.read_string
       end
 
       # Read the move list if necessary
-      terminator = IO.read_byte(file)
+      terminator = coder.read_byte
       if terminator == 0x01
-        return Command::Move.new(cid, args, string_args, indent, file)
+        return Command::Move.new(cid, args, string_args, indent, coder)
       elsif terminator != 0x00
         raise "command terminator is an unexpected value (#{terminator})"
       end
@@ -188,19 +188,19 @@ module WolfRpg
       return CID_TO_CLASS[cid].new(cid, args, string_args, indent)
     end
 
-    def dump(file)
-      IO.write_byte(file, @args.size + 1)
-      IO.write_int(file, @cid)
+    def dump(coder)
+      coder.write_byte(@args.size + 1)
+      coder.write_int(@cid)
       @args.each do |arg|
-        IO.write_int(file, arg)
+        coder.write_int(arg)
       end
-      IO.write_byte(file, indent)
-      IO.write_byte(file, @string_args.size)
+      coder.write_byte(indent)
+      coder.write_byte(@string_args.size)
       @string_args.each do |arg|
-        IO.write_string(file, arg)
+        coder.write_string(arg)
       end
 
-      dump_terminator(file)
+      dump_terminator(coder)
     end
 
     private
@@ -211,8 +211,8 @@ module WolfRpg
       @indent = indent
     end
 
-    def dump_terminator(file)
-      IO.write_byte(file, 0)
+    def dump_terminator(coder)
+      coder.write_byte(0)
     end
   end
 end

data/lib/wolfrpg/common_events.rb

@@ -1,31 +1,29 @@
-require 'wolfrpg/command'
-
 module WolfRpg
   class CommonEvents
     attr_accessor :events
 
     def initialize(filename)
-      File.open(filename, 'rb') do |file|
-        IO.verify(file, MAGIC_NUMBER)
-        @events = Array.new(IO.read_int(file))
+      FileCoder.open(filename, :read) do |coder|
+        coder.verify(MAGIC_NUMBER)
+        @events = Array.new(coder.read_int)
         @events.each_index do |i|
-          event = Event.new(file)
+          event = Event.new(coder)
           events[event.id] = event
         end
-        if (terminator = IO.read_byte(file)) != 0x8F
+        if (terminator = coder.read_byte) != 0x8F
           raise "CommonEvents terminator not 0x8F (got 0x#{terminator.to_s(16)})"
         end
       end
     end
 
     def dump(filename)
-      File.open(filename, 'wb') do |file|
-        IO.write(file, MAGIC_NUMBER)
-        IO.write_int(file, @events.size)
+      FileCoder.open(filename, :write) do |coder|
+        coder.write(MAGIC_NUMBER)
+        coder.write_int(@events.size)
         @events.each do |event|
-          event.dump(file)
+          event.dump(coder)
         end
-        IO.write_byte(file, 0x8F)
+        coder.write_byte(0x8F)
       end
     end
 
@@ -37,113 +35,113 @@ module WolfRpg
       attr_accessor :name
       attr_accessor :commands
 
-      def initialize(file)
-        if (indicator = IO.read_byte(file)) != 0x8E
+      def initialize(coder)
+        if (indicator = coder.read_byte) != 0x8E
           raise "CommonEvent header indicator not 0x8E (got 0x#{indicator.to_s(16)})"
         end
-        @id = IO.read_int(file)
-        @unknown1 = IO.read_int(file)
-        @unknown2 = IO.read(file, 7)
-        @name = IO.read_string(file)
-        @commands = Array.new(IO.read_int(file))
+        @id = coder.read_int
+        @unknown1 = coder.read_int
+        @unknown2 = coder.read(7)
+        @name = coder.read_string
+        @commands = Array.new(coder.read_int)
         @commands.each_index do |i|
-          @commands[i] = Command.create(file)
+          @commands[i] = Command.create(coder)
         end
-        @unknown11 = IO.read_string(file)
-        @description = IO.read_string(file)
-        if (indicator = IO.read_byte(file)) != 0x8F
+        @unknown11 = coder.read_string
+        @description = coder.read_string
+        if (indicator = coder.read_byte) != 0x8F
           raise "CommonEvent data indicator not 0x8F (got 0x#{indicator.to_s(16)})"
         end
-        IO.verify(file, MAGIC_NUMBER)
+        coder.verify(MAGIC_NUMBER)
         @unknown3 = Array.new(10)
         @unknown3.each_index do |i|
-          @unknown3[i] = IO.read_string(file)
+          @unknown3[i] = coder.read_string
         end
-        IO.verify(file, MAGIC_NUMBER)
+        coder.verify(MAGIC_NUMBER)
         @unknown4 = Array.new(10)
         @unknown4.each_index do |i|
-          @unknown4[i] = IO.read_byte(file)
+          @unknown4[i] = coder.read_byte
         end
-        IO.verify(file, MAGIC_NUMBER)
+        coder.verify(MAGIC_NUMBER)
         @unknown5 = Array.new(10)
         @unknown5.each_index do |i|
-          @unknown5[i] = Array.new(IO.read_int(file))
+          @unknown5[i] = Array.new(coder.read_int)
           @unknown5[i].each_index do |j|
-            @unknown5[i][j] = IO.read_string(file)
+            @unknown5[i][j] = coder.read_string
           end
         end
-        IO.verify(file, MAGIC_NUMBER)
+        coder.verify(MAGIC_NUMBER)
         @unknown6 = Array.new(10)
         @unknown6.each_index do |i|
-          @unknown6[i] = Array.new(IO.read_int(file))
+          @unknown6[i] = Array.new(coder.read_int)
           @unknown6[i].each_index do |j|
-            @unknown6[i][j] = IO.read_int(file)
+            @unknown6[i][j] = coder.read_int
           end
         end
-        @unknown7 = IO.read(file, 0x1D)
+        @unknown7 = coder.read(0x1D)
         @unknown8 = Array.new(100)
         @unknown8.each_index do |i|
-          @unknown8[i] = IO.read_string(file)
+          @unknown8[i] = coder.read_string
         end
-        if (indicator = IO.read_byte(file)) != 0x91
+        if (indicator = coder.read_byte) != 0x91
           raise "expected 0x91, got 0x#{indicator.to_s(16)}"
         end
-        @unknown9 = IO.read_string(file)
-        if (indicator = IO.read_byte(file)) != 0x92
+        @unknown9 = coder.read_string
+        if (indicator = coder.read_byte) != 0x92
           raise "expected 0x92, got 0x#{indicator.to_s(16)}"
         end
-        @unknown10 = IO.read_string(file)
-        @unknown12 = IO.read_int(file)
-        if (indicator = IO.read_byte(file)) != 0x92
+        @unknown10 = coder.read_string
+        @unknown12 = coder.read_int
+        if (indicator = coder.read_byte) != 0x92
           raise "expected 0x92, got 0x#{indicator.to_s(16)}"
         end
       end
 
-      def dump(file)
-        IO.write_byte(file, 0x8E)
-        IO.write_int(file, @id)
-        IO.write_int(file, @unknown1)
-        IO.write(file, @unknown2)
-        IO.write_string(file, @name)
-        IO.write_int(file, @commands.size)
+      def dump(coder)
+        coder.write_byte(0x8E)
+        coder.write_int(@id)
+        coder.write_int(@unknown1)
+        coder.write(@unknown2)
+        coder.write_string(@name)
+        coder.write_int(@commands.size)
         @commands.each do |cmd|
-          cmd.dump(file)
+          cmd.dump(coder)
         end
-        IO.write_string(file, @unknown11)
-        IO.write_string(file, @description)
-        IO.write_byte(file, 0x8F)
-        IO.write(file, MAGIC_NUMBER)
+        coder.write_string(@unknown11)
+        coder.write_string(@description)
+        coder.write_byte(0x8F)
+        coder.write(MAGIC_NUMBER)
         @unknown3.each do |i|
-          IO.write_string(file, i)
+          coder.write_string(i)
         end
-        IO.write(file, MAGIC_NUMBER)
+        coder.write(MAGIC_NUMBER)
         @unknown4.each do |i|
-          IO.write_byte(file, i)
+          coder.write_byte(i)
         end
-        IO.write(file, MAGIC_NUMBER)
+        coder.write(MAGIC_NUMBER)
         @unknown5.each do |i|
-          IO.write_int(file, i.size)
+          coder.write_int(i.size)
           i.each do |j|
-            IO.write_string(file, j)
+            coder.write_string(j)
           end
         end
-        IO.write(file, MAGIC_NUMBER)
+        coder.write(MAGIC_NUMBER)
         @unknown6.each do |i|
-          IO.write_int(file, i.size)
+          coder.write_int(i.size)
           i.each do |j|
-            IO.write_int(file, j)
+            coder.write_int(j)
           end
         end
-        IO.write(file, @unknown7)
+        coder.write(@unknown7)
         @unknown8.each do |i|
-          IO.write_string(file, i)
-        end
-        IO.write_byte(file, 0x91)
-        IO.write_string(file, @unknown9)
-        IO.write_byte(file, 0x92)
-        IO.write_string(file, @unknown10)
-        IO.write_int(file, @unknown12)
-        IO.write_byte(file, 0x92)
+          coder.write_string(i)
+        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)
       end
 
       private