6.6 update

Data/Scripts/021_Compiler/001_Compiler.rb

@@ -0,0 +1,852 @@
+require 'zlib'
+
+#===============================================================================
+# Records which file, section and line are currently being read
+#===============================================================================
+module FileLineData
+  @file     = ""
+  @linedata = ""
+  @lineno   = 0
+  @section  = nil
+  @key      = nil
+  @value    = nil
+
+  def self.file; return @file; end
+  def self.file=(value); @file = value; end
+
+  def self.clear
+    @file     = ""
+    @linedata = ""
+    @lineno   = ""
+    @section  = nil
+    @key      = nil
+    @value    = nil
+  end
+
+  def self.setSection(section,key,value)
+    @section = section
+    @key     = key
+    if value && value.length>200
+      @value = _INTL("{1}...",value[0,200])
+    else
+      @value = (value) ? value.clone : ""
+    end
+  end
+
+  def self.setLine(line,lineno)
+    @section  = nil
+    @linedata = (line && line.length>200) ? sprintf("%s...",line[0,200]) : line.clone
+    @lineno   = lineno
+  end
+
+  def self.linereport
+    if @section
+      if @key!=nil
+        return _INTL("File {1}, section {2}, key {3}\r\n{4}\r\n\r\n",@file,@section,@key,@value)
+      else
+        return _INTL("File {1}, section {2}\r\n{3}\r\n\r\n",@file,@section,@value)
+      end
+    else
+      return _INTL("File {1}, line {2}\r\n{3}\r\n\r\n",@file,@lineno,@linedata)
+    end
+  end
+end
+
+#===============================================================================
+# Compiler
+#===============================================================================
+module Compiler
+  module_function
+
+  def findIndex(a)
+    index = -1
+    count = 0
+    a.each { |i|
+      if yield i
+        index = count
+        break
+      end
+      count += 1
+    }
+    return index
+  end
+
+  def prepline(line)
+    line.sub!(/\s*\#.*$/,"")
+    line.sub!(/^\s+/,"")
+    line.sub!(/\s+$/,"")
+    return line
+  end
+
+  def csvQuote(str,always=false)
+    return "" if nil_or_empty?(str)
+    if always || str[/[,\"]/]   # || str[/^\s/] || str[/\s$/] || str[/^#/]
+      str = str.gsub(/[\"]/,"\\\"")
+      str = "\"#{str}\""
+    end
+    return str
+  end
+
+  def csvQuoteAlways(str)
+    return csvQuote(str,true)
+  end
+
+  #=============================================================================
+  # PBS file readers
+  #=============================================================================
+  def pbEachFileSectionEx(f)
+    lineno      = 1
+    havesection = false
+    sectionname = nil
+    lastsection = {}
+    f.each_line { |line|
+      if lineno==1 && line[0].ord==0xEF && line[1].ord==0xBB && line[2].ord==0xBF
+        line = line[3,line.length-3]
+      end
+      if !line[/^\#/] && !line[/^\s*$/]
+        if line[/^\s*\[\s*(.*)\s*\]\s*$/]   # Of the format: [something]
+          yield lastsection,sectionname if havesection
+          sectionname = $~[1]
+          havesection = true
+          lastsection = {}
+        else
+          if sectionname==nil
+            FileLineData.setLine(line,lineno)
+            raise _INTL("Expected a section at the beginning of the file. This error may also occur if the file was not saved in UTF-8.\r\n{1}",FileLineData.linereport)
+          end
+          if !line[/^\s*(\w+)\s*=\s*(.*)$/]
+            FileLineData.setSection(sectionname,nil,line)
+            raise _INTL("Bad line syntax (expected syntax like XXX=YYY)\r\n{1}",FileLineData.linereport)
+          end
+          r1 = $~[1]
+          r2 = $~[2]
+          lastsection[r1] = r2.gsub(/\s+$/,"")
+        end
+      end
+      lineno += 1
+      Graphics.update if lineno%200==0
+      pbSetWindowText(_INTL("Processing {1} line {2}",FileLineData.file,lineno)) if lineno%50==0
+    }
+    yield lastsection,sectionname if havesection
+  end
+
+  # Used for types.txt, pokemon.txt, metadata.txt
+  def pbEachFileSection(f)
+    pbEachFileSectionEx(f) { |section,name|
+      yield section,name.to_i if block_given? && name[/^\d+$/]
+    }
+  end
+
+  # Used for pokemonforms.txt
+  def pbEachFileSection2(f)
+    pbEachFileSectionEx(f) { |section,name|
+      yield section,name if block_given? && name[/^\w+[-,\s]{1}\d+$/]
+    }
+  end
+
+  # Used for phone.txt
+  def pbEachSection(f)
+    lineno      = 1
+    havesection = false
+    sectionname = nil
+    lastsection = []
+    f.each_line { |line|
+      if lineno==1 && line[0].ord==0xEF && line[1].ord==0xBB && line[2].ord==0xBF
+        line = line[3,line.length-3]
+      end
+      if !line[/^\#/] && !line[/^\s*$/]
+        if line[/^\s*\[\s*(.+?)\s*\]\s*$/]
+          yield lastsection,sectionname  if havesection
+          sectionname = $~[1]
+          lastsection = []
+          havesection = true
+        else
+          if sectionname==nil
+            raise _INTL("Expected a section at the beginning of the file (line {1}). Sections begin with '[name of section]'",lineno)
+          end
+          lastsection.push(line.gsub(/^\s+/,"").gsub(/\s+$/,""))
+        end
+      end
+      lineno += 1
+      Graphics.update if lineno%500==0
+    }
+    yield lastsection,sectionname  if havesection
+  end
+
+  # Unused
+  def pbEachCommentedLine(f)
+    lineno = 1
+    f.each_line { |line|
+      if lineno==1 && line[0].ord==0xEF && line[1].ord==0xBB && line[2].ord==0xBF
+        line = line[3,line.length-3]
+      end
+      yield line, lineno if !line[/^\#/] && !line[/^\s*$/]
+      lineno += 1
+    }
+  end
+
+  # Used for many PBS files
+  def pbCompilerEachCommentedLine(filename)
+    File.open(filename,"rb") { |f|
+      FileLineData.file = filename
+      lineno = 1
+      f.each_line { |line|
+        if lineno==1 && line[0].ord==0xEF && line[1].ord==0xBB && line[2].ord==0xBF
+          line = line[3,line.length-3]
+        end
+        if !line[/^\#/] && !line[/^\s*$/]
+          FileLineData.setLine(line,lineno)
+          yield line, lineno
+        end
+        lineno += 1
+      }
+    }
+  end
+
+  # Unused
+  def pbEachPreppedLine(f)
+    lineno = 1
+    f.each_line { |line|
+      if lineno==1 && line[0].ord==0xEF && line[1].ord==0xBB && line[2].ord==0xBF
+        line = line[3,line.length-3]
+      end
+      line = prepline(line)
+      yield line, lineno if !line[/^\#/] && !line[/^\s*$/]
+      lineno += 1
+    }
+  end
+
+  # Used for connections.txt, abilities.txt, moves.txt, regionaldexes.txt
+  def pbCompilerEachPreppedLine(filename)
+    File.open(filename,"rb") { |f|
+      FileLineData.file = filename
+      lineno = 1
+      f.each_line { |line|
+        if lineno==1 && line[0].ord==0xEF && line[1].ord==0xBB && line[2].ord==0xBF
+          line = line[3,line.length-3]
+        end
+        line = prepline(line)
+        if !line[/^\#/] && !line[/^\s*$/]
+          FileLineData.setLine(line,lineno)
+          yield line, lineno
+        end
+        lineno += 1
+      }
+    }
+  end
+
+  #=============================================================================
+  # Convert a string to certain kinds of values
+  #=============================================================================
+  def csvfield!(str)
+    ret = ""
+    str.sub!(/^\s*/,"")
+    if str[0,1]=="\""
+      str[0,1] = ""
+      escaped = false
+      fieldbytes = 0
+      str.scan(/./) do |s|
+        fieldbytes += s.length
+        break if s=="\"" && !escaped
+        if s=="\\" && !escaped
+          escaped = true
+        else
+          ret += s
+          escaped = false
+        end
+      end
+      str[0,fieldbytes] = ""
+      if !str[/^\s*,/] && !str[/^\s*$/]
+        raise _INTL("Invalid quoted field (in: {1})\r\n{2}",str,FileLineData.linereport)
+      end
+      str[0,str.length] = $~.post_match
+    else
+      if str[/,/]
+        str[0,str.length] = $~.post_match
+        ret = $~.pre_match
+      else
+        ret = str.clone
+        str[0,str.length] = ""
+      end
+      ret.gsub!(/\s+$/,"")
+    end
+    return ret
+  end
+
+  def csvBoolean!(str,_line=-1)
+    field = csvfield!(str)
+    if field[/^1|[Tt][Rr][Uu][Ee]|[Yy][Ee][Ss]|[Yy]$/]
+      return true
+    elsif field[/^0|[Ff][Aa][Ll][Ss][Ee]|[Nn][Oo]|[Nn]$/]
+      return false
+    end
+    raise _INTL("Field {1} is not a Boolean value (true, false, 1, 0)\r\n{2}",field,FileLineData.linereport)
+  end
+
+  def csvInt!(str,_line=-1)
+    ret = csvfield!(str)
+    if !ret[/^\-?\d+$/]
+      raise _INTL("Field {1} is not an integer\r\n{2}",ret,FileLineData.linereport)
+    end
+    return ret.to_i
+  end
+
+  def csvPosInt!(str,_line=-1)
+    ret = csvfield!(str)
+    if !ret[/^\d+$/]
+      raise _INTL("Field {1} is not a positive integer\r\n{2}",ret,FileLineData.linereport)
+    end
+    return ret.to_i
+  end
+
+  def csvFloat!(str,_line=-1)
+    ret = csvfield!(str)
+    return Float(ret) rescue raise _INTL("Field {1} is not a number\r\n{2}",ret,FileLineData.linereport)
+  end
+
+  def csvEnumField!(value,enumer,_key,_section)
+    ret = csvfield!(value)
+    return checkEnumField(ret,enumer)
+  end
+
+  def csvEnumFieldOrInt!(value,enumer,_key,_section)
+    ret = csvfield!(value)
+    return ret.to_i if ret[/\-?\d+/]
+    return checkEnumField(ret,enumer)
+  end
+
+  def checkEnumField(ret,enumer)
+    if enumer.is_a?(Module)
+      begin
+        if nil_or_empty?(ret) || !enumer.const_defined?(ret)
+          raise _INTL("Undefined value {1} in {2}\r\n{3}",ret,enumer.name,FileLineData.linereport)
+        end
+      rescue NameError
+        raise _INTL("Incorrect value {1} in {2}\r\n{3}",ret,enumer.name,FileLineData.linereport)
+      end
+      return enumer.const_get(ret.to_sym)
+    elsif enumer.is_a?(Symbol) || enumer.is_a?(String)
+      if !Kernel.const_defined?(enumer.to_sym) && GameData.const_defined?(enumer.to_sym)
+        enumer = GameData.const_get(enumer.to_sym)
+        begin
+          if nil_or_empty?(ret) || !enumer.exists?(ret.to_sym)
+            if enumer != GameData::Species
+              raise _INTL("Undefined value {1} in {2}\r\n{3}", ret, enumer.name, FileLineData.linereport)
+            end
+          end
+        rescue NameError
+          raise _INTL("Incorrect value {1} in {2}\r\n{3}", ret, enumer.name, FileLineData.linereport)
+        end
+        return ret.to_sym
+      end
+      enumer = Object.const_get(enumer.to_sym)
+      begin
+        if nil_or_empty?(ret) || !enumer.const_defined?(ret)
+          raise _INTL("Undefined value {1} in {2}\r\n{3}",ret,enumer.name,FileLineData.linereport)
+        end
+      rescue NameError
+        raise _INTL("Incorrect value {1} in {2}\r\n{3}",ret,enumer.name,FileLineData.linereport)
+      end
+      return enumer.const_get(ret.to_sym)
+    elsif enumer.is_a?(Array)
+      idx = findIndex(enumer) { |item| ret==item }
+      if idx<0
+        raise _INTL("Undefined value {1} (expected one of: {2})\r\n{3}",ret,enumer.inspect,FileLineData.linereport)
+      end
+      return idx
+    elsif enumer.is_a?(Hash)
+      value = enumer[ret]
+      if value==nil
+        raise _INTL("Undefined value {1} (expected one of: {2})\r\n{3}",ret,enumer.keys.inspect,FileLineData.linereport)
+      end
+      return value
+    end
+    raise _INTL("Enumeration not defined\r\n{1}",FileLineData.linereport)
+  end
+
+  def checkEnumFieldOrNil(ret,enumer)
+    if enumer.is_a?(Module)
+      return nil if nil_or_empty?(ret) || !(enumer.const_defined?(ret) rescue false)
+      return enumer.const_get(ret.to_sym)
+    elsif enumer.is_a?(Symbol) || enumer.is_a?(String)
+      if GameData.const_defined?(enumer.to_sym)
+        enumer = GameData.const_get(enumer.to_sym)
+        return nil if nil_or_empty?(ret) || !enumer.exists?(ret.to_sym)
+        return ret.to_sym
+      end
+      enumer = Object.const_get(enumer.to_sym)
+      return nil if nil_or_empty?(ret) || !(enumer.const_defined?(ret) rescue false)
+      return enumer.const_get(ret.to_sym)
+    elsif enumer.is_a?(Array)
+      idx = findIndex(enumer) { |item| ret==item }
+      return nil if idx<0
+      return idx
+    elsif enumer.is_a?(Hash)
+      return enumer[ret]
+    end
+    return nil
+  end
+
+  #=============================================================================
+  # Convert a string to values using a schema
+  #=============================================================================
+  def pbGetCsvRecord(rec,lineno,schema)
+    record = []
+    repeat = false
+    start = 0
+    if schema[1][0,1]=="*"
+      repeat = true
+      start = 1
+    end
+    begin
+      for i in start...schema[1].length
+        chr = schema[1][i,1]
+        case chr
+        when "i"   # Integer
+          record.push(csvInt!(rec,lineno))
+        when "I"   # Optional integer
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif !field[/^\-?\d+$/]
+            raise _INTL("Field {1} is not an integer\r\n{2}",field,FileLineData.linereport)
+          else
+            record.push(field.to_i)
+          end
+        when "u"   # Positive integer or zero
+          record.push(csvPosInt!(rec,lineno))
+        when "U"   # Optional positive integer or zero
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif !field[/^\d+$/]
+            raise _INTL("Field '{1}' must be 0 or greater\r\n{2}",field,FileLineData.linereport)
+          else
+            record.push(field.to_i)
+          end
+        when "v"   # Positive integer
+          field = csvPosInt!(rec,lineno)
+          raise _INTL("Field '{1}' must be greater than 0\r\n{2}",field,FileLineData.linereport) if field==0
+          record.push(field)
+        when "V"   # Optional positive integer
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif !field[/^\d+$/]
+            raise _INTL("Field '{1}' must be greater than 0\r\n{2}",field,FileLineData.linereport)
+          elsif field.to_i==0
+            raise _INTL("Field '{1}' must be greater than 0\r\n{2}",field,FileLineData.linereport)
+          else
+            record.push(field.to_i)
+          end
+        when "x"   # Hexadecimal number
+          field = csvfield!(rec)
+          if !field[/^[A-Fa-f0-9]+$/]
+            raise _INTL("Field '{1}' is not a hexadecimal number\r\n{2}",field,FileLineData.linereport)
+          end
+          record.push(field.hex)
+        when "X"   # Optional hexadecimal number
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif !field[/^[A-Fa-f0-9]+$/]
+            raise _INTL("Field '{1}' is not a hexadecimal number\r\n{2}",field,FileLineData.linereport)
+          else
+            record.push(field.hex)
+          end
+        when "f"   # Floating point number
+          record.push(csvFloat!(rec,lineno))
+        when "F"   # Optional floating point number
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif !field[/^\-?^\d*\.?\d*$/]
+            raise _INTL("Field {1} is not a floating point number\r\n{2}",field,FileLineData.linereport)
+          else
+            record.push(field.to_f)
+          end
+        when "b"   # Boolean
+          record.push(csvBoolean!(rec,lineno))
+        when "B"   # Optional Boolean
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif field[/^1|[Tt][Rr][Uu][Ee]|[Yy][Ee][Ss]|[Tt]|[Yy]$/]
+            record.push(true)
+          else
+            record.push(false)
+          end
+        when "n"   # Name
+          field = csvfield!(rec)
+          if !field[/^(?![0-9])\w+$/]
+            raise _INTL("Field '{1}' must contain only letters, digits, and\r\nunderscores and can't begin with a number.\r\n{2}",field,FileLineData.linereport)
+          end
+          record.push(field)
+        when "N"   # Optional name
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif !field[/^(?![0-9])\w+$/]
+            raise _INTL("Field '{1}' must contain only letters, digits, and\r\nunderscores and can't begin with a number.\r\n{2}",field,FileLineData.linereport)
+          else
+            record.push(field)
+          end
+        when "s"   # String
+          record.push(csvfield!(rec))
+        when "S"   # Optional string
+          field = csvfield!(rec)
+          record.push((nil_or_empty?(field)) ? nil : field)
+        when "q"   # Unformatted text
+          record.push(rec)
+          rec = ""
+        when "Q"   # Optional unformatted text
+          if nil_or_empty?(rec)
+            record.push(nil)
+          else
+            record.push(rec)
+            rec = ""
+          end
+        when "e"   # Enumerable
+          record.push(csvEnumField!(rec,schema[2+i-start],"",FileLineData.linereport))
+        when "E"   # Optional enumerable
+          field = csvfield!(rec)
+          record.push(checkEnumFieldOrNil(field,schema[2+i-start]))
+        when "y"   # Enumerable or integer
+          field = csvfield!(rec)
+          record.push(csvEnumFieldOrInt!(field,schema[2+i-start],"",FileLineData.linereport))
+        when "Y"   # Optional enumerable or integer
+          field = csvfield!(rec)
+          if nil_or_empty?(field)
+            record.push(nil)
+          elsif field[/^\-?\d+$/]
+            record.push(field.to_i)
+          else
+            record.push(checkEnumFieldOrNil(field,schema[2+i-start]))
+          end
+        end
+      end
+      break if repeat && nil_or_empty?(rec)
+    end while repeat
+    return (schema[1].length==1) ? record[0] : record
+  end
+
+  #=============================================================================
+  # Write values to a file using a schema
+  #=============================================================================
+  def pbWriteCsvRecord(record,file,schema)
+    rec = (record.is_a?(Array)) ? record.clone : [record]
+    for i in 0...schema[1].length
+      chr = schema[1][i,1]
+      file.write(",") if i>0
+      if rec[i].nil?
+        # do nothing
+      elsif rec[i].is_a?(String)
+        file.write(csvQuote(rec[i]))
+      elsif rec[i].is_a?(Symbol)
+        file.write(csvQuote(rec[i].to_s))
+      elsif rec[i]==true
+        file.write("true")
+      elsif rec[i]==false
+        file.write("false")
+      elsif rec[i].is_a?(Numeric)
+        case chr
+        when "e", "E"   # Enumerable
+          enumer = schema[2+i]
+          if enumer.is_a?(Array)
+            file.write(enumer[rec[i]])
+          elsif enumer.is_a?(Symbol) || enumer.is_a?(String)
+            mod = Object.const_get(enumer.to_sym)
+            file.write(getConstantName(mod,rec[i]))
+          elsif enumer.is_a?(Module)
+            file.write(getConstantName(enumer,rec[i]))
+          elsif enumer.is_a?(Hash)
+            for key in enumer.keys
+              if enumer[key]==rec[i]
+                file.write(key)
+                break
+              end
+            end
+          end
+        when "y", "Y"   # Enumerable or integer
+          enumer = schema[2+i]
+          if enumer.is_a?(Array)
+            if enumer[rec[i]]!=nil
+              file.write(enumer[rec[i]])
+            else
+              file.write(rec[i])
+            end
+          elsif enumer.is_a?(Symbol) || enumer.is_a?(String)
+            mod = Object.const_get(enumer.to_sym)
+            file.write(getConstantNameOrValue(mod,rec[i]))
+          elsif enumer.is_a?(Module)
+            file.write(getConstantNameOrValue(enumer,rec[i]))
+          elsif enumer.is_a?(Hash)
+            hasenum = false
+            for key in enumer.keys
+              if enumer[key]==rec[i]
+                file.write(key)
+                hasenum = true; break
+              end
+            end
+            file.write(rec[i]) unless hasenum
+          end
+        else   # Any other record type
+          file.write(rec[i].inspect)
+        end
+      else
+        file.write(rec[i].inspect)
+      end
+    end
+    return record
+  end
+
+  #=============================================================================
+  # Parse string into a likely constant name and return its ID number (if any).
+  # Last ditch attempt to figure out whether a constant is defined.
+  #=============================================================================
+  def pbGetConst(mod,item,err)
+    isDef = false
+    begin
+      mod = Object.const_get(mod) if mod.is_a?(Symbol)
+      isDef = mod.const_defined?(item.to_sym)
+    rescue
+      raise sprintf(err,item)
+    end
+    raise sprintf(err,item) if !isDef
+    return mod.const_get(item.to_sym)
+  end
+
+  def parseItem(item)
+    clonitem = item.upcase
+    clonitem.sub!(/^\s*/, "")
+    clonitem.sub!(/\s*$/, "")
+    itm = GameData::Item.try_get(clonitem)
+    if !itm
+      raise _INTL("Undefined item constant name: {1}\r\nMake sure the item is defined in PBS/items.txt.\r\n{2}", item, FileLineData.linereport)
+    end
+    return itm.id
+  end
+
+  def parseSpecies(species)
+    clonspecies = species.upcase
+    clonspecies.gsub!(/^\s*/, "")
+    clonspecies.gsub!(/\s*$/, "")
+    clonspecies = "NIDORANmA" if clonspecies == "NIDORANMA"
+    clonspecies = "NIDORANfE" if clonspecies == "NIDORANFE"
+    spec = GameData::Species.try_get(clonspecies)
+    if !spec
+      raise _INTL("Undefined species constant name: {1}\r\nMake sure the species is defined in PBS/pokemon.txt.\r\n{2}", species, FileLineData.linereport)
+    end
+    return spec.id
+  end
+
+  def parseMove(move, skip_unknown = false)
+    clonmove = move.upcase
+    clonmove.sub!(/^\s*/, "")
+    clonmove.sub!(/\s*$/, "")
+    mov = GameData::Move.try_get(clonmove)
+    if !mov
+      return nil if skip_unknown
+      raise _INTL("Undefined move constant name: {1}\r\nMake sure the move is defined in PBS/moves.txt.\r\n{2}", move, FileLineData.linereport)
+    end
+    return mov.id
+  end
+
+  # Unused
+  def parseNature(nature)
+    clonnature = nature.upcase
+    clonnature.sub!(/^\s*/, "")
+    clonnature.sub!(/\s*$/, "")
+    nat = GameData::Nature.try_get(clonnature)
+    if !nat
+      raise _INTL("Undefined nature constant name: {1}\r\nMake sure the nature is defined in the scripts.\r\n{2}", nature, FileLineData.linereport)
+    end
+    return nat.id
+  end
+
+  # Unused
+  def parseTrainer(type)
+    clontype = type.clone
+    clontype.sub!(/^\s*/, "")
+    clontype.sub!(/\s*$/, "")
+    typ = GameData::TrainerType.try_get(clontype)
+    if !typ
+      raise _INTL("Undefined Trainer type constant name: {1}\r\nMake sure the trainer type is defined in PBS/trainertypes.txt.\r\n{2}", type, FileLineData.linereport)
+    end
+    return typ.id
+  end
+
+  #=============================================================================
+  # Compile all data
+  #=============================================================================
+  def compile_all(mustCompile)
+    return if !mustCompile
+    FileLineData.clear
+    echoln _INTL("*** Starting full compile ***")
+    echoln ""
+    yield(_INTL("Compiling town map data"))
+    compile_town_map               # No dependencies
+    yield(_INTL("Compiling map connection data"))
+    compile_connections            # No dependencies
+    yield(_INTL("Compiling phone data"))
+    compile_phone                  # No dependencies
+    yield(_INTL("Compiling type data"))
+    compile_types                  # No dependencies
+    yield(_INTL("Compiling ability data"))
+    compile_abilities              # No dependencies
+    yield(_INTL("Compiling move data"))
+    compile_moves                  # Depends on Type
+    yield(_INTL("Compiling item data"))
+    compile_items                  # Depends on Move
+    yield(_INTL("Compiling berry plant data"))
+    compile_berry_plants           # Depends on Item
+    yield(_INTL("Compiling Pokémon data"))
+    compile_pokemon                # Depends on Move, Item, Type, Ability
+    yield(_INTL("Compiling Pokémon forms data"))
+    compile_pokemon_forms          # Depends on Species, Move, Item, Type, Ability
+    yield(_INTL("Compiling machine data"))
+    compile_move_compatibilities   # Depends on Species, Move
+    yield(_INTL("Compiling shadow moveset data"))
+    compile_shadow_movesets        # Depends on Species, Move
+    yield(_INTL("Compiling Regional Dexes"))
+    compile_regional_dexes         # Depends on Species
+    yield(_INTL("Compiling ribbon data"))
+    compile_ribbons                # No dependencies
+    yield(_INTL("Compiling encounter data"))
+    compile_encounters             # Depends on Species
+    yield(_INTL("Compiling Trainer type data"))
+    compile_trainer_types          # No dependencies
+    yield(_INTL("Compiling Trainer data"))
+    compile_trainers               # Depends on Species, Item, Move
+    yield(_INTL("Compiling battle Trainer data"))
+    compile_trainer_lists          # Depends on TrainerType
+    yield(_INTL("Compiling metadata"))
+    compile_metadata               # Depends on TrainerType
+    yield(_INTL("Compiling animations"))
+    compile_animations
+    yield(_INTL("Converting events"))
+    compile_trainer_events(mustCompile)
+    yield(_INTL("Saving messages"))
+    pbSetTextMessages
+    MessageTypes.saveMessages
+    MessageTypes.loadMessageFile("Data/messages.dat") if safeExists?("Data/messages.dat")
+    System.reload_cache
+    echoln ""
+    echoln _INTL("*** Finished full compile ***")
+    echoln ""
+    pbSetWindowText(nil)
+  end
+
+
+  def main
+    return if !$DEBUG
+    begin
+      dataFiles = [
+         "berry_plants.dat",
+         "encounters.dat",
+         "form2species.dat",
+         "items.dat",
+         "map_connections.dat",
+         "metadata.dat",
+         "moves.dat",
+         "phone.dat",
+         "regional_dexes.dat",
+         "ribbons.dat",
+         "shadow_movesets.dat",
+         "species.dat",
+         "species_eggmoves.dat",
+         "species_evolutions.dat",
+         "species_metrics.dat",
+         "species_movesets.dat",
+         "tm.dat",
+         "town_map.dat",
+         "trainer_lists.dat",
+         "trainer_types.dat",
+         "trainers.dat",
+         "types.dat"
+      ]
+      textFiles = [
+         "abilities.txt",
+         "berryplants.txt",
+         "connections.txt",
+         "encounters.txt",
+         "items.txt",
+         "metadata.txt",
+         "moves.txt",
+         "phone.txt",
+         "pokemon.txt",
+         "pokemonforms.txt",
+         "regionaldexes.txt",
+         "ribbons.txt",
+         "shadowmoves.txt",
+         "townmap.txt",
+         "trainerlists.txt",
+         "trainers.txt",
+         "trainertypes.txt",
+         "types.txt"
+      ]
+      latestDataTime = 0
+      latestTextTime = 0
+      mustCompile = false
+      # Should recompile if new maps were imported
+      mustCompile |= import_new_maps
+      # If no PBS file, create one and fill it, then recompile
+      if !safeIsDirectory?("PBS")
+        return
+        # Dir.mkdir("PBS") rescue nil
+        # write_all
+        # mustCompile = true
+      end
+      # Check data files and PBS files, and recompile if any PBS file was edited
+      # more recently than the data files were last created
+      dataFiles.each do |filename|
+        next if !safeExists?("Data/" + filename)
+        begin
+          File.open("Data/#{filename}") { |file|
+            latestDataTime = [latestDataTime, file.mtime.to_i].max
+          }
+        rescue SystemCallError
+          mustCompile = true
+        end
+      end
+      textFiles.each do |filename|
+        next if !safeExists?("PBS/" + filename)
+        begin
+          File.open("PBS/#{filename}") { |file|
+            latestTextTime = [latestTextTime, file.mtime.to_i].max
+          }
+        rescue SystemCallError
+        end
+      end
+      mustCompile |= (latestTextTime >= latestDataTime)
+      # Should recompile if holding Ctrl
+      Input.update
+      mustCompile = true if Input.press?(Input::CTRL)
+      # Delete old data files in preparation for recompiling
+      if mustCompile
+        for i in 0...dataFiles.length
+          begin
+            File.delete("Data/#{dataFiles[i]}") if safeExists?("Data/#{dataFiles[i]}")
+          rescue SystemCallError
+          end
+        end
+      end
+      # Recompile all data
+      compile_all(mustCompile) { |msg| pbSetWindowText(msg); echoln(msg) }
+    rescue Exception
+      e = $!
+      raise e if "#{e.class}"=="Reset" || e.is_a?(Reset) || e.is_a?(SystemExit)
+      pbPrintException(e)
+      for i in 0...dataFiles.length
+        begin
+          File.delete("Data/#{dataFiles[i]}")
+        rescue SystemCallError
+        end
+      end
+      raise Reset.new if e.is_a?(Hangup)
+      loop do
+        Graphics.update
+      end
+    end
+  end
+end

Data/Scripts/021_Compiler/003_Compiler_WritePBS.rb

@@ -0,0 +1,805 @@
+module Compiler
+  module_function
+
+  def add_PBS_header_to_file(file)
+    file.write(0xEF.chr)
+    file.write(0xBB.chr)
+    file.write(0xBF.chr)
+    file.write("\# " + _INTL("See the documentation on the wiki to learn how to edit this file.") + "\r\n")
+  end
+
+  #=============================================================================
+  # Save Town Map data to PBS file
+  #=============================================================================
+  def write_town_map
+    mapdata = pbLoadTownMapData
+    return if !mapdata
+    File.open("PBS/townmap.txt","wb") { |f|
+      add_PBS_header_to_file(f)
+      for i in 0...mapdata.length
+        map = mapdata[i]
+        next if !map
+        f.write("\#-------------------------------\r\n")
+        f.write(sprintf("[%d]\r\n",i))
+        rname = pbGetMessage(MessageTypes::RegionNames,i)
+        f.write(sprintf("Name = %s\r\nFilename = %s\r\n",
+          (rname && rname!="") ? rname : _INTL("Unnamed"),
+          csvQuote((map[1].is_a?(Array)) ? map[1][0] : map[1])))
+        for loc in map[2]
+          f.write("Point = ")
+          pbWriteCsvRecord(loc,f,[nil,"uussUUUU"])
+          f.write("\r\n")
+        end
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save map connections to PBS file
+  #=============================================================================
+  def normalize_connection(conn)
+    ret = conn.clone
+    if conn[1] < 0 && conn[4] < 0
+    elsif conn[1] < 0 || conn[4] < 0
+      ret[4] = -conn[1]
+      ret[1] = -conn[4]
+    end
+    if conn[2] < 0 && conn[5] < 0
+    elsif conn[2] < 0 || conn[5] < 0
+      ret[5] = -conn[2]
+      ret[2] = -conn[5]
+    end
+    return ret
+  end
+
+  def get_connection_text(map1, x1, y1, map2, x2, y2)
+    dims1 = MapFactoryHelper.getMapDims(map1)
+    dims2 = MapFactoryHelper.getMapDims(map2)
+    if x1 == 0 && x2 == dims2[0]
+      return sprintf("%d,West,%d,%d,East,%d", map1, y1, map2, y2)
+    elsif y1 == 0 && y2 == dims2[1]
+      return sprintf("%d,North,%d,%d,South,%d", map1, x1, map2, x2)
+    elsif x1 == dims1[0] && x2 == 0
+      return sprintf("%d,East,%d,%d,West,%d", map1, y1, map2, y2)
+    elsif y1 == dims1[1] && y2 == 0
+      return sprintf("%d,South,%d,%d,North,%d", map1, x1, map2, x2)
+    end
+    return sprintf("%d,%d,%d,%d,%d,%d", map1, x1, y1, map2, x2, y2)
+  end
+
+  def write_connections
+    conndata = load_data("Data/map_connections.dat")
+    return if !conndata
+    mapinfos = pbLoadMapInfos
+    File.open("PBS/connections.txt","wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      for conn in conndata
+        if mapinfos
+          # Skip if map no longer exists
+          next if !mapinfos[conn[0]] || !mapinfos[conn[3]]
+          f.write(sprintf("# %s (%d) - %s (%d)\r\n",
+          (mapinfos[conn[0]]) ? mapinfos[conn[0]].name : "???", conn[0],
+          (mapinfos[conn[3]]) ? mapinfos[conn[3]].name : "???", conn[3]))
+        end
+        if conn[1].is_a?(String) || conn[4].is_a?(String)
+          f.write(sprintf("%d,%s,%d,%d,%s,%d", conn[0], conn[1], conn[2],
+            conn[3], conn[4], conn[5]))
+        else
+          ret = normalize_connection(conn)
+          f.write(get_connection_text(ret[0], ret[1], ret[2], ret[3], ret[4], ret[5]))
+        end
+        f.write("\r\n")
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save phone messages to PBS file
+  #=============================================================================
+  def write_phone
+    data = load_data("Data/phone.dat") rescue nil
+    return if !data
+    File.open("PBS/phone.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      f.write("[<Generics>]\r\n")
+      f.write(data.generics.join("\r\n") + "\r\n")
+      f.write("\#-------------------------------\r\n")
+      f.write("[<BattleRequests>]\r\n")
+      f.write(data.battleRequests.join("\r\n") + "\r\n")
+      f.write("\#-------------------------------\r\n")
+      f.write("[<GreetingsMorning>]\r\n")
+      f.write(data.greetingsMorning.join("\r\n") + "\r\n")
+      f.write("\#-------------------------------\r\n")
+      f.write("[<GreetingsEvening>]\r\n")
+      f.write(data.greetingsEvening.join("\r\n") + "\r\n")
+      f.write("\#-------------------------------\r\n")
+      f.write("[<Greetings>]\r\n")
+      f.write(data.greetings.join("\r\n") + "\r\n")
+      f.write("\#-------------------------------\r\n")
+      f.write("[<Bodies1>]\r\n")
+      f.write(data.bodies1.join("\r\n") + "\r\n")
+      f.write("\#-------------------------------\r\n")
+      f.write("[<Bodies2>]\r\n")
+      f.write(data.bodies2.join("\r\n") + "\r\n")
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save type data to PBS file
+  #=============================================================================
+  def write_types
+    File.open("PBS/types.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      # Write each type in turn
+      GameData::Type.each do |type|
+        f.write("\#-------------------------------\r\n")
+        f.write("[#{type.id_number}]\r\n")
+        f.write("Name = #{type.real_name}\r\n")
+        f.write("InternalName = #{type.id}\r\n")
+        f.write("IsPseudoType = true\r\n") if type.pseudo_type
+        f.write("IsSpecialType = true\r\n") if type.special?
+        f.write("Weaknesses = #{type.weaknesses.join(",")}\r\n") if type.weaknesses.length > 0
+        f.write("Resistances = #{type.resistances.join(",")}\r\n") if type.resistances.length > 0
+        f.write("Immunities = #{type.immunities.join(",")}\r\n") if type.immunities.length > 0
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save ability data to PBS file
+  #=============================================================================
+  def write_abilities
+    File.open("PBS/abilities.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      GameData::Ability.each do |a|
+        f.write(sprintf("%d,%s,%s,%s\r\n",
+          a.id_number,
+          csvQuote(a.id.to_s),
+          csvQuote(a.real_name),
+          csvQuoteAlways(a.real_description)
+        ))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save move data to PBS file
+  #=============================================================================
+  def write_moves
+    File.open("PBS/moves.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      current_type = -1
+      GameData::Move.each do |m|
+        if current_type != m.type
+          current_type = m.type
+          f.write("\#-------------------------------\r\n")
+        end
+        f.write(sprintf("%d,%s,%s,%s,%d,%s,%s,%d,%d,%d,%s,%d,%s,%s\r\n",
+          m.id_number,
+          csvQuote(m.id.to_s),
+          csvQuote(m.real_name),
+          csvQuote(m.function_code),
+          m.base_damage,
+          m.type.to_s,
+          ["Physical", "Special", "Status"][m.category],
+          m.accuracy,
+          m.total_pp,
+          m.effect_chance,
+          m.target,
+          m.priority,
+          csvQuote(m.flags),
+          csvQuoteAlways(m.real_description)
+        ))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save item data to PBS file
+  #=============================================================================
+  def write_items
+    File.open("PBS/items.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      current_pocket = 0
+      GameData::Item.each do |i|
+        if current_pocket != i.pocket
+          current_pocket = i.pocket
+          f.write("\#-------------------------------\r\n")
+        end
+        move_name = (i.move) ? GameData::Move.get(i.move).id.to_s : ""
+        sprintf_text = "%d,%s,%s,%s,%d,%d,%s,%d,%d,%d\r\n"
+        sprintf_text = "%d,%s,%s,%s,%d,%d,%s,%d,%d,%d,%s\r\n" if move_name != ""
+        f.write(sprintf(sprintf_text,
+          i.id_number,
+          csvQuote(i.id.to_s),
+          csvQuote(i.real_name),
+          csvQuote(i.real_name_plural),
+          i.pocket,
+          i.price,
+          csvQuoteAlways(i.real_description),
+          i.field_use,
+          i.battle_use,
+          i.type,
+          csvQuote(move_name)
+        ))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save berry plant data to PBS file
+  #=============================================================================
+  def write_berry_plants
+    File.open("PBS/berryplants.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      GameData::BerryPlant.each do |bp|
+        f.write(sprintf("%s = %d,%d,%d,%d\r\n",
+          csvQuote(bp.id.to_s),
+          bp.hours_per_stage,
+          bp.drying_per_hour,
+          bp.minimum_yield,
+          bp.maximum_yield
+        ))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save Pokémon data to PBS file
+  #=============================================================================
+  def write_pokemon
+    File.open("PBS/pokemon.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      GameData::Species.each do |species|
+        next if species.form != 0
+        pbSetWindowText(_INTL("Writing species {1}...", species.id_number))
+        Graphics.update if species.id_number % 50 == 0
+        f.write("\#-------------------------------\r\n")
+        f.write(sprintf("[%d]\r\n", species.id_number))
+        f.write(sprintf("Name = %s\r\n", species.real_name))
+        f.write(sprintf("InternalName = %s\r\n", species.species))
+        f.write(sprintf("Type1 = %s\r\n", species.type1))
+        f.write(sprintf("Type2 = %s\r\n", species.type2)) if species.type2 != species.type1
+        stats_array = []
+        evs_array = []
+        GameData::Stat.each_main do |s|
+          next if s.pbs_order < 0
+          stats_array[s.pbs_order] = species.base_stats[s.id]
+          evs_array[s.pbs_order] = species.evs[s.id]
+        end
+        f.write(sprintf("BaseStats = %s\r\n", stats_array.join(",")))
+        f.write(sprintf("GenderRate = %s\r\n", species.gender_ratio))
+        f.write(sprintf("GrowthRate = %s\r\n", species.growth_rate))
+        f.write(sprintf("BaseEXP = %d\r\n", species.base_exp))
+        f.write(sprintf("EffortPoints = %s\r\n", evs_array.join(",")))
+        f.write(sprintf("Rareness = %d\r\n", species.catch_rate))
+        f.write(sprintf("Happiness = %d\r\n", species.happiness))
+        if species.abilities.length > 0
+          f.write(sprintf("Abilities = %s\r\n", species.abilities.join(",")))
+        end
+        if species.hidden_abilities.length > 0
+          f.write(sprintf("HiddenAbility = %s\r\n", species.hidden_abilities.join(",")))
+        end
+        if species.moves.length > 0
+          f.write(sprintf("Moves = %s\r\n", species.moves.join(",")))
+        end
+        if species.tutor_moves.length > 0
+          f.write(sprintf("TutorMoves = %s\r\n", species.tutor_moves.join(",")))
+        end
+        if species.egg_moves.length > 0
+          f.write(sprintf("EggMoves = %s\r\n", species.egg_moves.join(",")))
+        end
+        if species.egg_groups.length > 0
+          f.write(sprintf("Compatibility = %s\r\n", species.egg_groups.join(",")))
+        end
+        f.write(sprintf("StepsToHatch = %d\r\n", species.hatch_steps))
+        f.write(sprintf("Height = %.1f\r\n", species.height / 10.0))
+        f.write(sprintf("Weight = %.1f\r\n", species.weight / 10.0))
+        f.write(sprintf("Color = %s\r\n", species.color))
+        f.write(sprintf("Shape = %s\r\n", species.shape))
+        f.write(sprintf("Habitat = %s\r\n", species.habitat)) if species.habitat != :None
+        f.write(sprintf("Kind = %s\r\n", species.real_category))
+        f.write(sprintf("Pokedex = %s\r\n", species.real_pokedex_entry))
+        f.write(sprintf("FormName = %s\r\n", species.real_form_name)) if species.real_form_name && !species.real_form_name.empty?
+        f.write(sprintf("Generation = %d\r\n", species.generation)) if species.generation != 0
+        f.write(sprintf("WildItemCommon = %s\r\n", species.wild_item_common)) if species.wild_item_common
+        f.write(sprintf("WildItemUncommon = %s\r\n", species.wild_item_uncommon)) if species.wild_item_uncommon
+        f.write(sprintf("WildItemRare = %s\r\n", species.wild_item_rare)) if species.wild_item_rare
+        f.write(sprintf("BattlerPlayerX = %d\r\n", species.back_sprite_x))
+        f.write(sprintf("BattlerPlayerY = %d\r\n", species.back_sprite_y))
+        f.write(sprintf("BattlerEnemyX = %d\r\n", species.front_sprite_x))
+        f.write(sprintf("BattlerEnemyY = %d\r\n", species.front_sprite_y))
+        f.write(sprintf("BattlerAltitude = %d\r\n", species.front_sprite_altitude)) if species.front_sprite_altitude != 0
+        f.write(sprintf("BattlerShadowX = %d\r\n", species.shadow_x))
+        f.write(sprintf("BattlerShadowSize = %d\r\n", species.shadow_size))
+        if species.evolutions.any? { |evo| !evo[3] }
+          f.write("Evolutions = ")
+          need_comma = false
+          species.evolutions.each do |evo|
+            next if evo[3]   # Skip prevolution entries
+            f.write(",") if need_comma
+            need_comma = true
+            evo_type_data = GameData::Evolution.get(evo[1])
+            param_type = evo_type_data.parameter
+            f.write(sprintf("%s,%s,", evo[0], evo_type_data.id.to_s))
+            if !param_type.nil?
+              if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
+                f.write(getConstantName(param_type, evo[2]))
+              else
+                f.write(evo[2].to_s)
+              end
+            end
+          end
+          f.write("\r\n")
+        end
+        f.write(sprintf("Incense = %s\r\n", species.incense)) if species.incense
+      end
+    }
+    pbSetWindowText(nil)
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save Pokémon forms data to PBS file
+  #=============================================================================
+  def write_pokemon_forms
+    File.open("PBS/pokemonforms.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      GameData::Species.each do |species|
+        next if species.form == 0
+        base_species = GameData::Species.get(species.species)
+        pbSetWindowText(_INTL("Writing species {1}...", species.id_number))
+        Graphics.update if species.id_number % 50 == 0
+        f.write("\#-------------------------------\r\n")
+        f.write(sprintf("[%s,%d]\r\n", species.species, species.form))
+        f.write(sprintf("FormName = %s\r\n", species.real_form_name)) if species.real_form_name && !species.real_form_name.empty?
+        f.write(sprintf("PokedexForm = %d\r\n", species.pokedex_form)) if species.pokedex_form != species.form
+        f.write(sprintf("MegaStone = %s\r\n", species.mega_stone)) if species.mega_stone
+        f.write(sprintf("MegaMove = %s\r\n", species.mega_move)) if species.mega_move
+        f.write(sprintf("UnmegaForm = %d\r\n", species.unmega_form)) if species.unmega_form != 0
+        f.write(sprintf("MegaMessage = %d\r\n", species.mega_message)) if species.mega_message != 0
+        if species.type1 != base_species.type1 || species.type2 != base_species.type2
+          f.write(sprintf("Type1 = %s\r\n", species.type1))
+          f.write(sprintf("Type2 = %s\r\n", species.type2)) if species.type2 != species.type1
+        end
+        stats_array = []
+        evs_array = []
+        GameData::Stat.each_main do |s|
+          next if s.pbs_order < 0
+          stats_array[s.pbs_order] = species.base_stats[s.id]
+          evs_array[s.pbs_order] = species.evs[s.id]
+        end
+        f.write(sprintf("BaseStats = %s\r\n", stats_array.join(","))) if species.base_stats != base_species.base_stats
+        f.write(sprintf("BaseEXP = %d\r\n", species.base_exp)) if species.base_exp != base_species.base_exp
+        f.write(sprintf("EffortPoints = %s\r\n", evs_array.join(","))) if species.evs != base_species.evs
+        f.write(sprintf("Rareness = %d\r\n", species.catch_rate)) if species.catch_rate != base_species.catch_rate
+        f.write(sprintf("Happiness = %d\r\n", species.happiness)) if species.happiness != base_species.happiness
+        if species.abilities.length > 0 && species.abilities != base_species.abilities
+          f.write(sprintf("Abilities = %s\r\n", species.abilities.join(",")))
+        end
+        if species.hidden_abilities.length > 0 && species.hidden_abilities != base_species.hidden_abilities
+          f.write(sprintf("HiddenAbility = %s\r\n", species.hidden_abilities.join(",")))
+        end
+        if species.moves.length > 0 && species.moves != base_species.moves
+          f.write(sprintf("Moves = %s\r\n", species.moves.join(",")))
+        end
+        if species.tutor_moves.length > 0 && species.tutor_moves != base_species.tutor_moves
+          f.write(sprintf("TutorMoves = %s\r\n", species.tutor_moves.join(",")))
+        end
+        if species.egg_moves.length > 0 && species.egg_moves != base_species.egg_moves
+          f.write(sprintf("EggMoves = %s\r\n", species.egg_moves.join(",")))
+        end
+        if species.egg_groups.length > 0 && species.egg_groups != base_species.egg_groups
+          f.write(sprintf("Compatibility = %s\r\n", species.egg_groups.join(",")))
+        end
+        f.write(sprintf("StepsToHatch = %d\r\n", species.hatch_steps)) if species.hatch_steps != base_species.hatch_steps
+        f.write(sprintf("Height = %.1f\r\n", species.height / 10.0)) if species.height != base_species.height
+        f.write(sprintf("Weight = %.1f\r\n", species.weight / 10.0)) if species.weight != base_species.weight
+        f.write(sprintf("Color = %s\r\n", species.color)) if species.color != base_species.color
+        f.write(sprintf("Shape = %s\r\n", species.shape)) if species.shape != base_species.shape
+        if species.habitat != :None && species.habitat != base_species.habitat
+          f.write(sprintf("Habitat = %s\r\n", species.habitat))
+        end
+        f.write(sprintf("Kind = %s\r\n", species.real_category)) if species.real_category != base_species.real_category
+        f.write(sprintf("Pokedex = %s\r\n", species.real_pokedex_entry)) if species.real_pokedex_entry != base_species.real_pokedex_entry
+        f.write(sprintf("Generation = %d\r\n", species.generation)) if species.generation != base_species.generation
+        if species.wild_item_common != base_species.wild_item_common ||
+           species.wild_item_uncommon != base_species.wild_item_uncommon ||
+           species.wild_item_rare != base_species.wild_item_rare
+          f.write(sprintf("WildItemCommon = %s\r\n", species.wild_item_common)) if species.wild_item_common
+          f.write(sprintf("WildItemUncommon = %s\r\n", species.wild_item_uncommon)) if species.wild_item_uncommon
+          f.write(sprintf("WildItemRare = %s\r\n", species.wild_item_rare)) if species.wild_item_rare
+        end
+        f.write(sprintf("BattlerPlayerX = %d\r\n", species.back_sprite_x)) if species.back_sprite_x != base_species.back_sprite_x
+        f.write(sprintf("BattlerPlayerY = %d\r\n", species.back_sprite_y)) if species.back_sprite_y != base_species.back_sprite_y
+        f.write(sprintf("BattlerEnemyX = %d\r\n", species.front_sprite_x)) if species.front_sprite_x != base_species.front_sprite_x
+        f.write(sprintf("BattlerEnemyY = %d\r\n", species.front_sprite_y)) if species.front_sprite_y != base_species.front_sprite_y
+        f.write(sprintf("BattlerAltitude = %d\r\n", species.front_sprite_altitude)) if species.front_sprite_altitude != base_species.front_sprite_altitude
+        f.write(sprintf("BattlerShadowX = %d\r\n", species.shadow_x)) if species.shadow_x != base_species.shadow_x
+        f.write(sprintf("BattlerShadowSize = %d\r\n", species.shadow_size)) if species.shadow_size != base_species.shadow_size
+        if species.evolutions != base_species.evolutions && species.evolutions.any? { |evo| !evo[3] }
+          f.write("Evolutions = ")
+          need_comma = false
+          species.evolutions.each do |evo|
+            next if evo[3]   # Skip prevolution entries
+            f.write(",") if need_comma
+            need_comma = true
+            evo_type_data = GameData::Evolution.get(evo[1])
+            param_type = evo_type_data.parameter
+            f.write(sprintf("%s,%s,", evo[0], evo_type_data.id.to_s))
+            if !param_type.nil?
+              if !GameData.const_defined?(param_type.to_sym) && param_type.is_a?(Symbol)
+                f.write(getConstantName(param_type, evo[2]))
+              else
+                f.write(evo[2].to_s)
+              end
+            end
+          end
+          f.write("\r\n")
+        end
+      end
+    }
+    pbSetWindowText(nil)
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save Shadow movesets to PBS file
+  #=============================================================================
+  def write_shadow_movesets
+    shadow_movesets = pbLoadShadowMovesets
+    File.open("PBS/shadowmoves.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      GameData::Species.each do |species_data|
+        moveset = shadow_movesets[species_data.id]
+        next if !moveset || moveset.length == 0
+        f.write(sprintf("%s = %s\r\n", species_data.id, moveset.join(",")))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save Regional Dexes to PBS file
+  #=============================================================================
+  def write_regional_dexes
+    dex_lists = pbLoadRegionalDexes
+    File.open("PBS/regionaldexes.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      # Write each Dex list in turn
+      dex_lists.each_with_index do |list, index|
+        f.write("\#-------------------------------\r\n")
+        f.write("[#{index}]")
+        comma = false
+        current_family = nil
+        list.each do |species|
+          next if !species
+          if current_family && current_family.include?(species)
+            f.write(",") if comma
+          else
+            current_family = GameData::Species.get(species).get_related_species
+            comma = false
+            f.write("\r\n")
+          end
+          f.write(species)
+          comma = true
+        end
+        f.write("\r\n")
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save ability data to PBS file
+  #=============================================================================
+  def write_ribbons
+    File.open("PBS/ribbons.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      GameData::Ribbon.each do |r|
+        f.write(sprintf("%d,%s,%s,%s\r\n",
+          r.id_number,
+          csvQuote(r.id.to_s),
+          csvQuote(r.real_name),
+          csvQuoteAlways(r.real_description)
+        ))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save wild encounter data to PBS file
+  #=============================================================================
+  def write_encounters
+    map_infos = pbLoadMapInfos
+    File.open("PBS/encounters.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      GameData::Encounter.each do |encounter_data|
+        f.write("\#-------------------------------\r\n")
+        map_name = (map_infos[encounter_data.map]) ? " # #{map_infos[encounter_data.map].name}" : ""
+        if encounter_data.version > 0
+          f.write(sprintf("[%03d,%d]%s\r\n", encounter_data.map, encounter_data.version, map_name))
+        else
+          f.write(sprintf("[%03d]%s\r\n", encounter_data.map, map_name))
+        end
+        encounter_data.types.each do |type, slots|
+          next if !slots || slots.length == 0
+          if encounter_data.step_chances[type] && encounter_data.step_chances[type] > 0
+            f.write(sprintf("%s,%d\r\n", type.to_s, encounter_data.step_chances[type]))
+          else
+            f.write(sprintf("%s\r\n", type.to_s))
+          end
+          slots.each do |slot|
+            if slot[2] == slot[3]
+              f.write(sprintf("    %d,%s,%d\r\n", slot[0], slot[1], slot[2]))
+            else
+              f.write(sprintf("    %d,%s,%d,%d\r\n", slot[0], slot[1], slot[2], slot[3]))
+            end
+          end
+        end
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save trainer type data to PBS file
+  #=============================================================================
+  def write_trainer_types
+    File.open("PBS/trainertypes.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      GameData::TrainerType.each do |t|
+        f.write(sprintf("%d,%s,%s,%d,%s,%s,%s,%s,%s,%s\r\n",
+          t.id_number,
+          csvQuote(t.id.to_s),
+          csvQuote(t.real_name),
+          t.base_money,
+          csvQuote(t.battle_BGM),
+          csvQuote(t.victory_ME),
+          csvQuote(t.intro_ME),
+          ["Male", "Female", "Mixed"][t.gender],
+          (t.skill_level == t.base_money) ? "" : t.skill_level.to_s,
+          csvQuote(t.skill_code)
+        ))
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save individual trainer data to PBS file
+  #=============================================================================
+  def write_trainers
+    File.open("PBS/trainers.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      GameData::Trainer.each do |trainer|
+        pbSetWindowText(_INTL("Writing trainer {1}...", trainer.id_number))
+        Graphics.update if trainer.id_number % 50 == 0
+        f.write("\#-------------------------------\r\n")
+        if trainer.version > 0
+          f.write(sprintf("[%s,%s,%d]\r\n", trainer.trainer_type, trainer.real_name, trainer.version))
+        else
+          f.write(sprintf("[%s,%s]\r\n", trainer.trainer_type, trainer.real_name))
+        end
+        f.write(sprintf("Items = %s\r\n", trainer.items.join(","))) if trainer.items.length > 0
+        if trainer.real_lose_text && !trainer.real_lose_text.empty?
+          f.write(sprintf("LoseText = %s\r\n", csvQuoteAlways(trainer.real_lose_text)))
+        end
+        trainer.pokemon.each do |pkmn|
+          f.write(sprintf("Pokemon = %s,%d\r\n", pkmn[:species], pkmn[:level]))
+          f.write(sprintf("    Name = %s\r\n", pkmn[:name])) if pkmn[:name] && !pkmn[:name].empty?
+          f.write(sprintf("    Form = %d\r\n", pkmn[:form])) if pkmn[:form] && pkmn[:form] > 0
+          f.write(sprintf("    Gender = %s\r\n", (pkmn[:gender] == 1) ? "female" : "male")) if pkmn[:gender]
+          f.write("    Shiny = yes\r\n") if pkmn[:shininess]
+          f.write("    Shadow = yes\r\n") if pkmn[:shadowness]
+          f.write(sprintf("    Moves = %s\r\n", pkmn[:moves].join(","))) if pkmn[:moves] && pkmn[:moves].length > 0
+          f.write(sprintf("    Ability = %s\r\n", pkmn[:ability])) if pkmn[:ability]
+          f.write(sprintf("    AbilityIndex = %d\r\n", pkmn[:ability_index])) if pkmn[:ability_index]
+          f.write(sprintf("    Item = %s\r\n", pkmn[:item])) if pkmn[:item]
+          f.write(sprintf("    Nature = %s\r\n", pkmn[:nature])) if pkmn[:nature]
+          ivs_array = []
+          evs_array = []
+          GameData::Stat.each_main do |s|
+            next if s.pbs_order < 0
+            ivs_array[s.pbs_order] = pkmn[:iv][s.id] if pkmn[:iv]
+            evs_array[s.pbs_order] = pkmn[:ev][s.id] if pkmn[:ev]
+          end
+          f.write(sprintf("    IV = %s\r\n", ivs_array.join(","))) if pkmn[:iv]
+          f.write(sprintf("    EV = %s\r\n", evs_array.join(","))) if pkmn[:ev]
+          f.write(sprintf("    Happiness = %d\r\n", pkmn[:happiness])) if pkmn[:happiness]
+          f.write(sprintf("    Ball = %s\r\n", pkmn[:poke_ball])) if pkmn[:poke_ball]
+        end
+      end
+    }
+    pbSetWindowText(nil)
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save trainer list data to PBS file
+  #=============================================================================
+  def write_trainer_lists
+    trainerlists = load_data("Data/trainer_lists.dat") rescue nil
+    return if !trainerlists
+    File.open("PBS/trainerlists.txt","wb") { |f|
+      add_PBS_header_to_file(f)
+      for tr in trainerlists
+        f.write("\#-------------------------------\r\n")
+        f.write(((tr[5]) ? "[DefaultTrainerList]" : "[TrainerList]")+"\r\n")
+        f.write("Trainers = "+tr[3]+"\r\n")
+        f.write("Pokemon = "+tr[4]+"\r\n")
+        f.write("Challenges = "+tr[2].join(",")+"\r\n") if !tr[5]
+        write_battle_tower_trainers(tr[0],"PBS/"+tr[3])
+        write_battle_tower_pokemon(tr[1],"PBS/"+tr[4])
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save Battle Tower trainer data to PBS file
+  #=============================================================================
+  def write_battle_tower_trainers(bttrainers, filename)
+    return if !bttrainers || !filename
+    btTrainersRequiredTypes = {
+      "Type"          => [0, "e", nil],   # Specifies a trainer
+      "Name"          => [1, "s"],
+      "BeginSpeech"   => [2, "s"],
+      "EndSpeechWin"  => [3, "s"],
+      "EndSpeechLose" => [4, "s"],
+      "PokemonNos"    => [5, "*u"]
+    }
+    File.open(filename,"wb") { |f|
+      add_PBS_header_to_file(f)
+      for i in 0...bttrainers.length
+        next if !bttrainers[i]
+        f.write("\#-------------------------------\r\n")
+        f.write(sprintf("[%03d]\r\n",i))
+        for key in btTrainersRequiredTypes.keys
+          schema = btTrainersRequiredTypes[key]
+          record = bttrainers[i][schema[0]]
+          next if record==nil
+          f.write(sprintf("%s = ",key))
+          if key=="Type"
+            f.write(record.to_s)
+          elsif key=="PokemonNos"
+            f.write(record.join(","))   # pbWriteCsvRecord somehow won't work here
+          else
+            pbWriteCsvRecord(record,f,schema)
+          end
+          f.write(sprintf("\r\n"))
+        end
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save Battle Tower Pokémon data to PBS file
+  #=============================================================================
+  def write_battle_tower_pokemon(btpokemon,filename)
+    return if !btpokemon || !filename
+    species = {}
+    moves   = {}
+    items   = {}
+    natures = {}
+    evs = {
+      :HP              => "HP",
+      :ATTACK          => "ATK",
+      :DEFENSE         => "DEF",
+      :SPECIAL_ATTACK  => "SA",
+      :SPECIAL_DEFENSE => "SD",
+      :SPEED           => "SPD"
+    }
+    File.open(filename,"wb") { |f|
+      add_PBS_header_to_file(f)
+      f.write("\#-------------------------------\r\n")
+      for i in 0...btpokemon.length
+        Graphics.update if i % 500 == 0
+        pkmn = btpokemon[i]
+        c1 = (species[pkmn.species]) ? species[pkmn.species] : (species[pkmn.species] = GameData::Species.get(pkmn.species).species.to_s)
+        c2 = (items[pkmn.item]) ? items[pkmn.item] : (items[pkmn.item] = GameData::Item.get(pkmn.item).id.to_s)
+        c3 = (natures[pkmn.nature]) ? natures[pkmn.nature] : (natures[pkmn.nature] = GameData::Nature.get(pkmn.nature).id.to_s)
+        evlist = ""
+        pkmn.ev.each_with_index do |stat, i|
+          evlist += "," if i > 0
+          evlist += evs[stat]
+        end
+        c4 = c5 = c6 = c7 = ""
+        [pkmn.move1, pkmn.move2, pkmn.move3, pkmn.move4].each_with_index do |move, i|
+          next if !move
+          text = (moves[move]) ? moves[move] : (moves[move] = GameData::Move.get(move).id.to_s)
+          case i
+          when 0 then c4 = text
+          when 1 then c5 = text
+          when 2 then c6 = text
+          when 3 then c7 = text
+          end
+        end
+        f.write("#{c1};#{c2};#{c3};#{evlist};#{c4},#{c5},#{c6},#{c7}\r\n")
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save metadata data to PBS file
+  #=============================================================================
+  def write_metadata
+    File.open("PBS/metadata.txt", "wb") { |f|
+      add_PBS_header_to_file(f)
+      # Write global metadata
+      f.write("\#-------------------------------\r\n")
+      f.write("[000]\r\n")
+      metadata = GameData::Metadata.get
+      schema = GameData::Metadata::SCHEMA
+      keys = schema.keys.sort {|a, b| schema[a][0] <=> schema[b][0] }
+      for key in keys
+        record = metadata.property_from_string(key)
+        next if record.nil?
+        f.write(sprintf("%s = ", key))
+        pbWriteCsvRecord(record, f, schema[key])
+        f.write("\r\n")
+      end
+      # Write map metadata
+      map_infos = pbLoadMapInfos
+      schema = GameData::MapMetadata::SCHEMA
+      keys = schema.keys.sort {|a, b| schema[a][0] <=> schema[b][0] }
+      GameData::MapMetadata.each do |map_data|
+        f.write("\#-------------------------------\r\n")
+        f.write(sprintf("[%03d]\r\n", map_data.id))
+        if map_infos && map_infos[map_data.id]
+          f.write(sprintf("# %s\r\n", map_infos[map_data.id].name))
+        end
+        for key in keys
+          record = map_data.property_from_string(key)
+          next if record.nil?
+          f.write(sprintf("%s = ", key))
+          pbWriteCsvRecord(record, f, schema[key])
+          f.write("\r\n")
+        end
+      end
+    }
+    Graphics.update
+  end
+
+  #=============================================================================
+  # Save all data to PBS files
+  #=============================================================================
+  def write_all
+    write_town_map
+    write_connections
+    write_phone
+    write_types
+    write_abilities
+    write_moves
+    write_items
+    write_berry_plants
+    write_pokemon
+    write_pokemon_forms
+    write_shadow_movesets
+    write_regional_dexes
+    write_ribbons
+    write_encounters
+    write_trainer_types
+    write_trainers
+    write_trainer_lists
+    write_metadata
+  end
+end