Save-Point - DoubleX RMVXA Unison Skills/Items

DoubleX RMVXA Unison Skills/Items
Version: v1.01d
Introduction

Allows users to create unison skills or items for actors

Features

* Use of notetags(needs knowledge of notetag usage) to set specific skills or items needing specific actors and using specific parameter rules in their damage formulae in notetags in these skills or items' notebox

Video

Script
script
Code:
#==============================================================================|

#  ** DoubleX RMVXA Unison Skills/Items v1.01d                                 |

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

#  * Changelog                                                                 |

#    v1.01d(GMT 0300 21-7-2015):                                               |

#    - Increased this script's effectiveness, efficiency and flexibility       |

#    v1.01c(GMT 0900 1-6-2014):                                                |

#    - Fixed unison item not invoking common event bug                         |

#    v1.01b(GMT 0030 13-2-2014):                                               |

#    - Fixed nil @input_actor and @unison_actor bug                            |

#    v1.01a(GMT 0700 7-2-2014):                                                |

#    - Added <unison param: x> notetag                                         |

#    v1.00e(GMT 0300 26-1-2014):                                               |

#    - Fixed nil, non-skill and non-item item bug                              |

#    v1.00d(GMT 0500 24-1-2014):                                               |

#    - Fixed Action Times+ Bug                                                 |

#    v1.00c(GMT 0900 16-1-2014):                                               |

#    - Unison skills and items can only be selected by their unison actors     |

#    v1.00b(GMT 1300 15-1-2014):                                               |

#    - Fixed $game_actors[actor_id] with actor_id equals nil bug               |

#    v1.00a(GMT 0600 15-1-2014):                                               |

#    - 1st version of this script finished                                     |

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

#  * Author                                                                    |

#    DoubleX                                                                   |

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

#  * Terms of use                                                              |

#    None other than not claiming this script as created by anyone except      |

#    DoubleX or his alias                                                      |

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

#  * Prerequisites                                                             |

#    Scripts:                                                                  |

#    - none                                                                    |

#    Knowledge:                                                                |

#    - Use of notetags                                                         |

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

#  * Functions                                                                 |

#    - Allows users to create unison skills or items for actors                |

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

#  * Manual                                                                    |

#    To use this script, open the script editor and put this script into an    |

#    open slot between ▼ Materials and ▼ Main. Save to take effect.            |

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

#  * Compatibility                                                             |

#    Scripts rewriting or aliasing:                                            |

#    - load_database under DataManager                                         |

#    - param, inputable? or usable? under Game_BattlerBase                     |

#    - make_damage_value or use_item under Game_Battler                        |

#    - clear_actions or next_command under Game_Actor                          |

#    - enable? under Window_ItemList                                           |

#    - display_use_item under Window_BattleLog                                 |

#    - start, next_command, prior_command or turn_start under Scene_Battle     |

#    may have compatibility issues with this script                            |

#    Place this script above those aliasing any of these methods if possible   |

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

($imported ||= {})["DoubleX RMVXA Unison Item"] = true

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

#  * Notetag <unison item: x> for skills and items:                            |

#    x is the list of id of actors needed for the skill or item. For instance: |

#    - <unison item: 1> means actor with id 1 is required to use it            |

#    - <unison item: 4, 2> means actors with id 4 and 2 are needed to use it   |

#    All actors in list x needs to be in the battle, inputable, able to use it |

#    and pay its cost. They'll all pay the cost after using it. Only actors in |

#    list x can select it.                                                     |

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

#  * Notetag <unison rule: x> for skills and items:                            |

#    x is the rule of setting parameters used in the damage formula of the     |

#    skill or item. Notetag setting overrides the universal UNISON_PARAM_RULE. |

#    This notetag doesn't work if <unison item: x> is absent or x is nil.      |

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

#  * Notetag <unison param: x> for skills and items:                           |

#    x is the list of id of actors needed for the skill or item and stat is    |

#    parameters used in its damage formula. For instance:                      |

#    - <unison atk: 1> means atk in its damage formula uses atk of actor with  |

#      id 1                                                                    |

#    - <unison mat: 4, 2> means mat in its damage formula uses mat of actors   |

#      with id 4 and 2 under unison rule specified in <unison rule: x> notetag |

