wolftrans 0.0.1

data/lib/wolfrpg/game_dat.rb

@@ -0,0 +1,76 @@
+require 'wolfrpg/io'
+
+module WolfRpg
+  class GameDat
+    attr_accessor :unknown1
+    attr_accessor :title
+    attr_accessor :unknown2
+    attr_accessor :font
+    attr_accessor :subfonts
+    attr_accessor :default_pc_graphic
+    attr_accessor :version
+    attr_accessor :unknown3
+
+    def initialize(filename)
+      File.open(filename, 'rb') do |file|
+        IO.verify(file, MAGIC_NUMBER)
+        #TODO what is most of the junk in this file?
+        @unknown1 = IO.read(file, 25)
+
+        @title = IO.read_string(file)
+        if (magic_string = IO.read_string(file)) != MAGIC_STRING
+          raise "magic string invalid (got #{magic_string})"
+        end
+
+        unknown2_size = IO.read_int(file)
+        @unknown2 = IO.read(file, unknown2_size)
+
+        #IO.dump(file, 64)
+        #abort
+        @font = IO.read_string(file)
+        @subfonts = Array.new(3)
+        @subfonts.each_index do |i|
+          @subfonts[i] = IO.read_string(file)
+        end
+
+        @default_pc_graphic = IO.read_string(file)
+        @version = IO.read_string(file)
+
+        # This is the size of the file minus one.
+        # We don't need it, so discard it.
+        file.seek(4, :CUR)
+
+        # 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
+      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)
+        @subfonts.each do |subfont|
+          IO.write_string(file, subfont)
+        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
+    end
+
+    private
+    MAGIC_NUMBER = [
+      0x00, 0x57, 0x00, 0x00, 0x4f, 0x4c, 0x00, 0x46, 0x4d, 0x00,
+      0x15, 0x00, 0x00, 0x00, # likely an integer
+    ].pack('C*')
+    MAGIC_STRING = "0000-0000" # who knows what this is supposed to be
+  end
+end

data/lib/wolfrpg/io.rb

