More renaming and rearranging, fixed typo from earlier commit, tweaked splash and title screen code

Data/Scripts/003_Game processing/001_StartGame.rb

@@ -0,0 +1,120 @@
+# The Game module contains methods for saving and loading the game.
+module Game
+  # Initializes various global variables and loads the game data.
+  def self.initialize
+    $PokemonTemp        = PokemonTemp.new
+    $game_temp          = Game_Temp.new
+    $game_system        = Game_System.new
+    $data_animations    = load_data('Data/Animations.rxdata')
+    $data_tilesets      = load_data('Data/Tilesets.rxdata')
+    $data_common_events = load_data('Data/CommonEvents.rxdata')
+    $data_system        = load_data('Data/System.rxdata')
+    pbLoadBattleAnimations
+    GameData.load_all
+    map_file = format('Data/Map%03d.rxdata', $data_system.start_map_id)
+    if $data_system.start_map_id == 0 || !pbRgssExists?(map_file)
+      raise _INTL('No starting position was set in the map editor.')
+    end
+  end
+
+  # Loads bootup data from save file (if it exists) or creates bootup data (if
+  # it doesn't).
+  def self.set_up_system
+    SaveData.move_old_windows_save if System.platform[/Windows/]
+    save_data = (SaveData.exists?) ? SaveData.read_from_file(SaveData::FILE_PATH) : {}
+    if save_data.empty?
+      SaveData.initialize_bootup_values
+    else
+      SaveData.load_bootup_values(save_data)
+    end
+    # Set resize factor
+    pbSetResizeFactor([$PokemonSystem.screensize, 4].min)
+    # Set language (and choose language if there is no save file)
+    if Settings::LANGUAGES.length >= 2
+      $PokemonSystem.language = pbChooseLanguage if save_data.empty?
+      pbLoadMessages('Data/' + Settings::LANGUAGES[$PokemonSystem.language][1])
+    end
+  end
+
+  # Called when starting a new game. Initializes global variables
+  # and transfers the player into the map scene.
+  def self.start_new
+    if $game_map && $game_map.events
+      $game_map.events.each_value { |event| event.clear_starting }
+    end
+    $game_temp.common_event_id = 0 if $game_temp
+    $PokemonTemp.begunNewGame = true
+    $scene = Scene_Map.new
+    SaveData.load_new_game_values
+    $MapFactory = PokemonMapFactory.new($data_system.start_map_id)
+    $game_player.moveto($data_system.start_x, $data_system.start_y)
+    $game_player.refresh
+    $game_map.autoplay
+    $game_map.update
+  end
+
+  # Loads the game from the given save data and starts the map scene.
+  # @param save_data [Hash] hash containing the save data
+  # @raise [SaveData::InvalidValueError] if an invalid value is being loaded
+  def self.load(save_data)
+    validate save_data => Hash
+    SaveData.load_all_values(save_data)
+    self.load_map
+    pbAutoplayOnSave
+    $game_map.update
+    $PokemonMap.updateMap
+    $scene = Scene_Map.new
+  end
+
+  # Loads and validates the map. Called when loading a saved game.
+  def self.load_map
+    $game_map = $MapFactory.map
+    magic_number_matches = ($game_system.magic_number == $data_system.magic_number)
+    if !magic_number_matches || $PokemonGlobal.safesave
+      if pbMapInterpreterRunning?
+        pbMapInterpreter.setup(nil, 0)
+      end
+      begin
+        $MapFactory.setup($game_map.map_id)
+      rescue Errno::ENOENT
+        if $DEBUG
+          pbMessage(_INTL('Map {1} was not found.', $game_map.map_id))
+          map = pbWarpToMap
+          exit unless map
+          $MapFactory.setup(map[0])
+          $game_player.moveto(map[1], map[2])
+        else
+          raise _INTL('The map was not found. The game cannot continue.')
+        end
+      end
+      $game_player.center($game_player.x, $game_player.y)
+    else
+      $MapFactory.setMapChanged($game_map.map_id)
+    end
+    if $game_map.events.nil?
+      raise _INTL('The map is corrupt. The game cannot continue.')
+    end
+    $PokemonEncounters = PokemonEncounters.new
+    $PokemonEncounters.setup($game_map.map_id)
+  end
+
+  # Saves the game. Returns whether the operation was successful.
+  # @param save_file [String] the save file path
+  # @param safe [Boolean] whether $PokemonGlobal.safesave should be set to true
+  # @return [Boolean] whether the operation was successful
+  # @raise [SaveData::InvalidValueError] if an invalid value is being saved
+  def self.save(save_file = SaveData::FILE_PATH, safe: false)
+    validate save_file => String, safe => [TrueClass, FalseClass]
+    $PokemonGlobal.safesave = safe
+    $game_system.save_count += 1
+    $game_system.magic_number = $data_system.magic_number
+    begin
+      SaveData.save_to_file(save_file)
+      Graphics.frame_reset
+    rescue IOError, SystemCallError
+      $game_system.save_count -= 1
+      return false
+    end
+    return true
+  end
+end

