wolftrans 0.0.2 → 0.1.0

data/lib/wolfrpg/game_dat.rb

@@ -1,8 +1,12 @@
-require 'wolfrpg/io'
+require 'stringio'
 
 module WolfRpg
   class GameDat
+    attr_reader :legacy
+    alias_method :legacy?, :legacy
+
     attr_accessor :unknown1
+    attr_accessor :unknown4
     attr_accessor :title
     attr_accessor :unknown2
     attr_accessor :font
@@ -12,65 +16,123 @@ module WolfRpg
     attr_accessor :unknown3
 
     def initialize(filename)
-      File.open(filename, 'rb') do |file|
-        IO.verify(file, MAGIC_NUMBER)
+      FileCoder.open(filename, :read) do |coder|
+        if (first_byte = coder.read_byte) == 0
+          @legacy = false
+          coder.verify(MAGIC_NUMBER)
+        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)))
+        end
+
         #TODO what is most of the junk in this file?
-        @unknown1 = IO.read(file, 25)
+        unknown1_size = coder.read_int
+        @unknown1 = coder.read(unknown1_size)
+        @unknown4 = coder.read_int
 
-        @title = IO.read_string(file)
-        if (magic_string = IO.read_string(file)) != MAGIC_STRING
+        @title = coder.read_string
+        if (magic_string = coder.read_string) != MAGIC_STRING
           raise "magic string invalid (got #{magic_string})"
         end
 
-        unknown2_size = IO.read_int(file)
-        @unknown2 = IO.read(file, unknown2_size)
+        unknown2_size = coder.read_int
+        @unknown2 = coder.read(unknown2_size)
 
-        #IO.dump(file, 64)
-        #abort
-        @font = IO.read_string(file)
+        @font = coder.read_string
         @subfonts = Array.new(3)
         @subfonts.each_index do |i|
-          @subfonts[i] = IO.read_string(file)
+          @subfonts[i] = coder.read_string
         end
 
-        @default_pc_graphic = IO.read_string(file)
-        @version = IO.read_string(file)
+        @default_pc_graphic = coder.read_string
+        @version = coder.read_string
 
         # This is the size of the file minus one.
         # We don't need it, so discard it.
-        file.seek(4, :CUR)
+        coder.skip(4)
 
         # We don't care about the rest of this file for translation
         # purposes.
         # Someday we will know what the hell is stored in here... But not today.
-        @unknown3 = file.read
+        @unknown3 = coder.read
       end
     end
 
     def dump(filename)
-      File.open(filename, 'wb') do |file|
-        IO.write(file, MAGIC_NUMBER)
-        IO.write(file, @unknown1)
-        IO.write_string(file, @title)
-        IO.write_string(file, MAGIC_STRING)
-        IO.write_int(file, @unknown2.bytesize)
-        IO.write(file, @unknown2)
-        IO.write_string(file, @font)
+      begin
+        if @legacy
+          coder = FileCoder.new(StringIO.new('', 'wb'))
+        else
+          coder = FileCoder.open(filename, :write)
+          coder.write_byte(0)
+          coder.write(MAGIC_NUMBER)
+        end
+
+        coder.write_int(@unknown1.size)
+        coder.write(@unknown1)
+        coder.write_int(@unknown4)
+        coder.write_string(@title)
+        coder.write_string(MAGIC_STRING)
+        coder.write_int(@unknown2.bytesize)
+        coder.write(@unknown2)
+        coder.write_string(@font)
         @subfonts.each do |subfont|
