DoubleX RMVXA State Triggers v1.03b

#==============================================================================|
#  ** Script Info                                                              |
#------------------------------------------------------------------------------|
#  * Script Name                                                               |
#    DoubleX RMVXA State Triggers                                              |
#------------------------------------------------------------------------------|
#  * Functions                                                                 |
#    Sets some states to trigger additional effects when conditions are met    |
#------------------------------------------------------------------------------|
#  * Terms Of Use                                                              |
#    You shall keep this script's Script Info part's contents intact           |
#    You shalln't claim that this script is written by anyone other than       |
#    DoubleX or his aliases                                                    |
#    None of the above applies to DoubleX or his aliases                       |
#------------------------------------------------------------------------------|
#  * Prerequisites                                                             |
#    Abilities:                                                                |
#    1. Decent RGSS3 scripting proficiency to fully utilize this script        |
#------------------------------------------------------------------------------|
#  * Instructions                                                              |
#    1. Open the script editor and put this script into an open slot between   |
#       Materials and Main, save to take effect.                               |
#------------------------------------------------------------------------------|
#  * Links                                                                     |
#    Script Usage 101:                                                         |
#    1. forums.rpgmakerweb.com/index.php?/topic/32752-rmvxa-script-usage-101/  |
#    2. rpgmakervxace.net/topic/27475-rmvxa-script-usage-101/                  |
#    This script:                                                              |
#    1. http://www.rpgmakervxace.net/topic/31374-doublex-rmvxa-state-triggers/ |
#    Mentioned Patreon Supporters:                                             |
#    https://www.patreon.com/posts/71738797                                    |
#------------------------------------------------------------------------------|
#  * Authors                                                                   |
#    DoubleX                                                                   |
#------------------------------------------------------------------------------|
#  * Changelog                                                                 |
#    v1.03b(GMT 1400 10-5-2016):                                               |
#    1. timing while won't replace but will combine the state's existing       |
#       features with all stax meeting the corresponding stcx                  |
#    v1.03a(GMT 1500 9-5-2016):                                                |
#    1. adding the timing while to <timing state trigger: stcx, stax>          |
#    v1.02a(GMT 1300 26-2-2016):                                               |
#    1. stcx and stax take the state calling them as an argument as well       |
#    v1.01b(GMT 0300 7-11-2015):                                               |
#    1. Notetag values are now symbols of methods in the configuration regions |
#    2. This script doesn't need DoubleX RMVXA State Triggers Compatibility to |
#       be compatible with all its addressed scripts                           |
#    3. Further improved this script's compatibility, efficiency and simplicity|
#    v1.01a(GMT 1100 8-5-2015):                                                |
#    1. Lets users use state triggers with timings set by them                 |
#    v1.00g(GMT 1600 4-5-2015):                                                |
#    1. Improved this script's efficiency                                      |
#    v1.00f(GMT 0300 25-4-2015):                                               |
#    1. Improved this script's effectiveness                                   |
#    v1.00e(GMT 1400 21-4-2015):                                               |
#    1. Further improved this script's robustness                              |
#    v1.00d(GMT 1500 14-4-2015):                                               |
#    1. Improved this script's robustness                                      |
#    v1.00c(GMT 0200 12-4-2015):                                               |
#    1. Fixed triggering remove actions upon adding state resists bug          |
#    2. Fixed not triggering remove actions upon death, escape and recovery bug|
#    v1.00b(GMT 1400 11-4-2015):                                               |
#    1. Fixed not supporting multiple notetags on the same state bug           |
#    v1.00a(GMT 1100 11-4-2015):                                               |
#    1. 1st version of this script finished                                    |
#==============================================================================|

#==============================================================================|
#  ** Notetag Info                                                             |
#------------------------------------------------------------------------------|
#  * State Notetags:                                                           |
#    1. <timing state trigger: stcx, stax>                                     |
#       - Sets a state to trigger stax when timing and stcx are met            |
#       - timing can be add, turn, remove or custom timings set by you         |
#       - add means the state's just added                                     |
#       - turn means the state's remaining turn's just reduced by 1            |
#       - remove means the state's just removed                                |
#       - while means the stax effects are active as long as the state's active|
#       - timing must only consist of alphanumeric characters                  |
#       - stcx can be set in State Trigger Condition Notetag Values            |
#       - stax can be set in State Trigger Action Notetag Values               |
#==============================================================================|

#==============================================================================|
#  ** Script Call Info                                                         |
#------------------------------------------------------------------------------|
#  * Battler manipulations                                                     |
#    1. exec_state_triggers(state_id, timing)                                  |
#       - Executes all state triggers with timing timing of state with id      |
#         state_id                                                             |
#    2. state_trigger_features(state, timing)                                  |
#       - Returns an array of features returned by all stax meeting stcx with  |
#         timing timing of state                                               |
#       - This script call's not supposed to work with timing add, turn nor    |
#         remove but supposed to work with timing while                        |
#==============================================================================|

