mirror of
https://github.com/infinitefusion/infinitefusion-e18.git
synced 2025-12-06 06:01:46 +00:00
1289 lines
36 KiB
Ruby
1289 lines
36 KiB
Ruby
#===============================================================================
|
|
# Exceptions and critical code
|
|
#===============================================================================
|
|
class Reset < Exception
|
|
end
|
|
|
|
|
|
|
|
def pbGetExceptionMessage(e,script="")
|
|
emessage = e.message
|
|
if e.is_a?(Hangup)
|
|
emessage = "The script is taking too long. The game will restart."
|
|
elsif e.is_a?(Errno::ENOENT)
|
|
filename = emessage.sub("No such file or directory - ", "")
|
|
emessage = "File #{filename} not found."
|
|
end
|
|
if emessage && !safeExists?("Game.rgssad") && !safeExists?("Game.rgss2a")
|
|
emessage = emessage.gsub(/uninitialized constant PBItems\:\:(\S+)/) {
|
|
"The item '#{$1}' is not valid. Please add the item\r\nto the list of items in the editor. See the wiki for more information." }
|
|
emessage = emessage.gsub(/undefined method `(\S+?)' for PBItems\:Module/) {
|
|
"The item '#{$1}' is not valid. Please add the item\r\nto the list of items in the editor. See the wiki for more information." }
|
|
emessage = emessage.gsub(/uninitialized constant PBTypes\:\:(\S+)/) {
|
|
"The type '#{$1}' is not valid. Please add the type\r\nto the PBS/types.txt file." }
|
|
emessage = emessage.gsub(/undefined method `(\S+?)' for PBTypes\:Module/) {
|
|
"The type '#{$1}' is not valid. Please add the type\r\nto the PBS/types.txt file." }
|
|
emessage = emessage.gsub(/uninitialized constant PBTrainers\:\:(\S+)$/) {
|
|
"The trainer type '#{$1}' is not valid. Please add the trainer\r\nto the list of trainer types in the Editor. See the wiki for\r\nmore information." }
|
|
emessage = emessage.gsub(/undefined method `(\S+?)' for PBTrainers\:Module/) {
|
|
"The trainer type '#{$1}' is not valid. Please add the trainer\r\nto the list of trainer types in the Editor. See the wiki for\r\nmore information." }
|
|
emessage = emessage.gsub(/uninitialized constant PBSpecies\:\:(\S+)$/) {
|
|
"The Pokemon species '#{$1}' is not valid. Please\r\nadd the species to the PBS/pokemon.txt file.\r\nSee the wiki for more information." }
|
|
emessage = emessage.gsub(/undefined method `(\S+?)' for PBSpecies\:Module/) {
|
|
"The Pokemon species '#{$1}' is not valid. Please\r\nadd the species to the PBS/pokemon.txt file.\r\nSee the wiki for more information." }
|
|
end
|
|
emessage.gsub!(/Section(\d+)/) { $RGSS_SCRIPTS[$1.to_i][1] }
|
|
return emessage
|
|
end
|
|
|
|
def pbPrintException(e)
|
|
premessage = "\r\n=================\r\n\r\n[#{Time.now.to_s}]\r\n"
|
|
emessage = ""
|
|
if $EVENTHANGUPMSG && $EVENTHANGUPMSG!=""
|
|
emessage = $EVENTHANGUPMSG # Message with map/event ID generated elsewhere
|
|
$EVENTHANGUPMSG = nil
|
|
else
|
|
emessage = pbGetExceptionMessage(e)
|
|
end
|
|
btrace = ""
|
|
if e.backtrace
|
|
maxlength = ($INTERNAL) ? 25 : 10
|
|
e.backtrace[0,maxlength].each { |i| btrace += "#{i}\r\n" }
|
|
end
|
|
btrace.gsub!(/Section(\d+)/) { $RGSS_SCRIPTS[$1.to_i][1] }
|
|
message = "[Pokémon Essentials version #{ESSENTIALS_VERSION}]\r\n"
|
|
message += "#{ERROR_TEXT}" # For third party scripts to add to
|
|
message += "Exception: #{e.class}\r\n"
|
|
message += "Message: #{emessage}\r\n"
|
|
message += "\r\nBacktrace:\r\n#{btrace}"
|
|
errorlog = "errorlog.txt"
|
|
if (Object.const_defined?(:RTP) rescue false)
|
|
errorlog = RTP.getSaveFileName("errorlog.txt")
|
|
end
|
|
File.open(errorlog,"ab") { |f| f.write(premessage); f.write(message) }
|
|
errorlogline = errorlog.sub(Dir.pwd+"\\","")
|
|
errorlogline = errorlogline.sub(Dir.pwd+"/","")
|
|
errorlogline = errorlogline.gsub("/","\\")
|
|
errorlogline = "\r\n"+errorlogline if errorlogline.length>20
|
|
print("#{message}\r\nThis exception was logged in #{errorlogline}.\r\nPress Ctrl+C to copy this message to the clipboard.")
|
|
end
|
|
|
|
def pbCriticalCode
|
|
ret = 0
|
|
begin
|
|
yield
|
|
ret = 1
|
|
rescue Exception
|
|
e = $!
|
|
if e.is_a?(Reset) || e.is_a?(SystemExit)
|
|
raise
|
|
else
|
|
pbPrintException(e)
|
|
if e.is_a?(Hangup)
|
|
ret = 2
|
|
raise Reset.new
|
|
end
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# File reading
|
|
#===============================================================================
|
|
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.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
|
|
|
|
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
|
|
end
|
|
|
|
|
|
|
|
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 pbEachFileSectionEx(f)
|
|
lineno = 1
|
|
havesection = false
|
|
sectionname = nil
|
|
lastsection = {}
|
|
f.each_line { |line|
|
|
if lineno==1 && line[0]==0xEF && line[1]==0xBB && line[2]==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%500==0
|
|
Win32API.SetWindowText(_INTL("Processing line {1}",lineno)) if lineno%50==0
|
|
}
|
|
yield lastsection,sectionname if havesection
|
|
end
|
|
|
|
def pbEachFileSection(f)
|
|
pbEachFileSectionEx(f) { |section,name|
|
|
yield section,name.to_i if block_given? && name[/^\d+$/]
|
|
}
|
|
end
|
|
|
|
def pbEachFileSection2(f)
|
|
pbEachFileSectionEx(f) { |section,name|
|
|
yield section,name if block_given? && name[/^\w+[-,\s]{1}\d+$/]
|
|
}
|
|
end
|
|
|
|
def pbEachSection(f)
|
|
lineno = 1
|
|
havesection = false
|
|
sectionname = nil
|
|
lastsection = []
|
|
f.each_line { |line|
|
|
if lineno==1 && line[0]==0xEF && line[1]==0xBB && line[2]==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
|
|
|
|
def pbEachCommentedLine(f)
|
|
lineno = 1
|
|
f.each_line { |line|
|
|
if lineno==1 && line[0]==0xEF && line[1]==0xBB && line[2]==0xBF
|
|
line = line[3,line.length-3]
|
|
end
|
|
yield line, lineno if !line[/^\#/] && !line[/^\s*$/]
|
|
lineno += 1
|
|
}
|
|
end
|
|
|
|
def pbCompilerEachCommentedLine(filename)
|
|
File.open(filename,"rb") { |f|
|
|
FileLineData.file = filename
|
|
lineno = 1
|
|
f.each_line { |line|
|
|
if lineno==1 && line[0]==0xEF && line[1]==0xBB && line[2]==0xBF
|
|
line = line[3,line.length-3]
|
|
end
|
|
if !line[/^\#/] && !line[/^\s*$/]
|
|
FileLineData.setLine(line,lineno)
|
|
yield line, lineno
|
|
end
|
|
lineno += 1
|
|
}
|
|
}
|
|
end
|
|
|
|
def pbEachPreppedLine(f)
|
|
lineno = 1
|
|
f.each_line { |line|
|
|
if lineno==1 && line[0]==0xEF && line[1]==0xBB && line[2]==0xBF
|
|
line = line[3,line.length-3]
|
|
end
|
|
line = prepline(line)
|
|
yield line, lineno if !line[/^\#/] && !line[/^\s*$/]
|
|
lineno += 1
|
|
}
|
|
end
|
|
|
|
def pbCompilerEachPreppedLine(filename)
|
|
File.open(filename,"rb") { |f|
|
|
FileLineData.file = filename
|
|
lineno = 1
|
|
f.each_line { |line|
|
|
if lineno==1 && line[0]==0xEF && line[1]==0xBB && line[2]==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
|
|
|
|
#===============================================================================
|
|
# Valid value checks
|
|
#===============================================================================
|
|
def pbCheckByte(x,valuename)
|
|
if x<0 || x>255
|
|
raise _INTL("The value \"{1}\" must be from 0 through 255 (00-FF in hex), got a value of {2}\r\n{3}",valuename,x,FileLineData.linereport)
|
|
end
|
|
end
|
|
|
|
def pbCheckSignedByte(x,valuename)
|
|
if x<-128 || x>127
|
|
raise _INTL("The value \"{1}\" must be from -128 through 127, got a value of {2}\r\n{3}",valuename,x,FileLineData.linereport)
|
|
end
|
|
end
|
|
|
|
def pbCheckWord(x,valuename)
|
|
if x<0 || x>65535
|
|
raise _INTL("The value \"{1}\" must be from 0 through 65535 (0000-FFFF in hex), got a value of {2}\r\n{3}",valuename,x,FileLineData.linereport)
|
|
end
|
|
end
|
|
|
|
def pbCheckSignedWord(x,valuename)
|
|
if x<-32768 || x>32767
|
|
raise _INTL("The value \"{1}\" must be from -32768 through 32767, got a value of {2}\r\n{3}",valuename,x,FileLineData.linereport)
|
|
end
|
|
end
|
|
|
|
#===============================================================================
|
|
# Csv parsing
|
|
#===============================================================================
|
|
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 csvQuote(str,always=false)
|
|
return "" if !str || 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
|
|
|
|
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
|
|
else
|
|
raise _INTL("Field {1} is not a Boolean value (true, false, 1, 0)\r\n{2}",field,FileLineData.linereport)
|
|
return false
|
|
end
|
|
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 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)
|
|
enumer = Object.const_get(enumer.to_sym)
|
|
begin
|
|
if 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 ret=="" || !(enumer.const_defined?(ret) rescue false)
|
|
return enumer.const_get(ret.to_sym)
|
|
elsif enumer.is_a?(Symbol) || enumer.is_a?(String)
|
|
enumer = Object.const_get(enumer.to_sym)
|
|
return nil if 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
|
|
|
|
#===============================================================================
|
|
# Csv record reading/writing
|
|
#===============================================================================
|
|
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 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 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 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 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 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 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 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((field=="") ? nil : field)
|
|
when "q" # Unformatted text
|
|
record.push(rec)
|
|
rec = ""
|
|
when "Q" # Optional unformatted text
|
|
if !rec || 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
|
|
record.push(csvEnumFieldOrInt!(rec,schema[2+i-start],"",FileLineData.linereport))
|
|
when "Y" # Optional enumerable or integer
|
|
field = csvfield!(rec)
|
|
if field==""
|
|
record.push(nil)
|
|
elsif field[/^\-?\d+$/]
|
|
record.push(field.to_i)
|
|
else
|
|
record.push(checkEnumFieldOrNil(rec,schema[2+i-start]))
|
|
end
|
|
end
|
|
end
|
|
break if repeat && rec==""
|
|
end while repeat
|
|
return (schema[1].length==1) ? record[0] : record
|
|
end
|
|
|
|
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]==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)
|
|
if enumer.to_s=="PBTrainers" && !mod.respond_to?("getCount")
|
|
file.write((getConstantName(mod,rec[i]) rescue pbGetTrainerConst(rec[i])))
|
|
else
|
|
file.write(getConstantName(mod,rec[i]))
|
|
end
|
|
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)
|
|
if enumer.to_s=="PBTrainers" && !mod.respond_to?("getCount")
|
|
file.write((getConstantNameOrValue(mod,rec[i]) rescue pbGetTrainerConst(rec[i])))
|
|
else
|
|
file.write(getConstantNameOrValue(mod,rec[i]))
|
|
end
|
|
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
|
|
|
|
#===============================================================================
|
|
# Encoding and decoding
|
|
#===============================================================================
|
|
def intSize(value)
|
|
return 1 if value<0x80
|
|
return 2 if value<0x4000
|
|
return 3 if value<0x200000
|
|
return 4 if value<0x10000000
|
|
return 5
|
|
end
|
|
|
|
def encodeInt(strm,value)
|
|
num = 0
|
|
loop do
|
|
if value<0x80
|
|
strm.fputb(value)
|
|
return num+1
|
|
end
|
|
strm.fputb(0x80|(value&0x7F))
|
|
value >>= 7
|
|
num += 1
|
|
end
|
|
end
|
|
|
|
def decodeInt(strm)
|
|
bits = 0
|
|
curbyte = 0
|
|
ret = 0
|
|
begin
|
|
curbyte = strm.fgetb
|
|
ret += (curbyte&0x7F)<<bits
|
|
bits += 7
|
|
end while ((curbyte&0x80)>0)&&bits<0x1d
|
|
return ret
|
|
end
|
|
|
|
def strSize(str)
|
|
return str.length+intSize(str.length)
|
|
end
|
|
|
|
def encodeString(strm,str)
|
|
encodeInt(strm,str.length)
|
|
strm.write(str)
|
|
end
|
|
|
|
def decodeString(strm)
|
|
len = decodeInt(strm)
|
|
return strm.read(len)
|
|
end
|
|
|
|
def strsplit(str,re)
|
|
ret = []
|
|
tstr = str
|
|
while re=~tstr
|
|
ret[ret.length] = $~.pre_match
|
|
tstr = $~.post_match
|
|
end
|
|
ret[ret.length] = tstr if ret.length
|
|
return ret
|
|
end
|
|
|
|
def canonicalize(c)
|
|
csplit = strsplit(c,/[\/\\]/)
|
|
pos = -1
|
|
ret = []
|
|
retstr = ""
|
|
for x in csplit
|
|
if x=="."
|
|
elsif x==".."
|
|
ret.delete_at(pos) if pos>=0
|
|
pos -= 1
|
|
else
|
|
ret.push(x)
|
|
pos += 1
|
|
end
|
|
end
|
|
for i in 0...ret.length
|
|
retstr += "/" if i>0
|
|
retstr += ret[i]
|
|
end
|
|
return retstr
|
|
end
|
|
|
|
def frozenArrayValue(arr)
|
|
typestring = ""
|
|
for i in 0...arr.length
|
|
if i>0
|
|
typestring += ((i%20)==0) ? ",\r\n" : ","
|
|
end
|
|
typestring += arr[i].to_s
|
|
end
|
|
return "["+typestring+"].freeze"
|
|
end
|
|
|
|
#===============================================================================
|
|
# Enum const manipulators and parsers
|
|
#===============================================================================
|
|
def pbGetConst(mod,item,err)
|
|
isDef = false
|
|
begin
|
|
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 getConstantName(mod,value)
|
|
for c in mod.constants
|
|
return c if mod.const_get(c.to_sym)==value
|
|
end
|
|
raise _INTL("Value {1} not defined by a constant in {2}",value,mod.name)
|
|
end
|
|
|
|
def getConstantNameOrValue(mod,value)
|
|
for c in mod.constants
|
|
return c if mod.const_get(c.to_sym)==value
|
|
end
|
|
return value.inspect
|
|
end
|
|
|
|
def setConstantName(mod,value,name)
|
|
for c in mod.constants
|
|
mod.send(:remove_const,c.to_sym) if mod.const_get(c.to_sym)==value
|
|
end
|
|
mod.const_set(name,value)
|
|
end
|
|
|
|
def removeConstantValue(mod,value)
|
|
for c in mod.constants
|
|
mod.send(:remove_const,c.to_sym) if mod.const_get(c.to_sym)==value
|
|
end
|
|
end
|
|
|
|
def parseItem(item)
|
|
clonitem = item.upcase
|
|
clonitem.sub!(/^\s*/,"")
|
|
clonitem.sub!(/\s*$/,"")
|
|
return pbGetConst(PBItems,clonitem,_INTL("Undefined item constant name: %s\r\nName must consist only of letters, numbers, and\r\nunderscores and can't begin with a number.\r\nMake sure the item is defined in\r\nPBS/items.txt.\r\n{1}",FileLineData.linereport))
|
|
end
|
|
|
|
def parseSpecies(item)
|
|
clonitem = item.upcase
|
|
clonitem.gsub!(/^[\s\n]*/,"")
|
|
clonitem.gsub!(/[\s\n]*$/,"")
|
|
clonitem = "NIDORANmA" if clonitem=="NIDORANMA"
|
|
clonitem = "NIDORANfE" if clonitem=="NIDORANFE"
|
|
return pbGetConst(PBSpecies,clonitem,_INTL("Undefined species constant name: [%s]\r\nName must consist only of letters, numbers, and\r\nunderscores and can't begin with a number.\r\nMake sure the name is defined in\r\nPBS/pokemon.txt.\r\n{1}",FileLineData.linereport))
|
|
end
|
|
|
|
def parseMove(item)
|
|
clonitem = item.upcase
|
|
clonitem.sub!(/^\s*/,"")
|
|
clonitem.sub!(/\s*$/,"")
|
|
return pbGetConst(PBMoves,clonitem,_INTL("Undefined move constant name: %s\r\nName must consist only of letters, numbers, and\r\nunderscores and can't begin with a number.\r\nMake sure the name is defined in\r\nPBS/moves.txt.\r\n{1}",FileLineData.linereport))
|
|
end
|
|
|
|
def parseNature(item)
|
|
clonitem = item.upcase
|
|
clonitem.sub!(/^\s*/,"")
|
|
clonitem.sub!(/\s*$/,"")
|
|
return pbGetConst(PBNatures,clonitem,_INTL("Undefined nature constant name: %s\r\nName must consist only of letters, numbers, and\r\nunderscores and can't begin with a number.\r\nMake sure the name is defined in\r\nthe script section PBNatures.\r\n{1}",FileLineData.linereport))
|
|
end
|
|
|
|
def parseTrainer(item)
|
|
clonitem = item.clone
|
|
clonitem.sub!(/^\s*/,"")
|
|
clonitem.sub!(/\s*$/,"")
|
|
return pbGetConst(PBTrainers,clonitem,_INTL("Undefined Trainer constant name: %s\r\nName must consist only of letters, numbers, and\r\nunderscores and can't begin with a number.\r\nIn addition, the name must be defined\r\nin trainertypes.txt.\r\n{1}",FileLineData.linereport))
|
|
end
|
|
|
|
#===============================================================================
|
|
# Scripted constants
|
|
#===============================================================================
|
|
def pbFindScript(a,name)
|
|
a.each { |i|
|
|
next if !i
|
|
return i if i[1]==name
|
|
}
|
|
return nil
|
|
end
|
|
|
|
def pbAddScript(script,sectionname)
|
|
begin
|
|
scripts = load_data("Data/Constants.rxdata")
|
|
scripts = [] if !scripts
|
|
rescue
|
|
scripts = []
|
|
end
|
|
s = pbFindScript(scripts,sectionname)
|
|
if false#s
|
|
s[2]+=Zlib::Deflate.deflate("#{script}\r\n")
|
|
else
|
|
scripts.push([rand(100000000),sectionname,Zlib::Deflate.deflate("#{script}\r\n")])
|
|
end
|
|
save_data(scripts,"Data/Constants.rxdata")
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Serial record
|
|
#===============================================================================
|
|
class SerialRecord < Array
|
|
def bytesize
|
|
return SerialRecord.bytesize(self)
|
|
end
|
|
|
|
def encode(strm)
|
|
return SerialRecord.encode(self,strm)
|
|
end
|
|
|
|
def self.bytesize(arr)
|
|
ret = 0
|
|
return 0 if !arr
|
|
for field in arr
|
|
if field==nil || field==true || field==false
|
|
ret += 1
|
|
elsif field.is_a?(String)
|
|
ret += strSize(field)+1
|
|
elsif field.is_a?(Numeric)
|
|
ret += intSize(field)+1
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
def self.encode(arr,strm)
|
|
return if !arr
|
|
for field in arr
|
|
if field==nil
|
|
strm.write("0")
|
|
elsif field==true
|
|
strm.write("T")
|
|
elsif field==false
|
|
strm.write("F")
|
|
elsif field.is_a?(String)
|
|
strm.write("\"")
|
|
encodeString(strm,field)
|
|
elsif field.is_a?(Numeric)
|
|
strm.write("i")
|
|
encodeInt(strm,field)
|
|
end
|
|
end
|
|
end
|
|
|
|
def self.decode(strm,offset,length)
|
|
ret = SerialRecord.new
|
|
strm.pos = offset
|
|
while strm.pos<offset+length
|
|
datatype = strm.read(1)
|
|
case datatype
|
|
when "0"; ret.push(nil)
|
|
when "T"; ret.push(true)
|
|
when "F"; ret.push(false)
|
|
when "\""; ret.push(decodeString(strm))
|
|
when "i"; ret.push(decodeInt(strm))
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
end
|
|
|
|
|
|
|
|
def readSerialRecords(filename)
|
|
ret = []
|
|
return ret if !pbRgssExists?(filename)
|
|
pbRgssOpen(filename,"rb") { |file|
|
|
numrec = file.fgetdw>>3
|
|
curpos = 0
|
|
for i in 0...numrec
|
|
file.pos = curpos
|
|
offset = file.fgetdw
|
|
length = file.fgetdw
|
|
record = SerialRecord.decode(file,offset,length)
|
|
ret.push(record)
|
|
curpos += 8
|
|
end
|
|
}
|
|
return ret
|
|
end
|
|
|
|
def writeSerialRecords(filename,records)
|
|
File.open(filename,"wb") { |file|
|
|
totalsize = records.length*8
|
|
for record in records
|
|
file.fputdw(totalsize)
|
|
bytesize = record.bytesize
|
|
file.fputdw(bytesize)
|
|
totalsize += bytesize
|
|
end
|
|
for record in records
|
|
record.encode(file)
|
|
end
|
|
}
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Data structures
|
|
#===============================================================================
|
|
class ByteArray
|
|
include Enumerable
|
|
|
|
def initialize(data=nil)
|
|
@a = (data) ? data.unpack("C*") : []
|
|
end
|
|
|
|
def [](i); return @a[i]; end
|
|
def []=(i,value); @a[i] = value; end
|
|
|
|
def length; @a.length; end
|
|
def size; @a.size; end
|
|
|
|
def fillNils(length,value)
|
|
for i in 0...length
|
|
@a[i] = value if !@a[i]
|
|
end
|
|
end
|
|
|
|
def each
|
|
@a.each { |i| yield i}
|
|
end
|
|
|
|
def self._load(str)
|
|
return self.new(str)
|
|
end
|
|
|
|
def _dump(depth=100)
|
|
return @a.pack("C*")
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class WordArray
|
|
include Enumerable
|
|
|
|
def initialize(data=nil)
|
|
@a = (data) ? data.unpack("v*") : []
|
|
end
|
|
|
|
def [](i); return @a[i]; end
|
|
def []=(i,value); @a[i] = value; end
|
|
|
|
def length; @a.length; end
|
|
def size; @a.size; end
|
|
|
|
def fillNils(length,value)
|
|
for i in 0...length
|
|
@a[i] = value if !@a[i]
|
|
end
|
|
end
|
|
|
|
def each
|
|
@a.each { |i| yield i}
|
|
end
|
|
|
|
def self._load(str)
|
|
return self.new(str)
|
|
end
|
|
|
|
def _dump(depth=100)
|
|
return @a.pack("v*")
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class SignedWordArray
|
|
include Enumerable
|
|
|
|
def initialize(data=nil)
|
|
@a = (data) ? data.unpack("v*") : []
|
|
end
|
|
|
|
def []=(i,value)
|
|
@a[i] = value
|
|
end
|
|
|
|
def [](i)
|
|
v = @a[i]
|
|
return 0 if !v
|
|
return (v<0x8000) ? v : -((~v)&0xFFFF)-1
|
|
end
|
|
|
|
def length; @a.length; end
|
|
def size; @a.size; end
|
|
|
|
def fillNils(length,value)
|
|
for i in 0...length
|
|
@a[i] = value if !@a[i]
|
|
end
|
|
end
|
|
|
|
def each
|
|
@a.each { |i| yield i}
|
|
end
|
|
|
|
def self._load(str)
|
|
return self.new(str)
|
|
end
|
|
|
|
def _dump(depth=100)
|
|
return @a.pack("v*")
|
|
end
|
|
end
|
|
|
|
|
|
|
|
#===============================================================================
|
|
# Compile all data
|
|
#===============================================================================
|
|
def pbCompileAllData(mustCompile)
|
|
FileLineData.clear
|
|
if mustCompile
|
|
if (!$INEDITOR || LANGUAGES.length<2) && pbRgssExists?("Data/messages.dat")
|
|
MessageTypes.loadMessageFile("Data/messages.dat")
|
|
end
|
|
# No dependencies
|
|
yield(_INTL("Compiling type data"))
|
|
pbCompileTypes
|
|
# No dependencies
|
|
yield(_INTL("Compiling town map data"))
|
|
pbCompileTownMap
|
|
# No dependencies
|
|
yield(_INTL("Compiling map connection data"))
|
|
pbCompileConnections
|
|
# No dependencies
|
|
yield(_INTL("Compiling ability data"))
|
|
pbCompileAbilities
|
|
# Depends on PBTypes
|
|
yield(_INTL("Compiling move data"))
|
|
pbCompileMoves
|
|
# Depends on PBMoves
|
|
yield(_INTL("Compiling item data"))
|
|
pbCompileItems
|
|
# Depends on PBItems
|
|
yield(_INTL("Compiling berry plant data"))
|
|
pbCompileBerryPlants
|
|
# Depends on PBMoves, PBItems, PBTypes, PBAbilities
|
|
yield(_INTL("Compiling Pokémon data"))
|
|
pbCompilePokemonData
|
|
# Depends on PBSpecies, PBMoves
|
|
yield(_INTL("Compiling Pokémon forms data"))
|
|
pbCompilePokemonForms
|
|
# Depends on PBSpecies, PBMoves
|
|
yield(_INTL("Compiling machine data"))
|
|
pbCompileMachines
|
|
# No dependencies
|
|
yield(_INTL("Compiling Trainer type data"))
|
|
pbCompileTrainerTypes
|
|
# Depends on PBSpecies, PBItems, PBMoves
|
|
yield(_INTL("Compiling Trainer data"))
|
|
pbCompileTrainers
|
|
# Depends on PBTrainers
|
|
yield(_INTL("Compiling phone data"))
|
|
pbCompilePhoneData
|
|
# Depends on PBTrainers
|
|
yield(_INTL("Compiling metadata"))
|
|
pbCompileMetadata
|
|
# Depends on PBTrainers
|
|
yield(_INTL("Compiling battle Trainer data"))
|
|
pbCompileTrainerLists
|
|
# Depends on PBSpecies
|
|
yield(_INTL("Compiling encounter data"))
|
|
pbCompileEncounters
|
|
# Depends on PBSpecies, PBMoves
|
|
yield(_INTL("Compiling shadow move data"))
|
|
pbCompileShadowMoves
|
|
yield(_INTL("Compiling messages"))
|
|
else
|
|
if (!$INEDITOR || LANGUAGES.length<2) && safeExists?("Data/messages.dat")
|
|
MessageTypes.loadMessageFile("Data/messages.dat")
|
|
end
|
|
end
|
|
pbCompileAnimations
|
|
pbCompileTrainerEvents(mustCompile)
|
|
pbSetTextMessages
|
|
MessageTypes.saveMessages
|
|
if !$INEDITOR && LANGUAGES.length>=2
|
|
pbLoadMessages("Data/"+LANGUAGES[$PokemonSystem.language][1])
|
|
end
|
|
end
|
|
|
|
def pbCompiler
|
|
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",
|
|
"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",
|
|
"Constants.rxdata"
|
|
]
|
|
textFiles = [
|
|
"abilities.txt",
|
|
"berryplants.txt",
|
|
"connections.txt",
|
|
"encounters.txt",
|
|
"items.txt",
|
|
"metadata.txt",
|
|
"moves.txt",
|
|
"phone.txt",
|
|
"pokemon.txt",
|
|
"pokemonforms.txt",
|
|
"shadowmoves.txt",
|
|
"tm.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 |= pbImportNewMaps
|
|
# Should recompile if no existing data is found
|
|
mustCompile |= !(PBSpecies.respond_to?("maxValue") rescue false)
|
|
# If no PBS file, create one and fill it, then recompile
|
|
if !safeIsDirectory?("PBS")
|
|
Dir.mkdir("PBS") rescue nil
|
|
pbSaveAllData
|
|
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
|
|
for i in 0...dataFiles.length
|
|
begin
|
|
File.open("Data/#{dataFiles[i]}") { |file|
|
|
latestDataTime = [latestDataTime,file.mtime.to_i].max
|
|
}
|
|
rescue SystemCallError
|
|
mustCompile = true
|
|
end
|
|
end
|
|
for i in 0...textFiles.length
|
|
begin
|
|
File.open("PBS/#{textFiles[i]}") { |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]}")
|
|
rescue SystemCallError
|
|
end
|
|
end
|
|
end
|
|
# Recompile all data
|
|
pbCompileAllData(mustCompile) { |msg| Win32API.SetWindowText(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 |