@@ -0,0 +1,63 @@
+module WolfRpg
+  module IO
+    ########
+    # Read #
+    def self.read(io, size)
+      io.readpartial(size)
+    end
+    def self.read_byte(io)
+      io.readpartial(1).unpack('C').first
+    end
+    def self.read_int(io)
+      io.readpartial(4).unpack('l<').first
+    end
+    def self.read_string(io)
+      size = read_int(io)
+      return '' if size == 0
+      str = io.readpartial(size - 1).encode(Encoding::UTF_8, Encoding::WINDOWS_31J)
+      raise "string not null-terminated" unless read_byte(io) == 0
+      return str
+    end
+    def self.verify(io, data)
+      got = io.readpartial(data.length)
+      if got != data
+        raise "could not verify magic data (expecting #{data.unpack('C*')}, got #{got.unpack('C*')})"
+      end
+    end
+    def self.dump(io, length)
+      length.times do |i|
+        print " %02x" % read_byte(io)
+      end
+      print "\n"
+    end
+    def self.dump_until(pattern)
+      escaped_pattern = Regexp.escape(pattern)
+      str = ''.force_encoding('BINARY')
+      until str =~ /#{escaped_pattern}\z/nm
+        str << io.readpartial(1)
+      end
+      str.gsub(/#{escaped_pattern}\z/nm, '').each_byte do |byte|
+        print " %02x" % byte
+      end
+      print "\n"
+    end
+
+    #########
+    # Write #
+    def self.write(io, data)
+      io.write(data)
+    end
+    def self.write_byte(io, data)
+      io.write(data.chr)
+    end
+    def self.write_int(io, data)
+      io.write([data].pack('l<'))
+    end
+    def self.write_string(io, data)
+      new_data = data.encode(Encoding::WINDOWS_31J, Encoding::UTF_8)
+      write_int(io, new_data.bytesize + 1)
+      io.write(new_data)
+      write_byte(io, 0)
+    end
+  end
+end

data/lib/wolfrpg/map.rb

@@ -0,0 +1,250 @@
+require 'wolfrpg/io'
+require 'wolfrpg/route'
+require 'wolfrpg/command'
+
+module WolfRpg
+  class Map
+    attr_reader :tileset_id
+    attr_reader :width
+    attr_reader :height
+    attr_reader :events
+
+    #DEBUG
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = File.basename(filename, '.*')
+      File.open(filename, 'rb') do |file|
+        IO.verify(file, MAGIC_NUMBER)
+
+        @tileset_id = IO.read_int(file)
+
+        # Read basic data
+        @width = IO.read_int(file)
+        @height = IO.read_int(file)
+        @events = Array.new(IO.read_int(file))
+
+        # Read tiles
+        #TODO: interpret this data later
+        @tiles = IO.read(file, @width * @height * 3 * 4)
+
+        # Read events
+        while (indicator = IO.read_byte(file)) == 0x6F
+          event = Event.new(file)
+          @events[event.id] = event
+        end
+        if indicator != 0x66
+          raise "unexpected event indicator: #{indicator.to_s(16)}"
+        end
+        unless file.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)
+        @events.each do |event|
+          IO.write_byte(file, 0x6F)
+          event.dump(file)
+        end
+        IO.write_byte(file, 0x66)
+      end
+    end
+
+    #DEBUG method that searches for a string somewhere in the map
+    def grep(needle)
+      @events.each do |event|
+        event.pages.each do |page|
+          page.commands.each_with_index do |command, line|
+            command.string_args.each do |arg|
+              if m = arg.match(needle)
+                print "#{@filename}/#{event.id}/#{page.id+1}/#{line+1}: #{command.cid}\n\t#{command.args}\n\t#{command.string_args}\n"
+                break
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def grep_cid(cid)
+      @events.each do |event|
+        event.pages.each do |page|
+          page.commands.each_with_index do |command, line|
+            if command.cid == cid
+              print "#{@filename}/#{event.id}/#{page.id+1}/#{line+1}: #{command.cid}\n\t#{command.args}\n\t#{command.string_args}\n"
+            end
+          end
+        end
+      end
+    end
+
+    class Event
+      attr_accessor :id
+      attr_accessor :name
+      attr_accessor :x
+      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)
+
+        # Read pages
+        page_id = 0
+        while (indicator = IO.read_byte(file)) == 0x79
+          page = Page.new(file, page_id)
+          @pages[page_id] = page
+          page_id += 1
+        end
+        if indicator != 0x70
+          raise "unexpected event page indicator: #{indicator.to_s(16)}"
+        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)
+
+        # Write pages
+        @pages.each do |page|
+          IO.write_byte(file, 0x79)
+          page.dump(file)
+        end
+        IO.write_byte(file, 0x70)
+      end
+
+      class Page
+        attr_accessor :id
+        attr_accessor :unknown1
+        attr_accessor :graphic_name
+        attr_accessor :graphic_direction
+        attr_accessor :graphic_frame
+        attr_accessor :graphic_opacity
+        attr_accessor :graphic_render_mode
+        attr_accessor :conditions
+        attr_accessor :movement
+        attr_accessor :flags
+        attr_accessor :route_flags
+        attr_accessor :route
+        attr_accessor :commands
+        attr_accessor :shadow_graphic_num
+        attr_accessor :collision_width
+        attr_accessor :collision_height
+
+        def initialize(file, id)
+          @id = id
+
+          #TODO ???
+          @unknown1 = IO.read_int(file)
+
+          #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)
+
+          #TODO parse conditions later
+          @conditions = IO.read(file, 1 + 4 + 4*4 + 4*4)
+          #TODO parse movement options later
+          @movement = IO.read(file, 4)
+
+          #TODO further abstract flags
+          @flags = IO.read_byte(file)
+
+          #TODO further abstract flags
+          @route_flags = IO.read_byte(file)
+
+          # Parse move route
+          @route = Array.new(IO.read_int(file))
+          @route.each_index do |i|
+            @route[i] = RouteCommand.create(file)
+          end
+
+          # Parse commands
+          @commands = Array.new(IO.read_int(file))
+          @commands.each_index do |i|
+            @commands[i] = Command.create(file)
+          end
+          IO.verify(file, 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)
+
+          if (terminator = IO.read_byte(file)) != 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)
+          @route.each do |cmd|
+            cmd.dump(file)
+          end
+          IO.write_int(file, @commands.size)
+          @commands.each do |cmd|
+            cmd.dump(file)
+          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)
+        end
+
+        COMMANDS_TERMINATOR = [
+          0x03, 0x00, 0x00, 0x00,
+        ].pack('C*')
+      end
+
+      private
+      MAGIC_NUMBER1 = [
+        0x39, 0x30, 0x00, 0x00
+      ].pack('C*')
+      MAGIC_NUMBER2 = [
+        0x00, 0x00, 0x00, 0x00
+      ].pack('C*')
+    end
+
+    private
+    MAGIC_NUMBER = [
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x57, 0x4F, 0x4C, 0x46, 0x4D, 0x00,
+      0x00, 0x00, 0x00, 0x00,
+      0x64, 0x00, 0x00, 0x00,
+      0x65,
+      0x05, 0x00, 0x00, 0x00,
+      0x82, 0xC8, 0x82, 0xB5, 0x00,
+    ].pack('C*')
+  end
+end

data/lib/wolfrpg/route.rb