#    param can be hp, mp, tp, level, mhp, mmp, atk, def, mat, mdf, agi or luk. |

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

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

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

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

module DoubleX_RMVXA

  module Unison_Item

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

#  * SHOW_UNISON_ACTOR, default = true                                         |

#    The battlelog will show all actors involved in the unison skills or items |

#    instead of only the one invoking them if SHOW_UNISON_ACTOR is true.       |

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

  SHOW_UNISON_ACTOR = true

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

#  * UNISON_PARAM_RULE, default = 2                                            |

#    Each parameter in the damage formula of the unison skills or items used   |

#    will be altered by one of the rules below if there's no working notetag:  |

#    0 - No changes will take place                                            |

#    1 - Its minimum among all actors involved in the unison skills or items   |

#        used will be used in their damage formulae                            |

#    2 - Its average among all actors involved in the unison skills or items   |

#        used will be used in their damage formulae                            |

#    3 - Its maximum among all actors involved in the unison skills or items   |

#        used will be used in their damage formulae                            |

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

  UNISON_PARAM_RULE = 2

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

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

#  ** You need not edit this part as it's about how this script works          |

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

    UNISON_PARAM_0 = /<(?:UNISON_PARAM_0|unison mhp):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_1 = /<(?:UNISON_PARAM_1|unison mmp):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_2 = /<(?:UNISON_PARAM_2|unison atk):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_3 = /<(?:UNISON_PARAM_3|unison def):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_4 = /<(?:UNISON_PARAM_4|unison mat):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_5 = /<(?:UNISON_PARAM_5|unison mdf):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_6 = /<(?:UNISON_PARAM_6|unison agi):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_7 = /<(?:UNISON_PARAM_7|unison luk):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_hp = /<(?:UNISON_PARAM_hp|unison hp):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_mp = /<(?:UNISON_PARAM_mp|unison mp):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_tp = /<(?:UNISON_PARAM_tp|unison tp):[ ](\d+(?:\s*,\s*\d+)*)>/i

    UNISON_PARAM_level = /<(?:UNISON_PARAM_level|unison level):[ ](\d+(?:\s*,\s*\d+)*)>/i

  end # Unison_Item

end # DoubleX_RMVXA

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

#  * Edit module: DataManager                                                  |

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

class << DataManager

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

  #  Alias method: load_database                                               |

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

  alias load_database_unison_item load_database

  def load_database

    load_database_unison_item

    # Added to load unison notetags

    load_notetags_unison_item

    #

  end # load_database

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

  #  New method: load_notetags_unison_item                                     |

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

  def load_notetags_unison_item

    [$data_skills, $data_items].each { |data|

      data.each { |obj| obj.load_notetags_unison_item if obj }

    }

  end # load_notetags_unison_item

end # DataManager

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

#  * Edit class: RPG::UsableItem                                               |

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

