[VXA Script] DoubleX RMVXA Linked Battlers

"script"
Code:
#==============================================================================|

#  ** Script Info                                                              |

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

#  * Script Name                                                               |

#    DoubleX RMVXA Linked Battlers                                             |

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

#  * Functions                                                                 |

#    Lets users set some states to make their owners share some stats together |

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

#  * 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. Some 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://pastebin.com/bfCuAkKT                                           |

#    Mentioned Patreon Supporters:                                            |

#    https://www.patreon.com/posts/71738797                                    |

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

#  * Authors                                                                   |

#    DoubleX                                                                   |

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

#  * Changelog                                                                 |

#    v1.00b(GMT 0400 8-11-2015):                                               |

#    1. Notetag values are now symbols of methods in the configuration regions |

#    2. This script doesn't need DoubleX RMVXA Linked Battlers Compatibility to|

#       be compatible with all its addressed scripts                           |

#    3. Further improved this script's compatibility, efficiency and simplicity|

#    v1.00a(GMT 1500 7-8-2015):                                                |

#    1. 1st version of this script finished                                    |

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

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

#  ** Notetag Info                                                             |

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

#  * State Notetags:                                                           |

#    1. <linked battlers: lbcx, lbsx, lbwx>                                    |

#       - Sets the owners of this state meeting lbcx to share stats included in|

#         lbsx with weight lbwx applied to each of them when any included stat |

#         of any included battler changes                                      |

#       - Only the 1st applicable notetag of the state with the highest        |

#         priority will be applied to the stat change of the linked battler    |

#       - If a linked battler can't take all of that battler's share due to    |

#         hitting the minimum or maximum stat value, thost not being taken by  |

#         that battler will be shared by the rest of the linked battlers also  |

#       - The battler having a stat to be changed is the last linked battler   |

#         taking that battler's share                                          |

#       - lbcx can be set in Linked Battler Condition Notetag Values           |

#       - lbsx can be set in Linked Battler Stat Notetag Values                |

#       - lbwx can be set in Linked Battler Weight Notetag Values              |

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

($doublex_rmvxa ||= {})[:Linked_Battlers] = "v1.00b"

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

#  ** Script Configurations                                                    |

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

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

module DoubleX_RMVXA

  module Linked_Battlers

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

    #  Linked Battler Condition Notetag Values                                 |

    #  - Setups lbcx used by <linked battlers: lbcx, lbsx, lbwx>               |

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

    # lbcx are read at:

    # 1. RPG::State

    #    - @linked_battlers << [$1.downcase.to_sym, $2.downcase.to_sym, 

    #      $3.downcase.to_sym] in load_linked_battlers_notes

    # lbcx are used at:

    # 1. Game_BattlerBase

    #    - mem.state?(state_id) && lb.send(cond, mem, self) in

    #      get_linked_battlers

    # lbcx are strings of names of methods under DoubleX_RMVXA::Linked_Battlers

    # lbcx names can only use alphanumeric characters and can't use uppercase

    # letters

    # The battler having a stat to be changed can be referenced by target

    # Each of the rest of the linked battlers can be referenced by battler

    # The below lbcx are examples added to help you set your lbcx

    # You can freely use, rewrite and/or delete these examples

    # Sets the linked battler condition to include all linked battlers

    def self.lbc1(battler, target)

      true

    end

    # Sets the linked battler condition to include all and no linked battlers if

    # switch with id x is on and off respectively

    def self.lbc2(battler, target)

      $game_switches[x]

    end

    # Sets the linked battler condition to include all linked battlers that are

    # opponents of the battler having a stat to be changed

    def self.lbc3(battler, target)

      target.opposite?(battler)

    end

    # Adds new lbcx here

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

    #  Linked Battler Stat Notetag Values                                      |

    #  - Setups lbsx used by <linked battlers: lbcx, lbsx, lbwx>               |

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

    # lbsx are read at:

    # 1. RPG::State

    #    - @linked_battlers << [$1.downcase.to_sym, $2.downcase.to_sym, 

    #      $3.downcase.to_sym] in load_linked_battlers_notes

    # lbsx are used at:

    # 1. Game_BattlerBase

    #    - return [l_b, state_id] if lb.send(l_b[1], self).include?(stat) in

    #      linked_battler_state_id

    # lbsx are strings of names of methods under DoubleX_RMVXA::Linked_Battlers

    # lbsx names can only use alphanumeric characters and can't use uppercase

    # letters

    # The battler having a stat to be changed can be referenced by battler

    # It must return an array, which should include strings of a getter method

    # of each stat to be included

    # The below lbsx are examples added to help you set your lbsx

    # You can freely use, rewrite and/or delete these examples

    # Sets the linked battler stat to include hp, mp and tp

    def self.lbs1(battler)

      ["hp", "mp", "tp"]

    end

    # Sets the linked battler stat to always include hp and mp, and include tp

    # only if it's displayed in battle

    def self.lbs2(battler)

      ["hp", "mp", $data_system.opt_display_tp ? "tp" : nil]

    end

    # Sets the linked battler stat to include nothing

    def self.lbs3(battler)

      []

    end

    # Adds new lbsx here

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

    #  Linked Battler Weight Notetag Values                                    |

    #  - Setups lbwx used by <linked battlers: lbcx, lbsx, lbwx>               |

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

    # lbwx are read at:

    # 1. RPG::State

    #    - @linked_battlers << [$1.downcase.to_sym, $2.downcase.to_sym, 

    #      $3.downcase.to_sym] in load_linked_battlers_notes

    # lbwx are used in methods included in LINKED_STAT

    # lbwx are strings of names of methods under DoubleX_RMVXA::Linked_Battlers

    # lbwx names can only use alphanumeric characters and can't use uppercase

    # letters

    # It must return a real number

    # The battler having a stat to be changed can be referenced by target

    # Each of the rest of the linked battlers can be referenced by battler

    # The below lbwx are examples added to help you set your lbwx

    # You can freely use, rewrite and/or delete these examples

    # Sets the linked battler weight to be the same for all linked battlers

    def self.lbw1(battler, target)

      1

    end

    # Sets the linked battler weight to be multiplied by x if the linked battler

    # is the one having a stat to be changed

    def self.lbw2(battler, target)

      battler == target ? x : 1

    end

    # Sets the linked battler weight to be 0 for all linked battlers

    def self.lbw3(battler, target)

      0

    end

    # Adds new lbwx here

    # Sets the battler methods to be used by linked battlers

    # Its keys must be the battler stat getter method string

    # Its values must be an array containing the battler stat setter method,

    # its argument list, the one being modified, and the minimum and maximum

    # value of that battler stat of each linked battler

    # The methods returning those minimum and maximum values must be referenced

    # by battler

    # Methods with name method_name will be aliased to

    # linked_battlers_method_name

    LINKED_STATS = {

      # General form:

      # [:def_class, :super_class] => {

      #   "getter" => ["setter", "args", "mod arg", "stat_min", "stat_max"]

      # }

      [:Game_BattlerBase] => {

        # General form: 

        # "getter" => ["setter", "args", "mod arg", "stat_min", "stat_max"]

        "hp" => ["hp=", "hp", "hp", "0", "battler.mhp"],

        "mp" => ["mp=", "mp", "mp", "0", "battler.mmp"],

        "tp" => ["tp=", "tp", "tp", "0", "battler.max_tp"]

        # Adds new methods here

      }

      # Adds new classes here

    }

  end # Linked_Battlers