-          IO.write_string(file, 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(@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
-        IO.write_string(file, @default_pc_graphic)
-        IO.write_string(file, @version)
-        IO.write_int(file, file.tell + 4 + @unknown3.bytesize - 1)
-        IO.write(file, @unknown3)
       end
+      return data.pack('C*')
     end
 
     private
     MAGIC_NUMBER = [
-      0x00, 0x57, 0x00, 0x00, 0x4f, 0x4c, 0x00, 0x46, 0x4d, 0x00,
-      0x15, 0x00, 0x00, 0x00, # likely an integer
+      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

@@ -1,7 +1,3 @@
-require 'wolfrpg/io'
-require 'wolfrpg/route'
-require 'wolfrpg/command'
-
 module WolfRpg
   class Map
     attr_reader :tileset_id
@@ -14,48 +10,48 @@ module WolfRpg
 
     def initialize(filename)
       @filename = File.basename(filename, '.*')
-      File.open(filename, 'rb') do |file|
-        IO.verify(file, MAGIC_NUMBER)
+      FileCoder.open(filename, :read) do |coder|
+        coder.verify(MAGIC_NUMBER)
 
-        @tileset_id = IO.read_int(file)
+        @tileset_id = coder.read_int
 
         # Read basic data
-        @width = IO.read_int(file)
-        @height = IO.read_int(file)
-        @events = Array.new(IO.read_int(file))
+        @width = coder.read_int
+        @height = coder.read_int
+        @events = Array.new(coder.read_int)
 
         # Read tiles
         #TODO: interpret this data later
-        @tiles = IO.read(file, @width * @height * 3 * 4)
+        @tiles = coder.read(@width * @height * 3 * 4)
 
         # Read events
-        while (indicator = IO.read_byte(file)) == 0x6F
-          event = Event.new(file)
+        while (indicator = coder.read_byte) == 0x6F
+          event = Event.new(coder)
           @events[event.id] = event
         end
         if indicator != 0x66
           raise "unexpected event indicator: #{indicator.to_s(16)}"
         end
-        unless file.eof?
+        unless coder.eof?
           raise "file not fully parsed"
         end
       end
     end
 
     def dump(filename)
-      File.open(filename, 'wb') do |file|
-        IO.write(file, MAGIC_NUMBER)
-        IO.write_int(file, @tileset_id)
-        IO.write_int(file, @width)
-        IO.write_int(file, @height)
-        IO.write_int(file, @events.size)
-        IO.write(file, @tiles)
+      FileCoder.open(filename, :write) do |coder|
+        coder.write(MAGIC_NUMBER)
+        coder.write_int(@tileset_id)
+        coder.write_int(@width)
+        coder.write_int(@height)
+        coder.write_int(@events.size)
+        coder.write(@tiles)
         @events.each do |event|
           next unless event
-          IO.write_byte(file, 0x6F)
-          event.dump(file)
+          coder.write_byte(0x6F)
+          event.dump(coder)
         end
-        IO.write_byte(file, 0x66)
+        coder.write_byte(0x66)
       end
     end
 
@@ -94,19 +90,19 @@ module WolfRpg
       attr_accessor :y
       attr_accessor :pages
 
-      def initialize(file)
-        IO.verify(file, MAGIC_NUMBER1)
-        @id = IO.read_int(file)
-        @name = IO.read_string(file)
-        @x = IO.read_int(file)
-        @y = IO.read_int(file)
-        @pages = Array.new(IO.read_int(file))
-        IO.verify(file, MAGIC_NUMBER2)
+      def initialize(coder)
+        coder.verify(MAGIC_NUMBER1)
+        @id = coder.read_int
+        @name = coder.read_string
+        @x = coder.read_int
+        @y = coder.read_int
+        @pages = Array.new(coder.read_int)
+        coder.verify(MAGIC_NUMBER2)
 
         # Read pages
         page_id = 0
-        while (indicator = IO.read_byte(file)) == 0x79
-          page = Page.new(file, page_id)
+        while (indicator = coder.read_byte) == 0x79
+          page = Page.new(coder, page_id)
           @pages[page_id] = page
           page_id += 1
         end
@@ -115,21 +111,21 @@ module WolfRpg
         end
       end
 
-      def dump(file)
-        IO.write(file, MAGIC_NUMBER1)
-        IO.write_int(file, @id)
-        IO.write_string(file, @name)
-        IO.write_int(file, @x)
-        IO.write_int(file, @y)
-        IO.write_int(file, @pages.size)
-        IO.write(file, MAGIC_NUMBER2)
+      def dump(coder)
+        coder.write(MAGIC_NUMBER1)
+        coder.write_int(@id)
+        coder.write_string(@name)
+        coder.write_int(@x)
+        coder.write_int(@y)
+        coder.write_int(@pages.size)
+        coder.write(MAGIC_NUMBER2)
 
         # Write pages
         @pages.each do |page|
-          IO.write_byte(file, 0x79)
-          page.dump(file)
+          coder.write_byte(0x79)
+          page.dump(coder)
         end
-        IO.write_byte(file, 0x70)
+        coder.write_byte(0x70)
       end
 
       class Page
@@ -150,77 +146,77 @@ module WolfRpg
         attr_accessor :collision_width
         attr_accessor :collision_height
 
-        def initialize(file, id)
+        def initialize(coder, id)
           @id = id
 
           #TODO ???
-          @unknown1 = IO.read_int(file)
+          @unknown1 = coder.read_int
 
           #TODO further abstract graphics options
-          @graphic_name = IO.read_string(file)
-          @graphic_direction = IO.read_byte(file)
-          @graphic_frame = IO.read_byte(file)
-          @graphic_opacity = IO.read_byte(file)
-          @graphic_render_mode = IO.read_byte(file)
+          @graphic_name = coder.read_string
+          @graphic_direction = coder.read_byte
+          @graphic_frame = coder.read_byte
+          @graphic_opacity = coder.read_byte
+          @graphic_render_mode = coder.read_byte
 
           #TODO parse conditions later
-          @conditions = IO.read(file, 1 + 4 + 4*4 + 4*4)
+          @conditions = coder.read(1 + 4 + 4*4 + 4*4)
           #TODO parse movement options later
-          @movement = IO.read(file, 4)
+          @movement = coder.read(4)
 
           #TODO further abstract flags
-          @flags = IO.read_byte(file)
+          @flags = coder.read_byte
 
           #TODO further abstract flags
-          @route_flags = IO.read_byte(file)
+          @route_flags = coder.read_byte
 
           # Parse move 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
 
           # Parse commands
-          @commands = Array.new(IO.read_int(file))
+          @commands = Array.new(coder.read_int)
           @commands.each_index do |i|
-            @commands[i] = Command.create(file)
+            @commands[i] = Command.create(coder)
           end
-          IO.verify(file, COMMANDS_TERMINATOR)
+          coder.verify(COMMANDS_TERMINATOR)
 
           #TODO abstract these options later
-          @shadow_graphic_num = IO.read_byte(file)
-          @collision_width = IO.read_byte(file)
-          @collision_height = IO.read_byte(file)
+          @shadow_graphic_num = coder.read_byte
+          @collision_width = coder.read_byte
+          @collision_height = coder.read_byte
 
-          if (terminator = IO.read_byte(file)) != 0x7A
+          if (terminator = coder.read_byte) != 0x7A
             raise "page terminator not 7A (found #{terminator.to_s(16)})"
           end
         end
 
-        def dump(file)
-          IO.write_int(file, @unknown1)
-          IO.write_string(file, @graphic_name)
-          IO.write_byte(file, @graphic_direction)
-          IO.write_byte(file, @graphic_frame)
-          IO.write_byte(file, @graphic_opacity)
-          IO.write_byte(file, @graphic_render_mode)
-          IO.write(file, @conditions)
-          IO.write(file, @movement)
-          IO.write_byte(file, @flags)
-          IO.write_byte(file, @route_flags)
-          IO.write_int(file, @route.size)
+        def dump(coder)
+          coder.write_int(@unknown1)
+          coder.write_string(@graphic_name)
+          coder.write_byte(@graphic_direction)
+          coder.write_byte(@graphic_frame)
+          coder.write_byte(@graphic_opacity)
+          coder.write_byte(@graphic_render_mode)
+          coder.write(@conditions)
+          coder.write(@movement)
+          coder.write_byte(@flags)
+          coder.write_byte(@route_flags)
+          coder.write_int(@route.size)
           @route.each do |cmd|
-            cmd.dump(file)
+            cmd.dump(coder)
           end
-          IO.write_int(file, @commands.size)
+          coder.write_int(@commands.size)
           @commands.each do |cmd|
-            cmd.dump(file)
+            cmd.dump(coder)
           end
-          IO.write(file, COMMANDS_TERMINATOR)
-          IO.write_byte(file, @shadow_graphic_num)
-          IO.write_byte(file, @collision_width)
-          IO.write_byte(file, @collision_height)
-          IO.write_byte(file, 0x7A)
+          coder.write(COMMANDS_TERMINATOR)
+          coder.write_byte(@shadow_graphic_num)
+          coder.write_byte(@collision_width)
+          coder.write_byte(@collision_height)
+          coder.write_byte(0x7A)
         end
 
         COMMANDS_TERMINATOR = [

data/lib/wolfrpg/route.rb

@@ -1,25 +1,25 @@
 module WolfRpg
   class RouteCommand
-    def self.create(file)
+    def self.create(coder)
       # Read all data for this movement command from file
-      id = IO.read_byte(file)
-      args = Array.new(IO.read_byte(file))
+      id = coder.read_byte
+      args = Array.new(coder.read_byte)
       args.each_index do |i|
-        args[i] = IO.read_int(file)
+        args[i] = coder.read_int
       end
-      IO.verify(file, TERMINATOR)
+      coder.verify(TERMINATOR)
 
       #TODO Create proper route command
       return RouteCommand.new(id, args)
     end
 
-    def dump(file)
-      IO.write_byte(file, @id)
-      IO.write_byte(file, @args.size)
+    def dump(coder)
+      coder.write_byte(@id)
+      coder.write_byte(@args.size)
       @args.each do |arg|
-        IO.write_int(file, arg)
+        coder.write_int(arg)
       end
-      IO.write(file, TERMINATOR)
+      coder.write(TERMINATOR)
     end
 
     attr_accessor :id