wolftrans 0.0.1

data/lib/wolfrpg/command.rb

@@ -0,0 +1,218 @@
+require 'wolfrpg/route'
+
+module WolfRpg
+  class Command
+    attr_reader :cid
+    attr_reader :args
+    attr_reader :string_args
+    attr_reader :indent
+
+    #############################
+    # Command class definitions #
+
+    class Blank < Command
+    end
+
+    class Message < Command
+      def text
+        @string_args[0]
+      end
+      def text=(value)
+        @string_args[0] = value
+      end
+    end
+
+    class Choices < Command
+      def text
+        @string_args
+      end
+    end
+
+    class Comment < Command
+      def text
+        @string_args[0]
+      end
+    end
+
+    class DebugMessage < Command
+      def text
+        @string_args[0]
+      end
+    end
+
+    class StringCondition < Command
+    end
+
+    class SetString < Command
+      def text
+        if @string_args.length > 0
+          @string_args[0]
+        else
+          ''
+        end
+      end
+
+      def text=(value)
+        @string_args[0] = value
+      end
+    end
+
+    class Picture < Command
+      def type
+        case (args[0] >> 4) & 0x07
+        when 0
+          :file
+        when 1
+          :file_string
+        when 2
+          :text
+        when 3
+          :window_file
+        when 4
+          :window_string
+        else
+          nil
+        end
+      end
+
+      def num
+        args[1]
+      end
+
+      def text
+        if type != :text
+          raise "picture type #{type} has no text"
+        end
+        return '' if string_args.empty?
+        string_args[0]
+      end
+      def text=(value)
+        if type != :text
+          raise "picture type #{type} has no text"
+        end
+        if string_args.empty?
+          string_args << value
+        else
+          string_args[0] = value
+        end
+      end
+
+      def filename
+        if type != :file && type != :window_file
+          raise "picture type #{type} has no filename"
+        end
+        string_args[0]
+      end
+      def filename=(value)
+        if type != :file && type != :window_file
+          raise "picture type #{type} has no filename"
+        end
+        string_args[0] = value
+      end
+    end
+
+    #class
+
+    private
+    ##########################
+    # Map of CIDs to classes #
+
+    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
+
+    public
+    class Move < Command
+      def initialize(cid, args, string_args, indent, file)
+        super(cid, args, string_args, indent)
+        # Read unknown data
+        @unknown = Array.new(5)
+        @unknown.each_index do |i|
+          @unknown[i] = IO.read_byte(file)
+        end
+        # Read known data
+        #TODO further abstract this
+        @flags = IO.read_byte(file)
+
+        # Read route
+        @route = Array.new(IO.read_int(file))
+        @route.each_index do |i|
+          @route[i] = RouteCommand.create(file)
+        end
+      end
+
+      def dump_terminator(file)
+        IO.write_byte(file, 1)
+        @unknown.each do |byte|
+          IO.write_byte(file, byte)
+        end
+        IO.write_byte(file, @flags)
+        IO.write_int(file, @route.size)
+        @route.each do |cmd|
+          cmd.dump(file)
+        end
+      end
+    end
+
+    # Load from the file and create the appropriate class object
+    def self.create(file)
+      # Read all data for this command from file
+      args = Array.new(IO.read_byte(file) - 1)
+      cid = IO.read_int(file)
+      args.each_index do |i|
+        args[i] = IO.read_int(file)
+      end
+      indent = IO.read_byte(file)
+      string_args = Array.new(IO.read_byte(file))
+      string_args.each_index do |i|
+        string_args[i] = IO.read_string(file)
+      end
+
+      # Read the move list if necessary
+      terminator = IO.read_byte(file)
+      if terminator == 0x01
+        return Command::Move.new(cid, args, string_args, indent, file)
+      elsif terminator != 0x00
+        raise "command terminator is an unexpected value (#{terminator})"
+      end
+
+      # Create command
+      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)
+      @args.each do |arg|
+        IO.write_int(file, arg)
+      end
+      IO.write_byte(file, indent)
+      IO.write_byte(file, @string_args.size)
+      @string_args.each do |arg|
+        IO.write_string(file, arg)
+      end
+
+      dump_terminator(file)
+    end
+
+    private
+    def initialize(cid, args, string_args, indent)
+      @cid = cid
+      @args = args
+      @string_args = string_args
+      @indent = indent
+    end
+
+    def dump_terminator(file)
+      IO.write_byte(file, 0)
+    end
+  end
+end

