Updated to mkxp-z v2.1.1, renamed and rearranged some script files

Data/Scripts/002b_TriggeredEvents/001_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/002b_TriggeredEvents/002_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