Data/Scripts/003_Game processing/002_Interpreter.rb

@@ -0,0 +1,447 @@
+#===============================================================================
+# ** Interpreter
+#-------------------------------------------------------------------------------
+#  This interpreter runs event commands. This class is used within the
+#  Game_System class and the Game_Event class.
+#===============================================================================
+class Interpreter
+  #-----------------------------------------------------------------------------
+  # * Object Initialization
+  #     depth : nest depth
+  #     main  : main flag
+  #-----------------------------------------------------------------------------
+  def initialize(depth = 0, main = false)
+    @depth = depth
+    @main  = main
+    if depth > 100
+      print("Common event call has exceeded maximum limit.")
+      exit
+    end
+    clear
+  end
+
+  def clear
+    @map_id             = 0       # map ID when starting up
+    @event_id           = 0       # event ID
+    @message_waiting    = false   # waiting for message to end
+    @move_route_waiting = false   # waiting for move completion
+    @wait_count         = 0       # wait count
+    @child_interpreter  = nil     # child interpreter
+    @branch             = {}      # branch data
+    @buttonInput        = false
+  end
+  #-----------------------------------------------------------------------------
+  # * Event Setup
+  #     list     : list of event commands
+  #     event_id : event ID
+  #-----------------------------------------------------------------------------
+  def setup(list, event_id, map_id = nil)
+    clear
+    @map_id = map_id || $game_map.map_id
+    @event_id = event_id
+    @list = list
+    @index = 0
+    @branch.clear
+  end
+
+  def setup_starting_event
+    $game_map.refresh if $game_map.need_refresh
+    # Set up common event if one wants to start
+    if $game_temp.common_event_id > 0
+      setup($data_common_events[$game_temp.common_event_id].list, 0)
+      $game_temp.common_event_id = 0
+      return
+    end
+    # Check all map events for one that wants to start, and set it up
+    for event in $game_map.events.values
+      next if !event.starting
+      if event.trigger < 3   # Isn't autorun or parallel processing
+        event.lock
+        event.clear_starting
+      end
+      setup(event.list, event.id, event.map.map_id)
+      return
+    end
+    # Check all common events for one that is autorun, and set it up
+    for common_event in $data_common_events.compact
+      next if common_event.trigger != 1 || !$game_switches[common_event.switch_id]
+      setup(common_event.list, 0)
+      return
+    end
+  end
+
+  def running?
+    return @list != nil
+  end
+  #-----------------------------------------------------------------------------
+  # * Frame Update
+  #-----------------------------------------------------------------------------
+  def update
+    @loop_count = 0
+    loop do
+      @loop_count += 1
+      if @loop_count > 100   # Call Graphics.update for freeze prevention
+        Graphics.update
+        @loop_count = 0
+      end
+      # If this interpreter's map isn't the current map or connected to it,
+      # forget this interpreter's event ID
+      if $game_map.map_id != @map_id && !$MapFactory.areConnected?($game_map.map_id, @map_id)
+        @event_id = 0
+      end
+      # Update child interpreter if one exists
+      if @child_interpreter
+        @child_interpreter.update
+        @child_interpreter = nil if !@child_interpreter.running?
+        return if @child_interpreter
+      end
+      # Do nothing if a message is being shown
+      return if @message_waiting
+      # Do nothing if any event or the player is in the middle of a move route
+      if @move_route_waiting
+        return if $game_player.move_route_forcing
+        for event in $game_map.events.values
+          return if event.move_route_forcing
+        end
+        @move_route_waiting = false
+      end
+      # Do nothing while waiting
+      if @wait_count > 0
+        @wait_count -= 1
+        return
+      end
+      # Do nothing if the pause menu is going to open
+      return if $game_temp.menu_calling
+      # If there are no commands in the list, try to find something that wants to run
+      if @list.nil?
+        setup_starting_event if @main
+        return if @list.nil?   # Couldn't find anything that wants to run
+      end
+      # Execute the next command
+      return if execute_command == false
+      # Move to the next @index
+      @index += 1
+    end
+  end
+  #-----------------------------------------------------------------------------
+  # * Execute script
+  #-----------------------------------------------------------------------------
+  def execute_script(script)
+    begin
+      result = eval(script)
+      return result
+    rescue Exception
+      e = $!
+      raise if e.is_a?(SystemExit) || "#{e.class}" == "Reset"
+      event = get_self
+      s = "Backtrace:\r\n"
+      message = pbGetExceptionMessage(e)
+      if e.is_a?(SyntaxError)
+        script.each_line { |line|
+          line.gsub!(/\s+$/, "")
+          if line[/^\s*\(/]
+            message += "\r\n***Line '#{line}' shouldn't begin with '('. Try\r\n"
+            message += "putting the '(' at the end of the previous line instead,\r\n"
+            message += "or using 'extendtext.exe'."
+          end
+          if line[/\:\:\s*$/]
+            message += "\r\n***Line '#{line}' can't end with '::'. Try putting\r\n"
+            message += "the next word on the same line, e.g. 'PBSpecies:" + ":MEW'"
+          end
+        }
+      else
+        for bt in e.backtrace[0, 10]
+          s += bt + "\r\n"
+        end
+        s.gsub!(/Section(\d+)/) { $RGSS_SCRIPTS[$1.to_i][1] }
+      end
+      message = "Exception: #{e.class}\r\nMessage: " + message + "\r\n"
+      message += "\r\n***Full script:\r\n#{script}\r\n"
+      if event && $game_map
+        map_name = ($game_map.name rescue nil) || "???"
+        err  = "Script error in event #{event.id} (coords #{event.x},#{event.y}), map #{$game_map.map_id} (#{map_name}):\r\n"
+        err += "#{message}\r\n#{s}"
+        if e.is_a?(Hangup)
+          $EVENTHANGUPMSG = err
+          raise
+        end
+      elsif $game_map
+        map_name = ($game_map.name rescue nil) || "???"
+        err = "Script error in map #{$game_map.map_id} (#{map_name}):\r\n"
+        err += "#{message}\r\n#{s}"
+        if e.is_a?(Hangup)
+          $EVENTHANGUPMSG = err
+          raise
+        end
+      else
+        err = "Script error in interpreter:\r\n#{message}\r\n#{s}"
+        if e.is_a?(Hangup)
+          $EVENTHANGUPMSG = err
+          raise
+        end
+      end
+      raise err
+    end
+  end
+  #-----------------------------------------------------------------------------
+  # * Get Character
+  #     parameter : parameter
+  #-----------------------------------------------------------------------------
+  def get_character(parameter = 0)
+    case parameter
+    when -1   # player
+      return $game_player
+    when 0    # this event
+      events = $game_map.events
+      return (events) ? events[@event_id] : nil
+    else      # specific event
+      events = $game_map.events
+      return (events) ? events[parameter] : nil
+    end
+  end
+
+  def get_player
+    return get_character(-1)
+  end
+
+  def get_self
+    return get_character(0)
+  end
+
+  def get_event(parameter)
+    return get_character(parameter)
+  end
+  #-----------------------------------------------------------------------------
+  # * Freezes all events on the map (for use at the beginning of common events)
+  #-----------------------------------------------------------------------------
+  def pbGlobalLock
+    $game_map.events.values.each { |event| event.minilock }
+  end
+  #-----------------------------------------------------------------------------
+  # * Unfreezes all events on the map (for use at the end of common events)
+  #-----------------------------------------------------------------------------
+  def pbGlobalUnlock
+    $game_map.events.values.each { |event| event.unlock }
+  end
+  #-----------------------------------------------------------------------------
+  # * Gets the next index in the interpreter, ignoring certain commands between messages
+  #-----------------------------------------------------------------------------
+  def pbNextIndex(index)
+    return -1 if !@list || @list.length == 0
+    i = index + 1
+    loop do
+      return i if i >= @list.length - 1
+      case @list[i].code
+      when 118, 108, 408   # Label, Comment
+        i += 1
+      when 413             # Repeat Above
+        i = pbRepeatAbove(i)
+      when 113             # Break Loop
+        i = pbBreakLoop(i)
+      when 119             # Jump to Label
+        newI = pbJumpToLabel(i, @list[i].parameters[0])
+        i = (newI > i) ? newI : i + 1
+      else
+        return i
+      end
+    end
+  end
+
+  def pbRepeatAbove(index)
+    index = @list[index].indent
+    loop do
+      index -= 1
+      return index + 1 if @list[index].indent == indent
+    end
+  end
+
+  def pbBreakLoop(index)
+    indent = @list[index].indent
+    temp_index = index
+    loop do
+      temp_index += 1
+      return index + 1 if temp_index >= @list.size - 1
+      return temp_index + 1 if @list[temp_index].code == 413 &&
+                               @list[temp_index].indent < indent
+    end
+  end
+
+  def pbJumpToLabel(index, label_name)
+    temp_index = 0
+    loop do
+      return index + 1 if temp_index >= @list.size - 1
+      return temp_index + 1 if @list[temp_index].code == 118 &&
+                               @list[temp_index].parameters[0] == label_name
+      temp_index += 1
+    end
+  end
+  #-----------------------------------------------------------------------------
+  # * Various methods to be used in a script event command.
+  #-----------------------------------------------------------------------------
+  # Helper function that shows a picture in a script.
+  def pbShowPicture(number, name, origin, x, y, zoomX = 100, zoomY = 100, opacity = 255, blendType = 0)
+    number = number + ($game_temp.in_battle ? 50 : 0)
+    $game_screen.pictures[number].show(name, origin, x, y, zoomX, zoomY, opacity, blendType)
+  end
+
+  # Erases an event and adds it to the list of erased events so that
+  # it can stay erased when the game is saved then loaded again.
+  def pbEraseThisEvent
+    if $game_map.events[@event_id]
+      $game_map.events[@event_id].erase
+      $PokemonMap.addErasedEvent(@event_id) if $PokemonMap
+    end
+    @index += 1
+    return true
+  end
+
+  # Runs a common event.
+  def pbCommonEvent(id)
+    common_event = $data_common_events[id]
+    return if !common_event
+    if $game_temp.in_battle
+      $game_system.battle_interpreter.setup(common_event.list, 0)
+    else
+      interp = Interpreter.new
+      interp.setup(common_event.list, 0)
+      loop do
+        Graphics.update
+        Input.update
+        interp.update
+        pbUpdateSceneMap
+        break if !interp.running?
+      end
+    end
+  end
+
+  # Sets another event's self switch (eg. pbSetSelfSwitch(20, "A", true) ).
+  def pbSetSelfSwitch(eventid, switch_name, value, mapid = -1)
+    mapid = @map_id if mapid < 0
+    old_value = $game_self_switches[[mapid, eventid, switch_name]]
+    $game_self_switches[[mapid, eventid, switch_name]] = value
+    if value != old_value && $MapFactory.hasMap?(mapid)
+      $MapFactory.getMap(mapid, false).need_refresh = true
+    end
+  end
+
+  def tsOff?(c)
+    return get_self.tsOff?(c)
+  end
+  alias isTempSwitchOff? tsOff?
+
+  def tsOn?(c)
+    return get_self.tsOn?(c)
+  end
+  alias isTempSwitchOn? tsOn?
+
+  def setTempSwitchOn(c)
+    get_self.setTempSwitchOn(c)
+  end
+
+  def setTempSwitchOff(c)
+    get_self.setTempSwitchOff(c)
+  end
+
+  def getVariable(*arg)
+    if arg.length == 0
+      return nil if !$PokemonGlobal.eventvars
+      return $PokemonGlobal.eventvars[[@map_id, @event_id]]
+    else
+      return $game_variables[arg[0]]
+    end
+  end
+
+  def setVariable(*arg)
+    if arg.length == 1
+      $PokemonGlobal.eventvars = {} if !$PokemonGlobal.eventvars
+      $PokemonGlobal.eventvars[[@map_id, @event_id]] = arg[0]
+    else
+      $game_variables[arg[0]] = arg[1]
+      $game_map.need_refresh = true
+    end
+  end
+
+  def pbGetPokemon(id)
+    return $Trainer.party[pbGet(id)]
+  end
+
+  def pbSetEventTime(*arg)
+    $PokemonGlobal.eventvars = {} if !$PokemonGlobal.eventvars
+    time = pbGetTimeNow
+    time = time.to_i
+    pbSetSelfSwitch(@event_id, "A", true)
+    $PokemonGlobal.eventvars[[@map_id, @event_id]] = time
+    for otherevt in arg
+      pbSetSelfSwitch(otherevt, "A", true)
+      $PokemonGlobal.eventvars[[@map_id, otherevt]] = time
+    end
+  end
+
+  # Used in boulder events. Allows an event to be pushed.
+  def pbPushThisEvent
+    event = get_self
+    old_x  = event.x
+    old_y  = event.y
+    # Apply strict version of passable, which treats tiles that are passable
+    # only from certain directions as fully impassible
+    return if !event.can_move_in_direction?($game_player.direction, true)
+    case $game_player.direction
+    when 2 then event.move_down
+    when 4 then event.move_left
+    when 6 then event.move_right
+    when 8 then event.move_up
+    end
+    $PokemonMap.addMovedEvent(@event_id) if $PokemonMap
+    if old_x != event.x || old_y != event.y
+      $game_player.lock
+      loop do
+        Graphics.update
+        Input.update
+        pbUpdateSceneMap
+        break if !event.moving?
+      end
+      $game_player.unlock
+    end
+  end
+
+  def pbPushThisBoulder
+    pbPushThisEvent if $PokemonMap.strengthUsed
+    return true
+  end
+
+  def pbSmashThisEvent
+    event = get_self
+    pbSmashEvent(event) if event
+    @index += 1
+    return true
+  end
+
+  def pbTrainerIntro(symbol)
+    return true if $DEBUG && !GameData::TrainerType.exists?(symbol)
+    tr_type = GameData::TrainerType.get(symbol).id
+    pbGlobalLock
+    pbPlayTrainerIntroME(tr_type)
+    return true
+  end
+
+  def pbTrainerEnd
+    pbGlobalUnlock
+    event = get_self
+    event.erase_route if event
+  end
+
+  def setPrice(item, buy_price = -1, sell_price = -1)
+    item = GameData::Item.get(item).id
+    $game_temp.mart_prices[item] = [-1, -1] if !$game_temp.mart_prices[item]
+    $game_temp.mart_prices[item][0] = buy_price if buy_price > 0
+    if sell_price >= 0   # 0=can't sell
+      $game_temp.mart_prices[item][1] = sell_price * 2
+    else
+      $game_temp.mart_prices[item][1] = buy_price if buy_price > 0
+    end
+  end
+
+  def setSellPrice(item, sell_price)
+    setPrice(item, -1, sell_price)
+  end
+end

Data/Scripts/003_Game processing/004_Scene_Map.rb

@@ -0,0 +1,227 @@
+#===============================================================================
+# ** Modified Scene_Map class for Pokémon.
+#-------------------------------------------------------------------------------
+#
+#===============================================================================
+class Scene_Map
+  attr_reader :spritesetGlobal
+
+  def spriteset
+    for i in @spritesets.values
+      return i if i.map==$game_map
+    end
+    return @spritesets.values[0]
+  end
+
+  def createSpritesets
+    @spritesetGlobal = Spriteset_Global.new
+    @spritesets = {}
+    for map in $MapFactory.maps
+      @spritesets[map.map_id] = Spriteset_Map.new(map)
+    end
+    $MapFactory.setSceneStarted(self)
+    updateSpritesets
+  end
+
+  def createSingleSpriteset(map)
+    temp = $scene.spriteset.getAnimations
+    @spritesets[map] = Spriteset_Map.new($MapFactory.maps[map])
+    $scene.spriteset.restoreAnimations(temp)
+    $MapFactory.setSceneStarted(self)
+    updateSpritesets
+  end
+
+  def disposeSpritesets
+    return if !@spritesets
+    for i in @spritesets.keys
+      next if !@spritesets[i]
+      @spritesets[i].dispose
+      @spritesets[i] = nil
+    end
+    @spritesets.clear
+    @spritesets = {}
+    @spritesetGlobal.dispose
+    @spritesetGlobal = nil
+  end
+
+  def autofade(mapid)
+    playingBGM = $game_system.playing_bgm
+    playingBGS = $game_system.playing_bgs
+    return if !playingBGM && !playingBGS
+    map = load_data(sprintf("Data/Map%03d.rxdata", mapid))
+    if playingBGM && map.autoplay_bgm
+      if (PBDayNight.isNight? rescue false)
+        pbBGMFade(0.8) if playingBGM.name!=map.bgm.name && playingBGM.name!=map.bgm.name+"_n"
+      else
+        pbBGMFade(0.8) if playingBGM.name!=map.bgm.name
+      end
+    end
+    if playingBGS && map.autoplay_bgs
+      pbBGMFade(0.8) if playingBGS.name!=map.bgs.name
+    end
+    Graphics.frame_reset
+  end
+
+  def transfer_player(cancelVehicles=true)
+    $game_temp.player_transferring = false
+    pbCancelVehicles($game_temp.player_new_map_id) if cancelVehicles
+    autofade($game_temp.player_new_map_id)
+    pbBridgeOff
+    if $game_map.map_id!=$game_temp.player_new_map_id
+      $MapFactory.setup($game_temp.player_new_map_id)
+    end
+    $game_player.moveto($game_temp.player_new_x, $game_temp.player_new_y)
+    case $game_temp.player_new_direction
+    when 2 then $game_player.turn_down
+    when 4 then $game_player.turn_left
+    when 6 then $game_player.turn_right
+    when 8 then $game_player.turn_up
+    end
+    $game_player.straighten
+    $game_map.update
+    disposeSpritesets
+    RPG::Cache.clear
+    createSpritesets
+    if $game_temp.transition_processing
+      $game_temp.transition_processing = false
+      Graphics.transition(20)
+    end
+    $game_map.autoplay
+    Graphics.frame_reset
+    Input.update
+  end
+
+  def call_menu
+    $game_temp.menu_calling = false
+    $game_temp.in_menu = true
+    $game_player.straighten
+    $game_map.update
+    sscene = PokemonPauseMenu_Scene.new
+    sscreen = PokemonPauseMenu.new(sscene)
+    sscreen.pbStartPokemonMenu
+    $game_temp.in_menu = false
+  end
+
+  def call_debug
+    $game_temp.debug_calling = false
+    pbPlayDecisionSE
+    $game_player.straighten
+    pbFadeOutIn { pbDebugMenu }
+  end
+
+  def miniupdate
+    $PokemonTemp.miniupdate = true
+    loop do
+      updateMaps
+      $game_player.update
+      $game_system.update
+      $game_screen.update
+      break unless $game_temp.player_transferring
+      transfer_player
+      break if $game_temp.transition_processing
+    end
+    updateSpritesets
+    $PokemonTemp.miniupdate = false
+  end
+
+  def updateMaps
+    for map in $MapFactory.maps
+      map.update
+    end
+    $MapFactory.updateMaps(self)
+  end
+
+  def updateSpritesets
+    @spritesets = {} if !@spritesets
+    keys = @spritesets.keys.clone
+    for i in keys
+      if !$MapFactory.hasMap?(i)
+        @spritesets[i].dispose if @spritesets[i]
+        @spritesets[i] = nil
+        @spritesets.delete(i)
+      else
+        @spritesets[i].update
+      end
+    end
+    @spritesetGlobal.update
+    for map in $MapFactory.maps
+      @spritesets[map.map_id] = Spriteset_Map.new(map) if !@spritesets[map.map_id]
+    end
+    Events.onMapUpdate.trigger(self)
+  end
+
+  def update
+    loop do
+      updateMaps
+      pbMapInterpreter.update
+      $game_player.update
+      $game_system.update
+      $game_screen.update
+      break unless $game_temp.player_transferring
+      transfer_player
+      break if $game_temp.transition_processing
+    end
+    updateSpritesets
+    if $game_temp.to_title
+      $scene = pbCallTitle
+      return
+    end
+    if $game_temp.transition_processing
+      $game_temp.transition_processing = false
+      if $game_temp.transition_name == ""
+        Graphics.transition(20)
+      else
+        Graphics.transition(40, "Graphics/Transitions/" + $game_temp.transition_name)
+      end
+    end
+    return if $game_temp.message_window_showing
+    if !pbMapInterpreterRunning?
+      if Input.trigger?(Input::USE)
+        $PokemonTemp.hiddenMoveEventCalling = true
+      elsif Input.trigger?(Input::BACK)
+        unless $game_system.menu_disabled or $game_player.moving?
+          $game_temp.menu_calling = true
+          $game_temp.menu_beep = true
+        end
+      elsif Input.trigger?(Input::Z)
+        unless $game_player.moving?
+          $PokemonTemp.keyItemCalling = true
+        end
+      elsif Input.press?(Input::F9)
+        $game_temp.debug_calling = true if $DEBUG
+      end
+    end
+    unless $game_player.moving?
+      if $game_temp.menu_calling
+        call_menu
+      elsif $game_temp.debug_calling
+        call_debug
+      elsif $PokemonTemp.keyItemCalling
+        $PokemonTemp.keyItemCalling = false
+        $game_player.straighten
+        pbUseKeyItem
+      elsif $PokemonTemp.hiddenMoveEventCalling
+        $PokemonTemp.hiddenMoveEventCalling = false
+        $game_player.straighten
+        Events.onAction.trigger(self)
+      end
+    end
+  end
+
+  def main
+    createSpritesets
+    Graphics.transition(20)
+    loop do
+      Graphics.update
+      Input.update
+      update
+      break if $scene != self
+    end
+    Graphics.freeze
+    disposeSpritesets
+    if $game_temp.to_title
+      Graphics.transition(20)
+      Graphics.freeze
+    end
+  end
+end

Data/Scripts/003_Game processing/005_Event_Handlers.rb

@@ -0,0 +1,275 @@
+#===============================================================================
+# 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(conditionProc,handler=nil,&handlerBlock)
+    if ![Proc,Hash].include?(handler.class) && !block_given?
+      raise ArgumentError, "addIf call for #{self.class.name} has no valid handler (#{handler.inspect} was given)"
+    end
+    @addIfs.push([conditionProc,handler || handlerBlock])
+  end
+
+  def add(sym,handler=nil,&handlerBlock) # 'sym' can be an ID or symbol
+    if ![Proc,Hash].include?(handler.class) && !block_given?
+      raise ArgumentError, "#{self.class.name} for #{sym.inspect} has no valid handler (#{handler.inspect} was given)"
+    end
+    id = fromSymbol(sym)
+    @hash[id] = handler || handlerBlock if id
+    symbol = toSymbol(sym)
+    @hash[symbol] = handler || handlerBlock 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
+
+#===============================================================================
+# A stripped-down version of class HandlerHash which only deals with symbols and
+# doesn't care about whether those symbols actually relate to a defined thing.
+#===============================================================================
+class HandlerHash2
+  def initialize
+    @hash    = {}
+    @add_ifs = []
+  end
+
+  def [](sym)
+    sym = sym.id if !sym.is_a?(Symbol) && sym.respond_to?("id")
+    return @hash[sym] if sym && @hash[sym]
+    for add_if in @add_ifs
+      return add_if[1] if add_if[0].call(sym)
+    end
+    return nil
+  end
+
+  def addIf(conditionProc, handler = nil, &handlerBlock)
+    if ![Proc, Hash].include?(handler.class) && !block_given?
+      raise ArgumentError, "addIf call for #{self.class.name} has no valid handler (#{handler.inspect} was given)"
+    end
+    @add_ifs.push([conditionProc, handler || handlerBlock])
+  end
+
+  def add(sym, handler = nil, &handlerBlock)
+    if ![Proc, Hash].include?(handler.class) && !block_given?
+      raise ArgumentError, "#{self.class.name} for #{sym.inspect} has no valid handler (#{handler.inspect} was given)"
+    end
+    @hash[sym] = handler || handlerBlock if sym
+  end
+
+  def copy(src, *dests)
+    handler = self[src]
+    return if !handler
+    for dest in dests
+      self.add(dest, handler)
+    end
+  end
+
+  def clear
+    @hash.clear
+  end
+
+  def trigger(sym, *args)
+    sym = sym.id if !sym.is_a?(Symbol) && sym.respond_to?("id")
+    handler = self[sym]
+    return (handler) ? handler.call(sym, *args) : nil
+  end
+end
+
+#===============================================================================
+# An even more stripped down version of class HandlerHash which just takes
+# hashes with keys, no matter what the keys are.
+#===============================================================================
+class HandlerHashBasic
+  def initialize
+    @ordered_keys = []
+    @hash         = {}
+    @addIfs       = []
+  end
+
+  def [](entry)
+    ret = nil
+    ret = @hash[entry] if entry && @hash[entry]
+    unless ret
+      for addif in @addIfs
+        return addif[1] if addif[0].call(entry)
+      end
+    end
+    return ret
+  end
+
+  def each
+    @ordered_keys.each { |key| yield key, @hash[key] }
+  end
+
+  def add(entry, handler = nil, &handlerBlock)
+    if ![Proc,Hash].include?(handler.class) && !block_given?
+      raise ArgumentError, "#{self.class.name} for #{entry.inspect} has no valid handler (#{handler.inspect} was given)"
+    end
+    return if !entry || entry.empty?
+    @ordered_keys.push(entry) if !@ordered_keys.include?(entry)
+    @hash[entry] = handler || handlerBlock
+  end
+
+  def addIf(conditionProc, handler = nil, &handlerBlock)
+    if ![Proc, Hash].include?(handler.class) && !block_given?
+      raise ArgumentError, "addIf call for #{self.class.name} has no valid handler (#{handler.inspect} was given)"
+    end
+    @addIfs.push([conditionProc, handler || handlerBlock])
+  end
+
+  def copy(src, *dests)
+    handler = self[src]
+    return if !handler
+    dests.each { |dest| self.add(dest, handler) }
+  end
+
+  def clear
+    @hash.clear
+    @ordered_keys.clear
+  end
+
+  def trigger(entry, *args)
+    handler = self[entry]
+    return (handler) ? handler.call(*args) : nil
+  end
+end
+
+#===============================================================================
+#
+#===============================================================================
+class SpeciesHandlerHash < HandlerHash2
+end
+
+class AbilityHandlerHash < HandlerHash2
+end
+
+class ItemHandlerHash < HandlerHash2
+end
+
+class MoveHandlerHash < HandlerHash2
+end

Data/Scripts/003_Game processing/006_Event_FieldEvents.rb

@@ -0,0 +1,172 @@
+#===============================================================================
+# This module stores events that can happen during the game. A procedure can
+# subscribe to an event by adding itself to the event. It will then be called
+# whenever the event occurs.
+#===============================================================================
+module Events
+  @@OnMapCreate                 = Event.new
+  @@OnMapUpdate                 = Event.new
+  @@OnMapChange                 = Event.new
+  @@OnMapChanging               = Event.new
+  @@OnMapSceneChange            = Event.new
+  @@OnSpritesetCreate           = Event.new
+  @@OnAction                    = Event.new
+  @@OnStepTaken                 = Event.new
+  @@OnLeaveTile                 = Event.new
+  @@OnStepTakenFieldMovement    = Event.new
+  @@OnStepTakenTransferPossible = Event.new
+  @@OnStartBattle               = Event.new
+  @@OnEndBattle                 = Event.new
+  @@OnWildPokemonCreate         = Event.new
+  @@OnWildBattleOverride        = Event.new
+  @@OnWildBattleEnd             = Event.new
+  @@OnTrainerPartyLoad          = Event.new
+  @@OnChangeDirection           = Event.new
+
+  # Fires whenever a map is created. Event handler receives two parameters: the
+  # map (RPG::Map) and the tileset (RPG::Tileset)
+  def self.onMapCreate;     @@OnMapCreate;     end
+  def self.onMapCreate=(v); @@OnMapCreate = v; end
+
+  # Fires each frame during a map update.
+  def self.onMapUpdate;     @@OnMapUpdate;     end
+  def self.onMapUpdate=(v); @@OnMapUpdate = v; end
+
+  # Fires whenever one map is about to change to a different one. Event handler
+  # receives the new map ID and the Game_Map object representing the new map.
+  # When the event handler is called, $game_map still refers to the old map.
+  def self.onMapChanging;     @@OnMapChanging;     end
+  def self.onMapChanging=(v); @@OnMapChanging = v; end
+
+  # Fires whenever the player moves to a new map. Event handler receives the old
+  # map ID or 0 if none. Also fires when the first map of the game is loaded
+  def self.onMapChange;     @@OnMapChange;     end
+  def self.onMapChange=(v); @@OnMapChange = v; end
+
+  # Fires whenever the map scene is regenerated and soon after the player moves
+  # to a new map.
+  # Parameters:
+  # e[0] - Scene_Map object.
+  # e[1] - Whether the player just moved to a new map (either true or false). If
+  #        false, some other code had called $scene.createSpritesets to
+  #        regenerate the map scene without transferring the player elsewhere
+  def self.onMapSceneChange;     @@OnMapSceneChange;     end
+  def self.onMapSceneChange=(v); @@OnMapSceneChange = v; end
+
+  # Fires whenever a spriteset is created.
+  # Parameters:
+  # e[0] - Spriteset being created. e[0].map is the map associated with the
+  #        spriteset (not necessarily the current map).
+  # e[1] - Viewport used for tilemap and characters
+  def self.onSpritesetCreate;     @@OnSpritesetCreate;     end
+  def self.onSpritesetCreate=(v); @@OnSpritesetCreate = v; end
+
+  # Triggers when the player presses the Action button on the map.
+  def self.onAction;     @@OnAction;     end
+  def self.onAction=(v); @@OnAction = v; end
+
+  # Fires whenever the player takes a step.
+  def self.onStepTaken;     @@OnStepTaken;     end
+  def self.onStepTaken=(v); @@OnStepTaken = v; end
+
+  # Fires whenever the player or another event leaves a tile.
+  # Parameters:
+  # e[0] - Event that just left the tile.
+  # e[1] - Map ID where the tile is located (not necessarily
+  #        the current map). Use "$MapFactory.getMap(e[1])" to
+  #        get the Game_Map object corresponding to that map.
+  # e[2] - X-coordinate of the tile
+  # e[3] - Y-coordinate of the tile
+  def self.onLeaveTile;     @@OnLeaveTile;     end
+  def self.onLeaveTile=(v); @@OnLeaveTile = v; end
+
+  # Fires whenever the player or another event enters a tile.
+  # Parameters:
+  # e[0] - Event that just entered a tile.
+  def self.onStepTakenFieldMovement;     @@OnStepTakenFieldMovement;     end
+  def self.onStepTakenFieldMovement=(v); @@OnStepTakenFieldMovement = v; end
+
+  # Fires whenever the player takes a step. The event handler may possibly move
+  # the player elsewhere.
+  # Parameters:
+  # e[0] - Array that contains a single boolean value. If an event handler moves
+  #        the player to a new map, it should set this value to true. Other
+  #        event handlers should check this parameter's value.
+  def self.onStepTakenTransferPossible;     @@OnStepTakenTransferPossible;     end
+  def self.onStepTakenTransferPossible=(v); @@OnStepTakenTransferPossible = v; end
+
+  def self.onStartBattle;     @@OnStartBattle;     end
+  def self.onStartBattle=(v); @@OnStartBattle = v; end
+
+  def self.onEndBattle;     @@OnEndBattle;     end
+  def self.onEndBattle=(v); @@OnEndBattle = v; end
+
+  # Triggers whenever a wild Pokémon is created
+  # Parameters:
+  # e[0] - Pokémon being created
+  def self.onWildPokemonCreate;     @@OnWildPokemonCreate;     end
+  def self.onWildPokemonCreate=(v); @@OnWildPokemonCreate = v; end
+
+  # Triggers at the start of a wild battle.  Event handlers can provide their
+  # own wild battle routines to override the default behavior.
+  def self.onWildBattleOverride;     @@OnWildBattleOverride;     end
+  def self.onWildBattleOverride=(v); @@OnWildBattleOverride = v; end
+
+  # Triggers whenever a wild Pokémon battle ends
+  # Parameters:
+  # e[0] - Pokémon species
+  # e[1] - Pokémon level
+  # e[2] - Battle result (1-win, 2-loss, 3-escaped, 4-caught, 5-draw)
+  def self.onWildBattleEnd;     @@OnWildBattleEnd;     end
+  def self.onWildBattleEnd=(v); @@OnWildBattleEnd = v; end
+
+  # Triggers whenever an NPC trainer's Pokémon party is loaded
+  # Parameters:
+  # e[0] - Trainer
+  # e[1] - Items possessed by the trainer
+  # e[2] - Party
+  def self.onTrainerPartyLoad;     @@OnTrainerPartyLoad;     end
+  def self.onTrainerPartyLoad=(v); @@OnTrainerPartyLoad = v; end
+
+  # Fires whenever the player changes direction.
+  def self.onChangeDirection;     @@OnChangeDirection;     end
+  def self.onChangeDirection=(v); @@OnChangeDirection = v; end
+end
+
+#===============================================================================
+#
+#===============================================================================
+def pbOnSpritesetCreate(spriteset,viewport)
+  Events.onSpritesetCreate.trigger(nil,spriteset,viewport)
+end
+
+#===============================================================================
+# This module stores encounter-modifying events that can happen during the game.
+# A procedure can subscribe to an event by adding itself to the event. It will
+# then be called whenever the event occurs.
+#===============================================================================
+module EncounterModifier
+  @@procs    = []
+  @@procsEnd = []
+
+  def self.register(p)
+    @@procs.push(p)
+  end
+
+  def self.registerEncounterEnd(p)
+    @@procsEnd.push(p)
+  end
+
+  def self.trigger(encounter)
+    for prc in @@procs
+      encounter = prc.call(encounter)
+    end
+    return encounter
+  end
+
+  def self.triggerEncounterEnd()
+    for prc in @@procsEnd
+      prc.call()
+    end
+  end
+end