data/lib/wolfrpg/common_events.rb

@@ -0,0 +1,160 @@
+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))
+        @events.each_index do |i|
+          event = Event.new(file)
+          events[event.id] = event
+        end
+        if (terminator = IO.read_byte(file)) != 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)
+        @events.each do |event|
+          event.dump(file)
+        end
+        IO.write_byte(file, 0x8F)
+      end
+    end
+
+    def grep(needle)
+    end
+
+    class Event
+      attr_accessor :id
+      attr_accessor :name
+      attr_accessor :commands
+
+      def initialize(file)
+        if (indicator = IO.read_byte(file)) != 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))
+        @commands.each_index do |i|
+          @commands[i] = Command.create(file)
+        end
+        @unknown11 = IO.read_string(file)
+        @description = IO.read_string(file)
+        if (indicator = IO.read_byte(file)) != 0x8F
+          raise "CommonEvent data indicator not 0x8F (got 0x#{indicator.to_s(16)})"
+        end
+        IO.verify(file, MAGIC_NUMBER)
+        @unknown3 = Array.new(10)
+        @unknown3.each_index do |i|
+          @unknown3[i] = IO.read_string(file)
+        end
+        IO.verify(file, MAGIC_NUMBER)
+        @unknown4 = Array.new(10)
+        @unknown4.each_index do |i|
+          @unknown4[i] = IO.read_byte(file)
+        end
+        IO.verify(file, MAGIC_NUMBER)
+        @unknown5 = Array.new(10)
+        @unknown5.each_index do |i|
+          @unknown5[i] = Array.new(IO.read_int(file))
+          @unknown5[i].each_index do |j|
+            @unknown5[i][j] = IO.read_string(file)
+          end
+        end
+        IO.verify(file, MAGIC_NUMBER)
+        @unknown6 = Array.new(10)
+        @unknown6.each_index do |i|
+          @unknown6[i] = Array.new(IO.read_int(file))
+          @unknown6[i].each_index do |j|
+            @unknown6[i][j] = IO.read_int(file)
+          end
+        end
+        @unknown7 = IO.read(file, 0x1D)
+        @unknown8 = Array.new(100)
+        @unknown8.each_index do |i|
+          @unknown8[i] = IO.read_string(file)
+        end
+        if (indicator = IO.read_byte(file)) != 0x91
+          raise "expected 0x91, got 0x#{indicator.to_s(16)}"
+        end
+        @unknown9 = IO.read_string(file)
+        if (indicator = IO.read_byte(file)) != 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
+          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)
+        @commands.each do |cmd|
+          cmd.dump(file)
+        end
+        IO.write_string(file, @unknown11)
+        IO.write_string(file, @description)
+        IO.write_byte(file, 0x8F)
+        IO.write(file, MAGIC_NUMBER)
+        @unknown3.each do |i|
+          IO.write_string(file, i)
+        end
+        IO.write(file, MAGIC_NUMBER)
+        @unknown4.each do |i|
+          IO.write_byte(file, i)
+        end
+        IO.write(file, MAGIC_NUMBER)
+        @unknown5.each do |i|
+          IO.write_int(file, i.size)
+          i.each do |j|
+            IO.write_string(file, j)
+          end
+        end
+        IO.write(file, MAGIC_NUMBER)
+        @unknown6.each do |i|
+          IO.write_int(file, i.size)
+          i.each do |j|
+            IO.write_int(file, j)
+          end
+        end
+        IO.write(file, @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)
+      end
+
+      private
+      MAGIC_NUMBER = [
+        0x0A, 0x00, 0x00, 0x00
+      ].pack('C*')
+    end
+
+    private
+    MAGIC_NUMBER = [
+      0x00, 0x57, 0x00, 0x00, 0x4F, 0x4C, 0x00, 0x46, 0x43, 0x00, 0x8F
+    ].pack('C*')
+  end
+end

data/lib/wolfrpg/database.rb