($doublex_rmvxa ||= {})[:State_Triggers] = "v1.03b"

#==============================================================================|
#  ** Script Configurations                                                    |
#     You only need to edit this part as it's about what this script does      |
#------------------------------------------------------------------------------|

module DoubleX_RMVXA

  module State_Triggers

    #--------------------------------------------------------------------------|
    #  State Trigger Condition Notetag Values                                  |
    #  - Setups stcx used by this script's notetags                            |
    #--------------------------------------------------------------------------|
    # stcx are read at:
    # 1. RPG::State
    #    - (@state_triggers[$1.downcase.to_sym] ||= []).push(
    #      [$2.downcase, $3.downcase]) in load_state_triggers_notes
    # stcx are used at:
    # 1. Game_BattlerBase
    #    - st.send(trigger[0], self, state) in state_trigger_features
    # 2. Game_Battler
    #    - st.send(trigger[1], self) if st.send(trigger[0], self) in
    #      exec_state_triggers
    # stcx are strings names of methods under DoubleX_RMVXA::State_Triggers
    # stcx names can only use alphanumeric characters and can't use uppercase
    # letters
    # battler is the battler calling the stcx
    # state is the state using the stcx
    # The below stcx are examples added to help you set your stcx
    # You can freely use, rewrite and/or delete these examples

    # Sets the state trigger condition as always true
    def self.stc1(battler, state)
      true
    end

    # Sets the state trigger condition as always false
    def self.stc2(battler, state)
      false
    end

    # Sets the state trigger condition as needing switch with id x to be on
    def self.stc3(battler, state)
      $game_switches[x]
    end

    # Sets the state trigger condition as needing the state using this stcx to
    # have its number of remaining turns greater than x
    def self.stc4(battler, state)
      battler.instance_exec { @state_turns[state_id] > x }
    end

    # Adds new stcx here


    #--------------------------------------------------------------------------|
    #  State Trigger Action Notetag Values                                     |
    #  - Setups stax used by this script's notetags                            |
    #--------------------------------------------------------------------------|
    # stax are read at:
    # 1. RPG::State
    #    - (@state_triggers[$1.downcase.to_sym] ||= []).push(
    #      [$2.downcase, $3.downcase]) in load_state_triggers_notes
    # stax are used at:
    # 1. Game_BattlerBase
    #    - }.collect! { |trigger| st.send(trigger[1], self, state) }.flatten! in
    #      state_trigger_features
    # 2. Game_Battler
    #    - st.send(trigger[1], self) if st.send(trigger[0], self) in
    #      exec_state_triggers
    # stax are strings of names of methods under DoubleX_RMVXA::State_Triggers
    # stax names can only use alphanumeric characters and can't use uppercase
    # letters
    # battler is the battler calling the stax
    # state is the state using the stax
    # If the timing using the stax is while, the stax must return an array of
    # RPG::BaseItem::Feature
    # You can refer to Game_BattlerBase and RPG::BaseItem::Feature for more info
    # The below stax are examples added to help you set your stax
    # You can freely use, rewrite and/or delete these examples

    # Sets the state trigger action as what Special Effect Escape does
    # This stax's not supposed to work with the timing while as it doesn't
    # return an array of RPG::BaseItem::Feature
    def self.sta1(battler, state)
      battler.hide
    end

    # Sets the state trigger action as calling common event with id
    # common_event_id
    # This stax's not supposed to work with the timing while as it doesn't
    # return an array of RPG::BaseItem::Feature
    def self.sta2(battler, state)
      $game_temp.reserve_common_event(common_event_id)
    end

    # Sets the state trigger action as executing damage equal to the value of
    # game variable with id x to self with type equal to that of skill with id
    # equal to y
    # This stax's not supposed to work with the timing while as it doesn't
    # return an array of RPG::BaseItem::Feature
    def self.sta3(battler, state)
      battler.result.clear
      battler.result.make_damage($game_variables[x], $data_skills[y])
      battler.execute_damage(battler)
    end

    # Sets the state trigger action as multiplying the battler's atk by x * 100%
    # This stax's supposed to work with the timing while as it returns an array
    # of RPG::BaseItem::Feature
    def self.sta4(battler, state)
      [RPG::BaseItem::Feature.new(21, 2, x)]
    end

    # Adds new stax here


  end # State_Triggers

end # DoubleX_RMVXA

