Initial commit

Data/Scripts/006_Events and files/002_EventHandlers.rb

@@ -0,0 +1,172 @@
+# Defines an event that procedures can subscribe to.
+class Event
+  def initialize
+    @callbacks = []
+  end
+
+  # Sets an event handler for this event and removes all other event handlers.
+  def set(method)
+    @callbacks.clear
+    @callbacks.push(method)
+  end
+
+  # Removes an event handler procedure from the event.
+  def -(method)
+    for i in 0...@callbacks.length
+      next if @callbacks[i]!=method
+      @callbacks.delete_at(i)
+      break
+    end
+    return self
+  end
+
+  # Adds an event handler procedure from the event.
+  def +(method)
+    for i in 0...@callbacks.length
+      return self if @callbacks[i]==method
+    end
+    @callbacks.push(method)
+    return self
+  end
+
+  # Clears the event of event handlers.
+  def clear
+    @callbacks.clear
+  end
+
+  # Triggers the event and calls all its event handlers.  Normally called only
+  # by the code where the event occurred.
+  # The first argument is the sender of the event, the second argument contains
+  # the event's parameters. If three or more arguments are given, this method
+  # supports the following callbacks:
+  # proc{ |sender,params| } where params is an array of the other parameters, and
+  # proc{ |sender,arg0,arg1,...| }
+  def trigger(*arg)
+    arglist = arg[1,arg.length]
+    for callback in @callbacks
+      if callback.arity>2 && arg.length==callback.arity
+        # Retrofitted for callbacks that take three or more arguments
+        callback.call(*arg)
+      else
+        callback.call(arg[0],arglist)
+      end
+    end
+  end
+ 
+  # Triggers the event and calls all its event handlers. Normally called only
+  # by the code where the event occurred. The first argument is the sender of
+  # the event, the other arguments are the event's parameters.
+  def trigger2(*arg)
+    for callback in @callbacks
+      callback.call(*arg)
+    end
+  end
+end
+
+
+
+class HandlerHash
+  def initialize(mod)
+    @mod         = mod
+    @hash        = {}
+    @addIfs      = []
+    @symbolCache = {}
+  end
+
+  def fromSymbol(sym)
+    return sym unless sym.is_a?(Symbol) || sym.is_a?(String)
+    mod = Object.const_get(@mod) rescue nil
+    return nil if !mod
+    return mod.const_get(sym.to_sym) rescue nil
+  end
+
+  def toSymbol(sym)
+    return sym.to_sym if sym.is_a?(Symbol) || sym.is_a?(String)
+    ret = @symbolCache[sym]
+    return ret if ret
+    mod = Object.const_get(@mod) rescue nil
+    return nil if !mod
+    for key in mod.constants
+      next if mod.const_get(key)!=sym
+      ret = key.to_sym
+      @symbolCache[sym] = ret
+      break
+    end
+    return ret
+  end
+
+  def addIf(condProc,handler)
+    @addIfs.push([condProc,handler])
+  end
+
+  def add(sym,handler)   # 'sym' can be an ID or symbol
+    id = fromSymbol(sym)
+    @hash[id] = handler if id
+    symbol = toSymbol(sym)
+    @hash[symbol] = handler if symbol
+  end
+
+  def copy(src,*dests)
+    handler = self[src]
+    if handler
+      for dest in dests
+        self.add(dest,handler)
+      end
+    end
+  end
+
+  def [](sym)   # 'sym' can be an ID or symbol
+    id = fromSymbol(sym)
+    ret = nil
+    ret = @hash[id] if id && @hash[id]   # Real ID from the item
+    symbol = toSymbol(sym)
+    ret = @hash[symbol] if symbol && @hash[symbol]   # Symbol or string
+    unless ret
+      for addif in @addIfs
+        return addif[1] if addif[0].call(id)
+      end
+    end
+    return ret
+  end
+
+  def trigger(sym,*args)
+    handler = self[sym]
+    return (handler) ? handler.call(fromSymbol(sym),*args) : nil
+  end
+
+  def clear
+    @hash.clear
+  end
+end
+
+
+
+class SpeciesHandlerHash < HandlerHash
+  def initialize
+    super(:PBSpecies)
+  end
+end
+
+
+
+class AbilityHandlerHash < HandlerHash
+  def initialize
+    super(:PBAbilities)
+  end
+end
+
+
+
+class ItemHandlerHash < HandlerHash
+  def initialize
+    super(:PBItems)
+  end
+end
+
+
+
+class MoveHandlerHash < HandlerHash
+  def initialize
+    super(:PBMoves)
+  end
+end