@@ -0,0 +1,36 @@
+module WolfRpg
+  class RouteCommand
+    def self.create(file)
+      # Read all data for this movement command from file
+      id = IO.read_byte(file)
+      args = Array.new(IO.read_byte(file))
+      args.each_index do |i|
+        args[i] = IO.read_int(file)
+      end
+      IO.verify(file, 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)
+      @args.each do |arg|
+        IO.write_int(file, arg)
+      end
+      IO.write(file, TERMINATOR)
+    end
+
+    attr_accessor :id
+    attr_accessor :args
+
+    def initialize(id, args)
+      @id = id
+      @args = args
+    end
+
+    private
+    TERMINATOR = [0x01, 0x00].pack('C*')
+  end
+end

data/lib/wolftrans.rb

@@ -0,0 +1,169 @@
+require 'wolftrans/patch_text'
+require 'wolftrans/patch_data'
+require 'wolfrpg'
+
+module WolfTrans
+  class Patch
+    def initialize(game_path, patch_path)
+      @strings = Hash.new { |hash, key| hash[key] = Hash.new }
+      load_data(game_path)
+      load_patch(patch_path)
+    end
+  end
+
+  # Represents a translated string
+  class Translation
+    attr_reader :patch_filename
+    attr_reader :string
+    attr_accessor :autogenerate
+    alias_method :autogenerate?, :autogenerate
+
+    def initialize(patch_filename, string='', autogenerate=true)
+      @patch_filename = patch_filename
+      @string = string
+      @autogenerate = autogenerate
+    end
+
+    def to_s
+      @string
+    end
+  end
+
+  # Version; represents a major/minor version scheme
+  class Version
+    include Comparable
+    attr_accessor :major
+    attr_accessor :minor
+
+    def initialize(major: nil, minor: nil, flt: nil, str: nil)
+      # See if we need to parse from a string
+      if flt
+        string = flt.to_s
+      elsif str
+        string = str
+      else
+        string = nil
+      end
+
+      # Extract major and minor numbers
+      if string
+        if match = string.match(/(\d+)\.(\d+)/)
+          @major, @minor = match.captures.map { |s| s.to_i }
+        else
+          raise "could not parse version string '#{string}'"
+        end
+      elsif major && minor
+        @major = major
+        @minor = minor
+      else
+        @major = 0
+        @minor = 0
+      end
+    end
+
+    def to_s
+      "#{@major}.#{@minor}"
+    end
+
+    def <=>(other)
+      case other
+      when Version
+        return 0 if major == other.major && minor == other.minor
+        return 1 if major > other.major || (major == other.major && minor >= other.minor)
+        return -1
+      when String
+        return self == Version.new(str = other)
+      when Float
+        return self == Version.new(flt = other)
+      end
+      return nil
+    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
+
+  #####################
+  # Utility functions #
+
+  # Sanitize a path; i.e., standardize path separators remove trailing separator
+  def self.sanitize_path(path)
+    if File::ALT_SEPARATOR
+      path = path.gsub(File::ALT_SEPARATOR, '/')
+    end
+    path.sub(/\/$/, '')
+  end
+
+  # 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
+    return nil unless child_case
+    return "#{parent}/#{child_case}"
+  end
+
+  # Strip all leading/trailing whitespace, including fullwidth spaces
+  def self.full_strip(str)
+    str.strip.sub(/^\u{3000}*/, '').sub(/\u{3000}*$/, '')
+  end
+
+  # Escape a string for use as a path on the filesystem
+  # https://stackoverflow.com/questions/2270635/invalid-chars-filter-for-file-folder-name-ruby
+  def self.escape_path(path)
+    full_strip(path).gsub(/[\x00\/\\:\*\?\"<>\|]/, '_')
+  end
+
+  ###################
+  # Debug functions #
+  def self.grep(dir, needle)
+    Find.find(dir) do |path|
+      next if FileTest.directory? path
+
+      basename = File.basename(path)
+      basename_downcase = basename.downcase
+      basename_noext = File.basename(basename_downcase, '.*')
+      parent_path = File.dirname(path)
+      ext = File.extname(basename_downcase)
+
+      if ext.downcase == '.mps'
+        WolfRpg::Map.new(path).grep(needle)
+      elsif ext.downcase == '.project'
+        next if basename_downcase == 'sysdatabasebasic.project'
+        dat_filename = WolfTrans.join_path_nocase(parent_path, "#{basename_noext}.dat")
+        next if dat_filename == nil
+        WolfRpg::Database.new(path, dat_filename).grep(needle)
+      elsif basename_downcase == 'commonevent.dat'
+        WolfRpg::CommonEvents.new(path).grep(needle)
+      end
+    end
+  end
+
+  def self.grep_cid(dir, cid)
+    Find.find(dir) do |path|
+      next if FileTest.directory? path
+      if File.extname(path).downcase == '.mps'
+        WolfRpg::Map.new(path).grep_cid(cid)
+      end
+    end
+  end
+
+  # Latest patch version format that can be read
+  TXT_VERSION = Version.new(major: 1, minor: 0)
+end