@@ -0,0 +1,315 @@
+module WolfRpg
+  class Database
+    attr_accessor :name #DEBUG
+    attr_accessor :types
+
+    def initialize(project_filename, dat_filename)
+      @name = File.basename(project_filename, '.*')
+      File.open(project_filename, 'rb') do |file|
+        @types = Array.new(IO.read_int(file))
+        @types.each_index do |i|
+          @types[i] = Type.new(file)
+        end
+      end
+      File.open(dat_filename, 'rb') do |file|
+        IO.verify(file, DAT_MAGIC_NUMBER)
+        num_types = IO.read_int(file)
+        unless num_types == @types.size
+          raise "database project and dat Type count mismatch (#{@types.size} vs. #{num_types})"
+        end
+        @types.each do |type|
+          type.read_dat(file)
+        end
+        if IO.read_byte(file) != 0xC1
+          STDERR.puts "warning: no C1 terminator at the end of '#{dat_filename}'"
+        end
+      end
+
+      def dump(project_filename, dat_filename)
+        File.open(project_filename, 'wb') do |file|
+          IO.write_int(file, @types.size)
+          @types.each do |type|
+            type.dump_project(file)
+          end
+        end
+        File.open(dat_filename, 'wb') do |file|
+          IO.write(file, DAT_MAGIC_NUMBER)
+          IO.write_int(file, @types.size)
+          @types.each do |type|
+            type.dump_dat(file)
+          end
+          IO.write_byte(file, 0xC1)
+        end
+      end
+
+      def grep(needle)
+        @types.each_with_index do |type, type_index|
+          type.data.each_with_index do |datum, datum_index|
+            datum.each_translatable do |value, field|
+              next unless value =~ needle
+              puts "DB:#{@name}/[#{type_index}]#{type.name}/[#{datum_index}]#{datum.name}/[#{field.index}]#{field.name}"
+              puts "\t" + value
+            end
+          end
+        end
+      end
+    end
+
+    class Type
+      attr_accessor :name
+      attr_accessor :fields
+      attr_accessor :data
+      attr_accessor :description
+      attr_accessor :unknown1
+
+      # Initialize from project file IO
+      def initialize(file)
+        @name = IO.read_string(file)
+        @fields = Array.new(IO.read_int(file))
+        @fields.each_index do |i|
+          @fields[i] = Field.new(file)
+        end
+        @data = Array.new(IO.read_int(file))
+        @data.each_index do |i|
+          @data[i] = Data.new(file)
+        end
+        @description = IO.read_string(file)
+
+        # Add misc data to fields. It's separated for some reason.
+
+        # This appears to always be 0x64, but save it anyway
+        @field_type_list_size = IO.read_int(file)
+        index = 0
+        while index < @fields.size
+          @fields[index].type = IO.read_byte(file)
+          index += 1
+        end
+        file.seek(@field_type_list_size - index, :CUR)
+
+        IO.read_int(file).times do |i|
+          @fields[i].unknown1 = IO.read_string(file)
+        end
+        IO.read_int(file).times do |i|
+          @fields[i].string_args = Array.new(IO.read_int(file))
+          @fields[i].string_args.each_index do |j|
+            @fields[i].string_args[j] = IO.read_string(file)
+          end
+        end
+        IO.read_int(file).times do |i|
+          @fields[i].args = Array.new(IO.read_int(file))
+          @fields[i].args.each_index do |j|
+            @fields[i].args[j] = IO.read_int(file)
+          end
+        end
+        IO.read_int(file).times do |i|
+          @fields[i].default_value = IO.read_int(file)
+        end
+      end
+
+      def dump_project(file)
+        IO.write_string(file, @name)
+        IO.write_int(file, @fields.size)
+        @fields.each do |field|
+          field.dump_project(file)
+        end
+        IO.write_int(file, @data.size)
+        @data.each do |datum|
+          datum.dump_project(file)
+        end
+        IO.write_string(file, @description)
+
+        # Dump misc field data
+        IO.write_int(file, @field_type_list_size)
+        index = 0
+        while index < @fields.size
+          IO.write_byte(file, @fields[index].type)
+          index += 1
+        end
+        while index < @field_type_list_size
+          IO.write_byte(file, 0)
+          index += 1
+        end
+        IO.write_int(file, @fields.size)
+        @fields.each do |field|
+          IO.write_string(file, field.unknown1)
+        end
+        IO.write_int(file, @fields.size)
+        @fields.each do |field|
+          IO.write_int(file, field.string_args.size)
+          field.string_args.each do |arg|
+            IO.write_string(file, arg)
+          end
+        end
+        IO.write_int(file, @fields.size)
+        @fields.each do |field|
+          IO.write_int(file, field.args.size)
+          field.args.each do |arg|
+            IO.write_int(file, arg)
+          end
+        end
+        IO.write_int(file, @fields.size)
+        @fields.each do |field|
+          IO.write_int(file, field.default_value)
+        end
+      end
+
+      # Read the rest of the data from the dat file
+      def read_dat(file)
+        IO.verify(file, DAT_TYPE_SEPARATOR)
+        @unknown1 = IO.read_int(file)
+        num_fields = IO.read_int(file)
+        unless num_fields == @fields.size
+          raise "database project and dat Field count mismatch (#{@fields.size} vs. #{num_fields})"
+        end
+        @fields.each do |field|
+          field.read_dat(file)
+        end
+        num_data = IO.read_int(file)
+        unless num_data == @data.size
+          raise "database project and dat Field count mismatch (#{@data.size} vs. #{num_data})"
+        end
+        @data.each do |datum|
+          datum.read_dat(file, @fields)
+        end
+      end
+
+      def dump_dat(file)
+        IO.write(file, DAT_TYPE_SEPARATOR)
+        IO.write_int(file, @unknown1)
+        IO.write_int(file, @fields.size)
+        @fields.each do |field|
+          field.dump_dat(file)
+        end
+        IO.write_int(file, @data.size)
+        @data.each do |datum|
+          datum.dump_dat(file)
+        end
+      end
+    end
+
+
+    class Field
+      attr_accessor :name
+      attr_accessor :type
+      attr_accessor :unknown1
+      attr_accessor :string_args
+      attr_accessor :args
+      attr_accessor :default_value
+      attr_accessor :indexinfo
+
+      def initialize(file)
+        @name = IO.read_string(file)
+      end
+
+      def dump_project(file)
+        IO.write_string(file, @name)
+      end
+
+      def read_dat(file)
+        @indexinfo = IO.read_int(file)
+      end
+
+      def dump_dat(file)
+        IO.write_int(file, @indexinfo)
+      end
+
+      def string?
+        @indexinfo >= STRING_START
+      end
+
+      def int?
+        !string?
+      end
+
+      def index
+        if string?
+          @indexinfo - STRING_START
+        else
+          @indexinfo - INT_START
+        end
+      end
+
+      STRING_START = 0x07D0
+      INT_START = 0x03E8
+    end
+
+    class Data
+      attr_accessor :name
+      attr_accessor :int_values
+      attr_accessor :string_values
+
+      def initialize(file)
+        @name = IO.read_string(file)
+      end
+
+      def dump_project(file)
+        IO.write_string(file, @name)
+      end
+
+      def read_dat(file, fields)
+        @fields = fields
+        @int_values = Array.new(fields.select(&:int?).size)
+        @string_values = Array.new(fields.select(&:string?).size)
+
+        @int_values.each_index do |i|
+          @int_values[i] = IO.read_int(file)
+        end
+        @string_values.each_index do |i|
+          @string_values[i] = IO.read_string(file)
+        end
+      end
+
+      def dump_dat(file)
+        @int_values.each do |i|
+          IO.write_int(file, i)
+        end
+        @string_values.each do |i|
+          IO.write_string(file, i)
+        end
+      end
+
+      def [](key)
+        if key.is_a? Field
+          if key.string?
+            @string_values[key.index]
+          else
+            @int_values[key.index]
+          end
+        elsif value.is_a? Integer
+          self[@fields[key]]
+        else
+          raise "Data[] takes a Field, got a #{value.class}"
+        end
+      end
+
+      def []=(key, value)
+        if key.is_a? Field
+          if key.string?
+            @string_values[key.index] = value
+          else
+            @int_values[key.index] = value
+          end
+        elsif value.is_a? Integer
+          self[@fields[key]] = value
+        else
+          raise "Data[] takes a Field, got a #{value.class}"
+        end
+      end
+
+      def each_translatable
+        @fields.each do |field|
+          next unless field.string? && field.type == 0
+          value = self[field]
+          yield [value, field] unless value.empty? || value.include?("\n")
+        end
+      end
+    end
+
+    DAT_MAGIC_NUMBER = [
+      0x00, 0x57, 0x00, 0x00, 0x4F, 0x4C, 0x00, 0x46, 0x4D, 0x00, 0xC1
+    ].pack('C*')
+    DAT_TYPE_SEPARATOR = [
+      0xFE, 0xFF, 0xFF, 0xFF
+    ].pack('C*')
+  end
+end