end # DoubleX_RMVXA

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

#  ** Script Implementations                                                   |

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

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

#  * Script Support Info:                                                      |

#    1. Prerequisites                                                          |

#       - Decent 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_linked_battlers load_database

  def load_database(*argv, &argb)

    load_database_linked_battlers(*argv, &argb)

    $data_states.each { |obj| obj.load_linked_battlers_notes if obj } # Added

  end # load_database

end # DataManager

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

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

  #  New public instance variable                                              |

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

  attr_accessor :linked_battlers # An array of all linked battler notetag values

  def load_linked_battlers_notes # New

    @linked_battlers = []

    # Stores all lbcx, lbsx and lbwx triples from matching lines sequentially

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

      next unless l =~ /< *linked +battlers *: *(\w+) *, *(\w+) *, *(\w+) *>/i

      @linked_battlers << [$1.downcase.to_sym, $2.downcase.to_sym, 

      $3.downcase.to_sym]

    }

    #

  end # load_linked_battlers_notes

end # RPG::State

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

#  *  Adds helper methods used by methods used by linked battlers              |

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

class Game_BattlerBase # Edit

  # state_id: The id of the state to be included by all linked battlers

  # cond: The conditions for a linked battlers to be included

  def get_linked_battlers(state_id, cond) # New

    lb = DoubleX_RMVXA::Linked_Battlers

    ($game_party.alive_members + $game_troop.alive_members).select! { |mem|

      mem.state?(state_id) && lb.send(cond, mem, self)

    }

  end # get_linked_battlers

  # stat: The stat of a linked battler to be changed

  def linked_battler_state_id(stat) # New

    lb = DoubleX_RMVXA::Linked_Battlers

    @states.each { |state_id|

      $data_states[state_id].linked_battlers.each { |l_b|

        return [l_b, state_id] if lb.send(l_b[1], self).include?(stat)

      }

    }

    nil

  end # linked_battler_state_id

end # Game_BattlerBase

# Aliases methods used by linked battlers

DoubleX_RMVXA::Linked_Battlers::LINKED_STATS.each { |klass, defs|

  klass_def = %Q(

class #{klass[0].id2name}#{klass[1] ? " < #{klass[1].id2name}" : ""}

)

  defs.each { |get, stat|

    klass_def += %Q(

  alias linked_battlers_#{stat[0]} #{stat[0]}

  def #{stat[0]}(#{stat[1]})

    lb_si = linked_battler_state_id("#{get}")

    return self.linked_battlers_#{stat[0]}(#{stat[1]}) unless lb_si

    get_linked_battlers_#{get}(#{stat[1]}, lb_si[0], lb_si[1])

  end

  def get_linked_battlers_#{get}(#{stat[1]}, linked_battler, state_id)

    battlers = get_linked_battlers(state_id, linked_battler[0])

    index = battlers.index(self)

    battlers[index], battlers[-1] = battlers[-1], battlers[index]

    lb = DoubleX_RMVXA::Linked_Battlers

    weights = battlers.collect { |b| lb.send(linked_battler[2], b, self) }

    return if (sum = weights.inject(:+)) == 0

    diff = #{stat[2]} - self.#{get}

    set_linked_battlers_#{get}(#{stat[1]}, battlers, diff, sum, weights)

  end

  def set_linked_battlers_#{get}(#{stat[1]}, battlers, diff, sum, weights)

    battlers.each_with_index { |battler, index|

      change = diff * (weight = weights[index]) / sum

      if (new_stat = battler.#{get} + change) < min = #{stat[3]}

        change = battler.#{get} - min

        #{stat[2]} = min

      elsif new_stat > max = #{stat[4]}

        change = max - battler.#{get}

        #{stat[2]} = max

      else

        #{stat[2]} = new_stat

      end

      battler.linked_battlers_#{stat[0]}(#{stat[1]})

      diff -= change

      sum -= weight

    }

  end

)

  }

  eval(klass_def + %Q(

end

))

}

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

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