#==============================================================================|
#  ** Script Implementations                                                   |
#     You need not edit this part as it's about how this script works          |
#------------------------------------------------------------------------------|
#  * Script Support Info:                                                      |
#    1. Prerequisites                                                          |
#       - Some RGSS3 scripting proficiency to fully comprehend this script     |
#    2. Method documentation                                                   |
#       - The 1st part describes why this method's rewritten/aliased for       |
#         rewritten/aliased methods or what the method does for new methods    |
#       - The 2nd part describes what the arguments of the method are          |
#       - The 3rd part informs which version rewritten, aliased or created this|
#         method                                                               |
#       - The 4th part informs whether the method's rewritten or new           |
#       - The 5th part informs whether the method's a real or potential hotspot|
#       - The 6th part describes how this method works for new methods only,   |
#         and describes the parts added, removed or rewritten for rewritten or |
#         aliased methods only                                                 |
#       Example:                                                               |
# #--------------------------------------------------------------------------| |
# #  Why rewrite/alias/What this method does                                 | |
# #--------------------------------------------------------------------------| |
# # *argv: What these variables are                                            |
# # &argb: What this block is                                                  |
# def def_name(*argv, &argb) # Version X+; Rewrite/New; Hotspot                |
#   # Added/Removed/Rewritten to do something/How this method works            |
#   def_name_code                                                              |
#   #                                                                          |
# end # def_name                                                               |
#------------------------------------------------------------------------------|

class << DataManager # Edit

  alias load_database_state_triggers load_database
  def load_database(*argv, &argb)
    load_database_state_triggers(*argv, &argb)
    $data_states.each { |obj| obj.load_state_triggers_notes if obj } # Added
  end # load_database

end # DataManager

class RPG::State < RPG::BaseItem # Edit

  #----------------------------------------------------------------------------|
  #  New public instance variable                                              |
  #----------------------------------------------------------------------------|
  attr_accessor :state_triggers # The storage of all state trigger notetags

  def load_state_triggers_notes
    # Stores all timing, stcx and stax triples from matching lines sequentially
    @state_triggers = {}
    @note.split(/[\r\n]+/).each { |line|
      next unless line =~ /< *(\w+) +state +trigger *: *(\w+) *, *(\w+) *>/i
      (@state_triggers[$1.downcase.to_sym] ||= []).push(
      [$2.downcase.to_sym, $3.downcase.to_sym])
    }
    #
  end # load_state_triggers_notes

end # RPG::State

class Game_BattlerBase # Edit

  alias all_features_state_triggers all_features
  def all_features(*argv, &argb) # v1.03a+
    # Rewritten to use features returned by stax for states meeting any stcx
    states.inject([]) {|r, obj|
      r + state_trigger_features(obj, :while)
    } + all_features_state_triggers(*argv, &argb)
    #
  end # all_features

  alias erase_state_triggers erase_state
  def erase_state(state_id, &argb)
    # Added to store the state existence flag right before it's erased
    trigger = @states.include?(state_id)
    #
    erase_state_triggers(state_id, &argb)
    # Added to trigger the remove actions when the remove conditions are met
    exec_state_triggers(state_id, :remove) if trigger
    #
  end # erase_state

  # state: The state having its features returned by stax collected
  # timing: The timing of the state collecting features returned by stax
  def state_trigger_features(state, timing) # v1.03a+
    return [] unless triggers = state.state_triggers[timing]
    st = DoubleX_RMVXA::State_Triggers
    # Collects all features returned by stax meeting stcx with timing timing
    triggers.select { |trigger|
      st.send(trigger[0], self, state)
    }.collect! { |trigger| st.send(trigger[1], self, state) }.flatten!
    #
  end # state_trigger_features

end # Game_BattlerBase

class Game_Battler < Game_BattlerBase # Edit

  alias clear_states_triggers clear_states
  def clear_states(*argv, &argb)
    # Added to store the state array right before it's cleared
    last_states = @states
    #
    clear_states_triggers(*argv, &argb)
    # Added to trigger the remove actions when the remove conditions are met
    return unless last_states
    last_states.each { |state_id| exec_state_triggers(state_id, :remove) }
    #
  end # clear_states

  alias reset_state_counts_state_triggers reset_state_counts
  def reset_state_counts(state_id, &argb)
    reset_state_counts_state_triggers(state_id, &argb)
    # Added to trigger the add actions when the add conditions are met
    exec_state_triggers(state_id, :add) if @states.include?(state_id)
    #
  end # reset_state_counts

  alias update_state_turns_state_triggers update_state_turns
  def update_state_turns(*argv, &argb)
    update_state_turns_state_triggers(*argv, &argb)
    # Added to trigger the turn actions when the turn conditions are met
    @states.each { |state_id| exec_state_triggers(state_id, :turn) }
    #
  end # update_state_turns

  #----------------------------------------------------------------------------|
  #  Triggers each state action when each respective condition's met           |
  #----------------------------------------------------------------------------|
  # state_id: The id of the state triggering its actions
  # timing: The timing of the state triggering its actions
  def exec_state_triggers(state_id, timing) # New
    # Evaluates each stcx to see if its corresponding stax should be evaluated
    state = $data_states[state_id]
    return unless triggers = state.state_triggers[timing]
    st = DoubleX_RMVXA::State_Triggers
    triggers.each { |trigger|
      st.send(trigger[1], self, state) if st.send(trigger[0], self, state)
    }
    #
  end # exec_state_triggers

end # Game_Battler

#------------------------------------------------------------------------------|

#==============================================================================|