Data/Scripts/006_Events and files/003_File_Mixins.rb

@@ -0,0 +1,163 @@
+module FileInputMixin
+  def fgetb
+    x=0
+    ret=0
+    each_byte do |i|
+      ret=i || 0
+      break
+    end
+    return ret
+  end
+
+  def fgetw
+    x=0
+    ret=0
+    each_byte do |i|
+      break if !i
+      ret|=(i<<x)
+      x+=8
+      break if x==16
+    end
+    return ret
+  end
+
+  def fgetdw
+    x=0
+    ret=0
+    each_byte do |i|
+      break if !i
+      ret|=(i<<x)
+      x+=8
+      break if x==32
+    end
+    return ret
+  end
+
+  def fgetsb
+    ret=fgetb
+    if (ret&0x80)!=0
+      return ret-256
+    else
+      return ret
+    end
+  end
+
+  def xfgetb(offset)
+    self.pos=offset
+    return fgetb
+  end
+
+  def xfgetw(offset)
+    self.pos=offset
+    return fgetw
+  end
+
+  def xfgetdw(offset)
+    self.pos=offset
+    return fgetdw
+  end
+
+  def getOffset(index)
+    self.binmode
+    self.pos=0
+    offset=fgetdw>>3
+    return 0 if index>=offset
+    self.pos=index*8
+    return fgetdw
+  end
+
+  def getLength(index)
+    self.binmode
+    self.pos=0
+    offset=fgetdw>>3
+    return 0 if index>=offset
+    self.pos=index*8+4
+    return fgetdw
+  end
+
+  def readName(index)
+    self.binmode
+    self.pos=0
+    offset=fgetdw>>3
+    return "" if index>=offset
+    self.pos=index<<3
+    offset=fgetdw
+    length=fgetdw
+    return "" if length==0
+    self.pos=offset
+    return read(length)
+  end
+end
+
+
+
+module FileOutputMixin
+  def fputb(b)
+    b=b&0xFF
+    write(b.chr)
+  end
+
+  def fputw(w)
+    2.times do
+      b=w&0xFF
+      write(b.chr)
+      w>>=8
+    end
+  end
+
+  def fputdw(w)
+    4.times do
+      b=w&0xFF
+      write(b.chr)
+      w>>=8
+    end
+  end
+end
+
+
+
+class File < IO
+=begin
+  unless defined?(debugopen)
+    class << self
+      alias debugopen open
+    end
+  end
+
+  def open(f,m="r")
+    debugopen("debug.txt","ab") { |file| file.write([f,m,Time.now.to_f].inspect+"\r\n") }
+    if block_given?
+      debugopen(f,m) { |file| yield file }
+    else
+      return debugopen(f,m)
+    end
+  end
+=end
+  include FileInputMixin
+  include FileOutputMixin
+end
+
+
+
+class StringInput
+  include FileInputMixin
+
+  def pos=(value)
+    seek(value)
+  end
+
+  def each_byte
+    while !eof?
+      yield getc
+    end
+  end
+
+  def binmode
+  end
+end
+
+
+
+class StringOutput
+  include FileOutputMixin
+end

Data/Scripts/006_Events and files/004_Intl_Messages.rb

