mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-07 21:24:59 +00:00
Remove Scripts folder to convert to submodule
This commit is contained in:
chardub
@@ -1,852 +0,0 @@
|
||||
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
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,805 +0,0 @@
|
||||
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
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user