class RPG::UsableItem < RPG::BaseItem

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

  #  New public instance variables                                             |

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

  attr_accessor :unison_item

  attr_accessor :unison_actor_id

  attr_accessor :unison_rule

  [0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each { |param|

    eval("attr_accessor :unison_param_#{param = param.to_s}")

    eval("attr_accessor :unison_param_#{param}_id")

  }

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

  #  New method: load_notetags_unison_item                                     |

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

  def load_notetags_unison_item

    @unison_item = false

    @unison_actor_id = []

    @unison_rule = (ui = DoubleX_RMVXA::Unison_Item)::UNISON_PARAM_RULE

    [0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each { |param|

      eval("@unison_param_#{param = param.to_s} = false")

      eval("@unison_param_#{param}_id = []")

    }

    @note.split(/[\r\n]+/).each { |line|

      case line

      when /<(?:UNISON_ITEM|unison item):[ ](\d+(?:\s*,\s*\d+)*)>/i

        $1.scan(/\d+/).each { |n| @unison_actor_id << n.to_i if n.to_i > 0 }

        @unison_item ||= @unison_actor_id.size > 0

      when /<(?:UNISON_RULE|unison rule):[ ]*(\d+)>/i

        @unison_rule = $1.to_i if @unison_item

      else

        [0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each { |param|

          case line

          when eval("ui::UNISON_PARAM_#{param = param.to_s}")

            $1.scan(/\d+/).each { |num|

              eval("@unison_param_#{param}_id.push(num.to_i)") if num.to_i > 0

            }

            eval("@unison_param_#{param} = true") if 

            eval("@unison_param_#{param}_id.size > 0")

          end

        }

      end

    }

  end # load_notetags_unison_item

end # RPG::UsableItem

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

#  * Edit class: Game_BattlerBase                                              |

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

class Game_BattlerBase

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

  #  Alias method: param                                                       |

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

  alias param_unison_item param

  def param(param_id)

    # Rewritten to return unison param when it's set

    @unison_param_set ? @unison_param[param_id] : param_unison_item(param_id)

    #

  end # param

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

  #  Alias method: inputable?                                                  |

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

  alias inputable_unison_item? inputable?

  def inputable?

    # Rewritten to check if at least 1 action slot isn't reserved

    return false unless inputable_unison_item?

    return true unless SceneManager.scene_is?(Scene_Battle) && actor?

    @unison_inputs < @actions.size

    #

  end # inputable?

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

  #  Alias method: usable?                                                     |

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

  alias usable_unison_item? usable?

  def usable?(item)

    # Rewritten to check if all unison actors can use the unison skill/item

    unless actor? && item && item.is_a?(RPG::UsableItem) && item.unison_item

      return usable_unison_item?(item)

    end

    return false unless item.unison_actor_id.include?(id)

    return false unless usable_unison_item?(item)

    return unison_skill_usable?(item) if item.is_a?(RPG::Skill)

    return unison_item_usable?(item) if item.is_a?(RPG::Item)

    false

    #

  end # usable?

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

  #  New method: unison_skill_usable?                                          |

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

  def unison_skill_usable?(item)

    battle = SceneManager.scene_is?(Scene_Battle)

    (item.unison_actor_id - [id]).each { |actor_id|

      actor = $game_actors[actor_id]

      return false unless actor.battle_member? && actor.inputable?

      return false if battle && actor.actions.select { |a| a.item }.size >= 

      actor.actions.size - actor.unison_inputs

      return false unless actor.skill_conditions_met?(item)

      return false unless actor.skills.any? { |s| s == $data_skills[item.id] }

    }

    true

  end # unison_skill_usable?

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

  #  New method: unison_item_usable?                                           |

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

  def unison_item_usable?(item)

    return false unless item_conditions_met?(item)

    (item.unison_actor_id - [id]).each { |actor_id|

      actor = $game_actors[actor_id]

      return false unless actor.battle_member? && actor.inputable?

    }

    true

  end # unison_item_usable?

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

  #  New method: unison_param_set                                              |

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

  def unison_param_set(item)

    @unison_param = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

    [0, 1, 2, 3, 4, 5, 6, 7, "hp", "mp", "tp", "level"].each_with_index { |param_id, i|

      if item.send("unison_param_#{param_id.to_s}".to_sym)

        unison_param_actor = item.send("unison_param_#{param_id.to_s}_id".to_sym)

      else

        unison_param_actor = item.unison_actor_id

      end

      unison_param_rule(item, param_id, i, unison_param_actor)

    }

    @unison_level = @unison_param[11]

    @unison_param_set = true

  end # unison_param_set

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

  #  New method: unison_param_rule                                             |

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

  def unison_param_rule(item, param_id, i, unison_param_actor)

    case item.unison_rule

    when 1

      if param_id.is_a?(Numeric)

        @unison_param[i] = param_max(param_id)

      elsif param_id == "hp"

        @unison_param[8] = param_max(0)

      elsif param_id == "mp"

        @unison_param[9] = param_max(1)

      elsif param_id == "tp"

        @unison_param[10] = max_tp

      else

        @unison_param[11] = max_level

      end

      unison_param_min_max(param_id, i, unison_param_actor, :min)

    when 2

      unison_param_actor.each { |actor_id|

        if param_id.is_a?(Numeric)

          @unison_param[i] += $game_actors[actor_id].param(i)

        else

          @unison_param[i] += $game_actors[actor_id].send(param_id.to_s.to_sym)

        end

      }

      @unison_param[i] /= unison_param_actor.size

    when 3

      unison_param_min_max(param_id, i, unison_param_actor, :max)

    else

      return unison_param_clear

    end

  end # unison_param_rule

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

  #  New method: unison_param_min_max                                          |

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

  def unison_param_min_max(param_id, i, unison_param_actor, sym)

    unison_param_actor.each { |actor_id|

      if param_id.is_a?(Numeric)

        @unison_param[i] = [@unison_param[i], $game_actors[actor_id].param(i)].send(sym)

      else

        @unison_param[i] = [@unison_param[i], 

        $game_actors[actor_id].send(param_id.to_s.to_sym)].send(sym)

      end

    }

  end # unison_param_min_max

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

  #  New method: unison_param_clear                                            |

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

  def unison_param_clear

    @unison_level = nil

    @unison_param_set = false

  end # unison_param_clear

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

  #  (v1.01a+)New method: hp                                                   |

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

  def hp

    @unison_param_set ? @unison_param[8] : @hp

  end # hp

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

  #  (v1.01a+)New method: mp                                                   |

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

  def mp

    @unison_param_set ? @unison_param[9] : @mp

  end # mp

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

  #  (v1.01a+)New method: tp                                                   |

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

  def tp

    @unison_param_set ? @unison_param[10] : @tp

  end # tp

end # Game_BattlerBase

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

#  * Edit class: Game_Battler                                                  |

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

class Game_Battler < Game_BattlerBase

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

  #  Alias method: make_damage_value                                           |

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

  alias make_damage_value_unison_item make_damage_value

  def make_damage_value(user, item)

    # Added to set the params of the user as the unison version

    unison = user.actor? && item.unison_item && item.unison_rule > 0

    user.unison_param_set(item) if unison

    #

    make_damage_value_unison_item(user, item)

    # Added to reset the params of the user to the default

    user.unison_param_clear if unison

    #

  end # make_damage_value

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

  #  Alias method: use_item                                                    |

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

  alias use_item_unison_item use_item

  def use_item(item)

    # Rewritten to pay unison skill cost

    unless item.is_a?(RPG::Skill) && item.unison_item

      return use_item_unison_item(item)

    end

    item.unison_actor_id.each { |a_id| $game_actors[a_id].pay_skill_cost(item) }

    item.effects.each { |effect| item_global_effect_apply(effect) }

    #

  end # use_item

end # Game_Battler

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

#  * Edit class: Game_Actor                                                    |

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

class Game_Actor < Game_Battler

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

  #  New public instance variables                                             |

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

  attr_accessor :unison_inputs

  attr_writer :unison_level

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

  #  (v1.01d+)Alias method: setup                                              |

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

  alias setup_unison_item setup

  def setup(actor_id)

    setup_unison_item(actor_id)

    # Added to initialize the number of reserved action slots

    @unison_inputs = 0

    #

  end # setup

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

  #  (v1.00d+)Alias method: clear_actions                                      |

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

  alias clear_actions_unison_item clear_actions

  def clear_actions

    clear_actions_unison_item

    # Added to reset the number of reserved action slots

    @unison_inputs = 0

    #

  end # clear_actions

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

  #  (v1.01d+)Alias method: next_command                                       |

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

  alias next_command_unison_item next_command

  def next_command

    # Added to return false if the next slot is reserved for unison skill/items

    return false if @action_input_index >= @actions.size - 1 - @unison_inputs

    #

    next_command_unison_item

  end # next_command

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

  #  (v1.01a+)New method: level                                                |

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

  def level

    @unison_level || @level

  end # level

end # Game_Actor

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

#  * Edit class: Window_ItemList                                               |

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

class Window_ItemList < Window_Selectable

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

  #  (v1.00c+)Alias method: enable?                                            |

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

  alias enable_unison_item? enable?

  def enable?(item)

    # Rewritten to set disable unison items when unison conditions aren't met

    return enable_unison_item?(item) unless item.is_a?(RPG::Item) && 

    item.unison_item && SceneManager.scene_is?(Scene_Battle)

    BattleManager.actor.usable?(item)

    #

  end # enable?

end # Window_ItemList

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

#  * Edit class: Window_BattleLog                                              |

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

class Window_BattleLog < Window_Selectable

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

  #  Alias method: display_use_item                                            |

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

  alias display_use_item_unison_item display_use_item

  def display_use_item(subject, item)

    # Rewritten to display unison actors while using unison skills or items

    unless DoubleX_RMVXA::Unison_Item::SHOW_UNISON_ACTOR && item.unison_item

      return display_use_item_unison_item(subject, item)

    end

    display_unison_item(item)

    #

  end # display_use_item

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

  #  New method: display_unison_item                                           |

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

  def display_unison_item(item)

    unless item.is_a?(RPG::Skill)

      return add_text(sprintf(Vocab::UseItem, unison_actor_names(item), item.name))

    end

    add_text(unison_actor_names(item) + item.message1)

    return if item.message2.empty?

    wait

    add_text(item.message2)

  end # display_unison_item

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

  #  New method: unison_actor_names                                            |

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

  def unison_actor_names(item)

    names = ""

    size = item.unison_actor_id.size

    item.unison_actor_id.each_with_index { |actor_id, index|

      if index > 0 && index < size - 1

        names += ", "

      elsif size > 1 && index == size - 1

        names += " and "

      end

      names += $game_actors[actor_id].name

    }

    names

  end # unison_actor_names

end # Window_BattleLog

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

#  * Edit class: Scene_Battle                                                  |

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

class Scene_Battle < Scene_Base

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

  #  (v1.01d+)Alias method: start                                              |

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

  alias start_unison_item start

  def start

    start_unison_item

    # Added to initialize the unison action linkage hash

    @unison_actor_ids = {}

    #

  end # start

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

  #  Alias method: next_command                                                |

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

  alias next_command_unison_item next_command

  def next_command

    # Added to set the link of the unison action slot to the unison invokees

    add_unison_actor_ids if (actor = BattleManager.actor) && actor.input && 

    actor.input.item && actor.input.item.unison_item

    #

    next_command_unison_item

  end # next_command

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

  #  Alias method: prior_command                                               |

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

  alias prior_command_unison_item prior_command

  def prior_command

    # Added to clear the currently selected action before selecting the prior

    BattleManager.actor.input.clear if BattleManager.actor.input

    #

    prior_command_unison_item

    # Added to clear the unison action linkage and unconfirm the action

    clear_unison_actor_ids if BattleManager.actor

    #

  end # prior_command

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

  #  Alias method: turn_start                                                  |

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

  alias turn_start_unison_item turn_start

  def turn_start

    # Added to reset the links of the unison action slots to the unison invokees

    @unison_actor_ids = {}

    $game_party.alive_members.each { |mem| mem.unison_inputs = -1 }

    #

    turn_start_unison_item

  end # turn_start

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

  #  New method: add_unison_actor_ids                                          |

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

  def add_unison_actor_ids

    ids = (actor = BattleManager.actor).input.item.unison_actor_id - [actor.id]

    @unison_actor_ids[[actor.index, actor.action_input_index]] = ids

    ids.each { |id| $game_actors[id].unison_inputs += 1 }

  end # add_unison_actor_ids

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

  #  New method: clear_unison_actor_ids                                        |

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

  def clear_unison_actor_ids

    a = BattleManager.actor

    return unless ids = @unison_actor_ids[[a.index, a.action_input_index]]

    @unison_actor_ids.delete([a.index, a.action_input_index])

    ids.each { |id| $game_actors[id].unison_inputs -= 1 }

  end # clear_unison_actor_ids

end # Scene_Battle

#==============================================================================|
Instructions

Open the script editor and put this script into an open slot between Materials and Main. Save to take effect.

FAQ

None

Compatibility

Scripts rewriting or aliasing method:

- load_database under DataManager
- param, inputable? or usable? under Game_BattlerBase
- make_damage_value or use_item under Game_Battler
- clear_actions or next_command under Game_Actor
- enable? under Window_ItemList
- display_use_item under Window_BattleLog
- start, next_command, prior_command or turn_start under Scene_Battle
may have compatibility issues with this script
Place this script above those aliasing any of these methods if possible

Credits and Thanks

None

Author's Notes

None

Terms and Conditions

None other than not claiming this script as created by anyone except DoubleX or his alias
Updates
v1.01d(GMT 0300 21-7-2015):
- Increased this script's effectiveness, efficiency and flexibility