@@ -0,0 +1,776 @@
+def pbAddScriptTexts(items,script)
+  script.scan(/(?:_I)\s*\(\s*\"((?:[^\\\"]*\\\"?)*[^\"]*)\"/) { |s|
+    string=s[0]
+    string.gsub!(/\\\"/,"\"")
+    string.gsub!(/\\\\/,"\\")
+    items.push(string)
+  }
+end
+
+def pbAddRgssScriptTexts(items,script)
+  script.scan(/(?:_INTL|_ISPRINTF)\s*\(\s*\"((?:[^\\\"]*\\\"?)*[^\"]*)\"/) { |s|
+    string=s[0]
+    string.gsub!(/\\r/,"\r")
+    string.gsub!(/\\n/,"\n")
+    string.gsub!(/\\1/,"\1")
+    string.gsub!(/\\\"/,"\"")
+    string.gsub!(/\\\\/,"\\")
+    items.push(string)
+  }
+end
+
+def pbSetTextMessages
+  Graphics.update
+  begin
+    t = Time.now.to_i
+    texts=[]
+    for script in $RGSS_SCRIPTS
+      if Time.now.to_i - t >= 5
+        t = Time.now.to_i
+        Graphics.update
+      end
+      scr=Zlib::Inflate.inflate(script[2])
+      pbAddRgssScriptTexts(texts,scr)
+    end
+    # Must add messages because this code is used by both game system and Editor
+    MessageTypes.addMessagesAsHash(MessageTypes::ScriptTexts,texts)
+    commonevents=pbLoadRxData("Data/CommonEvents")
+    items=[]
+    choices=[]
+    for event in commonevents.compact
+      if Time.now.to_i - t >= 5
+        t = Time.now.to_i
+        Graphics.update
+      end
+      begin
+        neednewline=false
+        lastitem=""
+        for j in 0...event.list.size
+          list = event.list[j]
+          if neednewline && list.code!=401
+            if lastitem!=""
+              lastitem.gsub!(/([^\.\!\?])\s\s+/) { |m| $1+" " }
+              items.push(lastitem)
+              lastitem=""
+            end         
+            neednewline=false
+          end
+          if list.code == 101
+            lastitem+="#{list.parameters[0]}" if !$RPGVX
+            neednewline=true
+          elsif list.code == 102
+            for k in 0...list.parameters[0].length
+              choices.push(list.parameters[0][k])
+            end
+            neednewline=false
+          elsif list.code == 401
+            lastitem+=" " if lastitem!=""
+            lastitem+="#{list.parameters[0]}"
+            neednewline=true
+          elsif list.code == 355 || list.code == 655
+            pbAddScriptTexts(items,list.parameters[0])
+          elsif list.code == 111 && list.parameters[0]==12
+            pbAddScriptTexts(items,list.parameters[1])
+          elsif list.code == 209
+            route=list.parameters[1]
+            for k in 0...route.list.size
+              if route.list[k].code == 45
+                pbAddScriptTexts(items,route.list[k].parameters[0])
+              end
+            end
+          end
+        end
+        if neednewline
+          if lastitem!=""
+            items.push(lastitem)
+            lastitem=""
+          end         
+        end
+      end
+    end
+    if Time.now.to_i - t >= 5
+      t = Time.now.to_i
+      Graphics.update
+    end
+    items|=[]
+    choices|=[]
+    items.concat(choices)
+    MessageTypes.setMapMessagesAsHash(0,items)
+    mapinfos = pbLoadRxData("Data/MapInfos")
+    mapnames=[]
+    for id in mapinfos.keys
+      mapnames[id]=mapinfos[id].name
+    end
+    MessageTypes.setMessages(MessageTypes::MapNames,mapnames)
+    for id in mapinfos.keys
+      if Time.now.to_i - t >= 5
+        t = Time.now.to_i
+        Graphics.update
+      end
+      filename=sprintf("Data/Map%03d.%s",id,$RPGVX ? "rvdata" : "rxdata")
+      next if !pbRgssExists?(filename)
+      map = load_data(filename)
+      items=[]
+      choices=[]
+      for event in map.events.values
+        if Time.now.to_i - t >= 5
+          t = Time.now.to_i
+          Graphics.update
+        end
+        begin
+          for i in 0...event.pages.size
+            neednewline=false
+            lastitem=""
+            for j in 0...event.pages[i].list.size
+              list = event.pages[i].list[j]
+              if neednewline && list.code!=401
+                if lastitem!=""
+                  lastitem.gsub!(/([^\.\!\?])\s\s+/) { |m| $1+" " }
+                  items.push(lastitem)
+                  lastitem=""
+                end         
+                neednewline=false
+              end
+              if list.code == 101
+                lastitem+="#{list.parameters[0]}" if !$RPGVX
+                neednewline=true
+              elsif list.code == 102
+                for k in 0...list.parameters[0].length
+                  choices.push(list.parameters[0][k])
+                end
+                neednewline=false
+              elsif list.code == 401
+                lastitem+=" " if lastitem!=""
+                lastitem+="#{list.parameters[0]}"
+                neednewline=true
+              elsif list.code == 355 || list.code==655
+                pbAddScriptTexts(items,list.parameters[0])
+              elsif list.code == 111 && list.parameters[0]==12
+                pbAddScriptTexts(items,list.parameters[1])
+              elsif list.code==209
+                route=list.parameters[1]
+                for k in 0...route.list.size
+                  if route.list[k].code==45
+                    pbAddScriptTexts(items,route.list[k].parameters[0])
+                  end
+                end
+              end
+            end
+            if neednewline
+              if lastitem!=""
+                items.push(lastitem)
+                lastitem=""
+              end         
+            end
+          end
+        end
+      end
+      if Time.now.to_i - t >= 5
+        t = Time.now.to_i
+        Graphics.update
+      end
+      items|=[]
+      choices|=[]
+      items.concat(choices)
+      MessageTypes.setMapMessagesAsHash(id,items)
+      if Time.now.to_i - t >= 5
+        t = Time.now.to_i
+        Graphics.update
+      end
+    end
+  rescue Hangup
+  end
+  Graphics.update
+end
+
+def pbEachIntlSection(file)
+  lineno=1
+  re=/^\s*\[\s*([^\]]+)\s*\]\s*$/
+  havesection=false
+  sectionname=nil
+  lastsection=[]
+  file.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[re]
+        if havesection
+          yield lastsection,sectionname 
+        end
+        lastsection.clear
+        sectionname=$~[1]
+        havesection=true
+      else
+        if sectionname==nil
+          raise _INTL("Expected a section at the beginning of the file (line {1})",lineno)
+        end
+        lastsection.push(line.gsub(/\s+$/,""))
+      end
+    end
+    lineno+=1
+    if lineno%500==0
+      Graphics.update
+    end
+  }
+  if havesection
+    yield lastsection,sectionname 
+  end
+end
+
+def pbGetText(infile)
+  begin
+    file=File.open(infile,"rb") 
+  rescue
+    raise _INTL("Can't find {1}",infile)
+  end
+  intldat=[]
+  begin
+    pbEachIntlSection(file) { |section,name|
+      next if section.length==0
+      index=name
+      if !name[/^([Mm][Aa][Pp])?(\d+)$/]
+        raise _INTL("Invalid section name {1}",name)
+      end
+      ismap=$~[1] && $~[1]!=""
+      id=$~[2].to_i
+      itemlength=0
+      if section[0][/^\d+$/]
+        intlhash=[]
+        itemlength=3
+        if ismap
+          raise _INTL("Section {1} can't be an ordered list (section was recognized as an ordered list because its first line is a number)",name)
+        end
+        if section.length%3!=0
+          raise _INTL("Section {1}'s line count is not divisible by 3 (section was recognized as an ordered list because its first line is a number)",name)
+        end
+      else
+        intlhash=OrderedHash.new
+        itemlength=2
+        if section.length%2!=0
+          raise _INTL("Section {1} has an odd number of entries (section was recognized as a hash because its first line is not a number)",name)
+        end
+      end
+      i=0;loop do break unless i<section.length
+        if itemlength==3
+          if !section[i][/^\d+$/]
+            raise _INTL("Expected a number in section {1}, got {2} instead",name,section[i])
+          end
+          key=section[i].to_i
+          i+=1
+        else
+          key=MessageTypes.denormalizeValue(section[i])
+        end
+        intlhash[key]=MessageTypes.denormalizeValue(section[i+1])
+        i+=2
+      end
+      if ismap
+        intldat[0]=[] if !intldat[0]
+        intldat[0][id]=intlhash
+      else
+        intldat[id]=intlhash
+      end
+    }
+  ensure
+    file.close
+  end
+  return intldat
+end
+
+def pbCompileText
+  outfile=File.open("intl.dat","wb")
+  begin
+    intldat=pbGetText("intl.txt")
+    Marshal.dump(intldat,outfile)
+  rescue
+    raise
+  ensure
+    outfile.close
+  end
+end
+
+
+
+class OrderedHash < Hash
+  def initialize
+    @keys=[]
+    super
+  end
+
+  def keys
+    return @keys.clone
+  end
+
+  def inspect
+    str="{"
+    for i in 0...@keys.length
+      str+=", " if i>0
+      str+=@keys[i].inspect+"=>"+self[@keys[i]].inspect
+    end
+    str+="}"
+    return str
+  end
+
+  alias :to_s :inspect
+
+  def []=(key,value)
+    oldvalue=self[key]
+    if !oldvalue && value
+      @keys.push(key)
+    elsif !value
+      @keys|=[]
+      @keys-=[key]
+    end
+    return super(key,value)
+  end
+
+  def self._load(string)
+    ret=self.new
+    keysvalues=Marshal.load(string)
+    keys=keysvalues[0]
+    values=keysvalues[1]
+    for i in 0...keys.length
+      ret[keys[i]]=values[i]
+    end
+    return ret
+  end
+
+  def _dump(depth=100)
+    values=[]
+    for key in @keys
+      values.push(self[key])
+    end
+    return Marshal.dump([@keys,values])
+  end
+end
+
+
+
+class Messages
+  def initialize(filename=nil,delayLoad=false)
+    @messages=nil
+    @filename=filename
+    if @filename && !delayLoad
+      loadMessageFile(@filename)
+    end
+  end
+
+  def delayedLoad
+    if @filename && !@messages
+      loadMessageFile(@filename)
+      @filename=nil
+    end
+  end
+
+  def self.stringToKey(str)
+    if str && str[/[\r\n\t\1]|^\s+|\s+$|\s{2,}/]
+       key=str.clone
+       key.gsub!(/^\s+/,"")
+       key.gsub!(/\s+$/,"")
+       key.gsub!(/\s{2,}/," ")
+       return key
+    end
+    return str
+  end
+
+  def self.normalizeValue(value)
+    if value[/[\r\n\t\x01]|^[\[\]]/]
+      ret=value.clone
+      ret.gsub!(/\r/,"<<r>>")
+      ret.gsub!(/\n/,"<<n>>")
+      ret.gsub!(/\t/,"<<t>>")
+      ret.gsub!(/\[/,"<<[>>")
+      ret.gsub!(/\]/,"<<]>>")
+      ret.gsub!(/\x01/,"<<1>>")
+      return ret
+    end
+    return value
+  end
+
+  def self.denormalizeValue(value)
+    if value[/<<[rnt1\[\]]>>/]
+      ret=value.clone
+      ret.gsub!(/<<1>>/,"\1")
+      ret.gsub!(/<<r>>/,"\r")
+      ret.gsub!(/<<n>>/,"\n")
+      ret.gsub!(/<<\[>>/,"[")
+      ret.gsub!(/<<\]>>/,"]")
+      ret.gsub!(/<<t>>/,"\t")
+      return ret
+    end
+    return value
+  end
+
+  def self.writeObject(f,msgs,secname,origMessages=nil)
+    return if !msgs
+    if msgs.is_a?(Array)
+      f.write("[#{secname}]\r\n")
+      for j in 0...msgs.length
+        next if msgs[j]==nil || msgs[j]==""
+        value=Messages.normalizeValue(msgs[j])
+        origValue=""
+        if origMessages
+          origValue=Messages.normalizeValue(origMessages.get(secname,j))
+        else
+          origValue=Messages.normalizeValue(MessageTypes.get(secname,j))
+        end
+        f.write("#{j}\r\n")
+        f.write(origValue+"\r\n")
+        f.write(value+"\r\n")
+      end
+    elsif msgs.is_a?(OrderedHash)
+      f.write("[#{secname}]\r\n")
+      keys=msgs.keys
+      for key in keys
+        next if msgs[key]==nil || msgs[key]==""
+        value=Messages.normalizeValue(msgs[key])
+        valkey=Messages.normalizeValue(key)
+        # key is already serialized
+        f.write(valkey+"\r\n")
+        f.write(value+"\r\n")
+      end
+    end
+  end
+
+  def messages
+    return @messages || []
+  end
+
+  def extract(outfile)
+#    return if !@messages
+    origMessages=Messages.new("Data/messages.dat")
+    File.open(outfile,"wb") { |f|
+      f.write(0xef.chr)
+      f.write(0xbb.chr)
+      f.write(0xbf.chr)
+      f.write("# To localize this text for a particular language, please\r\n")
+      f.write("# translate every second line of this file.\r\n")
+      if origMessages.messages[0]
+        for i in 0...origMessages.messages[0].length
+          msgs=origMessages.messages[0][i]
+          Messages.writeObject(f,msgs,"Map#{i}",origMessages)
+        end
+      end
+      for i in 1...origMessages.messages.length
+        msgs=origMessages.messages[i]
+        Messages.writeObject(f,msgs,i,origMessages)
+      end
+    }
+  end
+
+  def setMessages(type,array)
+    @messages=[] if !@messages
+    arr=[]
+    for i in 0...array.length
+      arr[i]=(array[i]) ? array[i] : ""
+    end
+    @messages[type]=arr
+  end
+
+  def addMessages(type,array)
+    @messages=[] if !@messages
+    arr=(@messages[type]) ? @messages[type] : []
+    for i in 0...array.length
+      arr[i]=(array[i]) ? array[i] : (arr[i]) ? arr[i] : ""
+    end
+    @messages[type]=arr
+  end
+
+  def self.createHash(type,array)
+    arr=OrderedHash.new
+    for i in 0...array.length
+      if array[i]
+        key=Messages.stringToKey(array[i])
+        arr[key]=array[i]
+      end
+    end
+    return arr
+  end
+
+  def self.addToHash(type,array,hash)
+    if !hash
+      hash=OrderedHash.new
+    end
+    for i in 0...array.length
+      if array[i]
+        key=Messages.stringToKey(array[i])
+        hash[key]=array[i]
+      end
+    end
+    return hash
+  end
+
+  def setMapMessagesAsHash(type,array)
+    @messages=[] if !@messages
+    @messages[0]=[] if !@messages[0]
+    @messages[0][type]=Messages.createHash(type,array)
+  end
+
+  def addMapMessagesAsHash(type,array)
+    @messages=[] if !@messages
+    @messages[0]=[] if !@messages[0]
+    @messages[0][type]=Messages.addToHash(type,array,@messages[0][type])
+  end
+
+  def setMessagesAsHash(type,array)
+    @messages=[] if !@messages
+    @messages[type]=Messages.createHash(type,array)
+  end
+
+  def addMessagesAsHash(type,array)
+    @messages=[] if !@messages
+    @messages[type]=Messages.addToHash(type,array,@messages[type])
+  end
+
+  def saveMessages(filename=nil)
+    filename="Data/messages.dat" if !filename
+    File.open(filename,"wb") { |f| Marshal.dump(@messages,f) }
+  end
+
+  def loadMessageFile(filename)
+    begin
+      pbRgssOpen(filename,"rb") { |f| @messages=Marshal.load(f) }
+      if !@messages.is_a?(Array)
+        @messages=nil
+        raise "Corrupted data"
+      end
+      return @messages
+    rescue
+      @messages=nil
+      return nil
+    end
+  end
+
+  def set(type,id,value)
+    delayedLoad
+    return if !@messages
+    return if !@messages[type]
+    @messages[type][id]=value
+  end
+
+  def getCount(type)
+    delayedLoad
+    return 0 if !@messages
+    return 0 if !@messages[type]
+    return @messages[type].length
+  end
+
+  def get(type,id)
+    delayedLoad
+    return "" if !@messages
+    return "" if !@messages[type]
+    return "" if !@messages[type][id]
+    return @messages[type][id]
+  end
+
+  def getFromHash(type,key)
+    delayedLoad
+    return key if !@messages || !@messages[type] || !key
+    id=Messages.stringToKey(key)
+    return key if !@messages[type][id]
+    return @messages[type][id]
+  end
+
+  def getFromMapHash(type,key)
+    delayedLoad
+    return key if !@messages
+    return key if !@messages[0]
+    return key if !@messages[0][type] && !@messages[0][0]
+    id=Messages.stringToKey(key)
+    if @messages[0][type] &&  @messages[0][type][id]
+      return @messages[0][type][id]
+    elsif @messages[0][0] && @messages[0][0][id]
+      return @messages[0][0][id]
+    end
+    return key
+  end
+end
+
+
+
+module MessageTypes
+  # Value 0 is used for common event and map event text
+  Species           = 1
+  Kinds             = 2
+  Entries           = 3
+  FormNames         = 4
+  Moves             = 5
+  MoveDescriptions  = 6
+  Items             = 7
+  ItemPlurals       = 8
+  ItemDescriptions  = 9
+  Abilities         = 10
+  AbilityDescs      = 11
+  Types             = 12
+  TrainerTypes      = 13
+  TrainerNames      = 14
+  BeginSpeech       = 15
+  EndSpeechWin      = 16
+  EndSpeechLose     = 17
+  RegionNames       = 18
+  PlaceNames        = 19
+  PlaceDescriptions = 20
+  MapNames          = 21
+  PhoneMessages     = 22
+  TrainerLoseText   = 23
+  ScriptTexts       = 24
+  @@messages         = Messages.new
+  @@messagesFallback = Messages.new("Data/messages.dat",true)
+
+  def self.stringToKey(str)
+    return Messages.stringToKey(str)
+  end
+
+  def self.normalizeValue(value)
+    return Messages.normalizeValue(value)
+  end
+
+  def self.denormalizeValue(value)
+    Messages.denormalizeValue(value)
+  end
+
+  def self.writeObject(f,msgs,secname)
+    Messages.denormalizeValue(str)
+  end
+
+  def self.extract(outfile)
+    @@messages.extract(outfile)
+  end
+
+  def self.setMessages(type,array)
+    @@messages.setMessages(type,array)
+  end
+
+  def self.addMessages(type,array)
+    @@messages.addMessages(type,array)
+  end
+
+  def self.createHash(type,array)
+    Messages.createHash(type,array)
+  end
+
+  def self.addMapMessagesAsHash(type,array)
+    @@messages.addMapMessagesAsHash(type,array)
+  end
+
+  def self.setMapMessagesAsHash(type,array)
+    @@messages.setMapMessagesAsHash(type,array)
+  end
+
+  def self.addMessagesAsHash(type,array)
+    @@messages.addMessagesAsHash(type,array)
+  end
+
+  def self.setMessagesAsHash(type,array)
+    @@messages.setMessagesAsHash(type,array)
+  end
+
+  def self.saveMessages(filename=nil)
+    @@messages.saveMessages(filename)
+  end
+
+  def self.loadMessageFile(filename)
+    @@messages.loadMessageFile(filename)
+  end
+
+  def self.get(type,id)
+    ret=@@messages.get(type,id)
+    if ret==""
+      ret=@@messagesFallback.get(type,id)
+    end
+    return ret
+  end
+
+  def self.getCount(type)
+    c1=@@messages.getCount(type)
+    c2=@@messagesFallback.getCount(type)
+    return c1>c2 ? c1 : c2
+  end
+
+  def self.getOriginal(type,id)
+    return @@messagesFallback.get(type,id)
+  end
+
+  def self.getFromHash(type,key)
+    @@messages.getFromHash(type,key)
+  end
+
+  def self.getFromMapHash(type,key)
+    @@messages.getFromMapHash(type,key)
+  end
+end
+
+
+
+def pbLoadMessages(file)
+  return MessageTypes.loadMessageFile(file)
+end
+
+def pbGetMessageCount(type)
+  return MessageTypes.getCount(type)
+end
+
+def pbGetMessage(type,id)
+  return MessageTypes.get(type,id)
+end
+
+def pbGetMessageFromHash(type,id)
+  return MessageTypes.getFromHash(type,id)
+end
+
+# Replaces first argument with a localized version and formats the other
+# parameters by replacing {1}, {2}, etc. with those placeholders.
+def _INTL(*arg)
+  begin
+    string=MessageTypes.getFromHash(MessageTypes::ScriptTexts,arg[0])
+  rescue
+    string=arg[0]
+  end
+  string=string.clone
+  for i in 1...arg.length
+    string.gsub!(/\{#{i}\}/,"#{arg[i]}")
+  end
+  return string
+end
+
+# Replaces first argument with a localized version and formats the other
+# parameters by replacing {1}, {2}, etc. with those placeholders.
+# This version acts more like sprintf, supports e.g. {1:d} or {2:s}
+def _ISPRINTF(*arg)
+  begin
+    string=MessageTypes.getFromHash(MessageTypes::ScriptTexts,arg[0])
+  rescue
+    string=arg[0]
+  end
+  string=string.clone
+  for i in 1...arg.length
+    string.gsub!(/\{#{i}\:([^\}]+?)\}/) { |m|
+      next sprintf("%"+$1,arg[i])
+    }
+  end
+  return string
+end
+
+def _I(str)
+  return _MAPINTL($game_map.map_id,str)
+end
+
+def _MAPINTL(mapid,*arg)
+  string=MessageTypes.getFromMapHash(mapid,arg[0])
+  string=string.clone
+  for i in 1...arg.length
+    string.gsub!(/\{#{i}\}/,"#{arg[i]}")
+  end
+  return string
+end
+
+def _MAPISPRINTF(mapid,*arg)
+  string=MessageTypes.getFromMapHash(mapid,arg[0])
+  string=string.clone
+  for i in 1...arg.length
+    string.gsub!(/\{#{i}\:([^\}]+?)\}/) { |m|
+      next sprintf("%"+$1,arg[i])
+    }
+  end
+  return string
+end

Data/Scripts/006_Events and files/005_PBDebug.rb

@@ -0,0 +1,40 @@
+module PBDebug
+  @@log = []
+
+  def self.logonerr
+    begin
+      yield
+    rescue
+      PBDebug.log("")
+      PBDebug.log("**Exception: #{$!.message}")
+      PBDebug.log("#{$!.backtrace.inspect}")
+      PBDebug.log("")
+#      if $INTERNAL
+        pbPrintException($!)
+#      end
+      PBDebug.flush
+    end
+  end
+
+  def self.flush
+    if $DEBUG && $INTERNAL && @@log.length>0
+      File.open("Data/debuglog.txt", "a+b") { |f| f.write("#{@@log}") }
+    end
+    @@log.clear 
+  end
+
+  def self.log(msg)
+    if $DEBUG && $INTERNAL
+      @@log.push("#{msg}\r\n")
+#      if @@log.length>1024
+        PBDebug.flush
+#      end
+    end
+  end
+
+  def self.dump(msg)
+    if $DEBUG && $INTERNAL
+      File.open("Data/dumplog.txt", "a+b") { |f| f.write("#{msg}\r\n") }
+    end
+  end
+end