//==============================================================================
// dsPassiveSkill.js
// Copyright (c) 2015 - 2019 DOURAKU
// Released under the MIT License.
// http://opensource.org/licenses/mit-license.php
//==============================================================================

/*:
 * @plugindesc パッシブスキルを実装するプラグイン ver1.12.0
 * @author 道楽
 *
 * @param Show Battle
 * @desc パッシブスキルを戦闘中に表示するか
 * (true なら表示する / false なら表示しない)
 * @default true
 * @type boolean
 *
 * @param Show Battle Switch ID
 * @desc 戦闘中のパッシブスキル表示を制御するスイッチのＩＤ
 * (0なら「Show Battle」の設定に従う)
 * @default 0
 * @type number
 *
 * @help
 * このプラグインは以下のメモタグの設定ができます。
 *
 * -----------------------------------------------------------------------------
 * スキルに設定するメモタグ
 *
 * --------
 * ・装備できる武器の種類を追加(Equip Weapon)
 * <passiveEWPN[武器タイプ]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *
 * --------
 * ・装備できる防具の種類を追加(Equip Armor)
 * <passiveEARM[防具タイプ]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *
 * --------
 * ・特定の通常能力値をアップ(Parameter Boost)
 * <passivePBST[能力値番号]:[上昇量(%)]>
 *  [能力値番号] - 上昇させる通常能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - ＨＰ
 *                 1 - ＭＰ
 *                 2 - 攻撃力
 *                 3 - 防御力
 *                 4 - 魔法力
 *                 5 - 魔法防御
 *                 6 - 敏捷性
 *                 7 - 運
 *  [上昇量(%)]  - 能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *                 装備なし状態の能力値に対しての倍率がかかる。
 *
 * --------
 * ・一定の条件下において、特定の通常能力値をアップ(Parameter Boost Ex)
 * <passivePBSTEX[能力値番号]:[上昇量(%)],[参照する条件],[判定する値]>
 *  [能力値番号]   - passivePBST参照
 *  [上昇量(%)]    - passivePBST参照
 *  [参照する条件] - 効果を発揮する条件を以下の中から設定する。(文字列)
 *                   HPUP - ＨＰが特定の値以上の場合に効果を発揮
 *                   HPLW - ＨＰが特定の値以下の場合に効果を発揮
 *                   MPUP - ＭＰが特定の値以上の場合に効果を発揮
 *                   MPLW - ＭＰが特定の値以下の場合に効果を発揮
 *                   TPUP - ＴＰが特定の値以上の場合に効果を発揮
 *                   TPLW - ＴＰが特定の値以下の場合に効果を発揮
 *                   STAT - 特定のステートを受けている場合に効果を発揮
 *  [判定する値]   - 条件の判定に使用するパーセンテージ。(数字)
 *                   STATの場合はステート番号。(数字)
 *
 * 例) HP50%以下で攻撃力が50%アップするスキルを作成する場合
 * <passivePBSTEX2:50%,HPUP,50>
 *
 * --------
 * ・特定の追加能力値をアップ(XParameter Boost)
 * <passiveXPBST[能力値番号]:[上昇量]>
 *  [能力値番号] - 上昇させる追加能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - 命中率
 *                 1 - 回避率
 *                 2 - 会心率
 *                 3 - 会心回避率
 *                 4 - 魔法回避率
 *                 5 - 魔法反射率
 *                 6 - 反撃率
 *                 7 - ＨＰ再生率
 *                 8 - ＭＰ再生率
 *                 9 - ＴＰ再生率
 *  [上昇量]     - 能力値の上昇量。(数字)
 *
 * --------
 * ・一定の条件下において、特定の追加能力値をアップ(XParameter Boost Ex)
 * <passiveXPBSTEX[能力値番号]:[上昇量],[参照する条件],[判定する値]>
 *  [能力値番号]   - passiveXPBST参照
 *  [上昇量]       - passiveXPBST参照
 *  [参照する条件] - passivePBSTEX参照
 *  [判定する値]   - passivePBSTEX参照
 *
 * 例) MP最大時にHPが5%再生するスキルを作成する場合
 * <passiveXPBSTEX7:5,MPUP,100>
 *
 * --------
 * ・特定の特殊能力値をアップ(SParameter Boost)
 * <passiveSPBST[能力値番号]:[上昇量]>
 *  [能力値番号] - 上昇させる特殊能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - 狙われ率
 *                 1 - 防御効果率
 *                 2 - 回復効果率
 *                 3 - 薬の知識率
 *                 4 - ＭＰ消費率
 *                 5 - ＴＰチャージ率
 *                 6 - 物理ダメージ率
 *                 7 - 魔法ダメージ率
 *                 8 - 床ダメージ率
 *                 9 - 経験値獲得率
 *  [上昇量]     - 能力値の上昇量。(数字)
 *
 * --------
 * ・一定の条件下において、特定の追加能力値をアップ(XParameter Boost Ex)
 * <passiveSPBSTEX[能力値番号]:[上昇量],[参照する条件],[判定する値]>
 *  [能力値番号]   - passiveSPBST参照
 *  [上昇量]       - passiveSPBST参照
 *  [参照する条件] - passivePBSTEX参照
 *  [判定する値]   - passivePBSTEX参照
 *
 * 例) TPが50%以上の時に狙われやすくするスキルを作成する場合
 * <passiveSPBSTEX0:50,TPUP,50>
 *
 * --------
 * ※更新に伴い非推奨 (passivePBSTEXを使用してください)
 * ・一定のＨＰ以下の場合のみ特定の通常能力値をアップ(Indomitable)
 * <passiveINDM[能力値番号]:[HP残量率],[上昇量(%)]>
 *  [能力値番号] - passivePBST参照
 *  [HP残量率]   - 効果が発揮されるHPの残量率を%で設定する。(数字)
 *  [上昇量(%)]  - 能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *                 装備なし状態の能力値に対しての倍率がかかる。
 *
 * --------
 * ※更新に伴い非推奨 (passiveXPBSTEXを使用してください)
 * ・一定のＨＰ以下の場合のみ特定の追加能力値をアップ(XIndomitable)
 * <passiveXINDM[能力値番号]:[HP残量率],[上昇量]>
 *  [能力値番号] - passiveXPBST参照
 *  [HP残量率]   - 効果が発揮されるHPの残量率を%で設定する。(数字)
 *  [上昇量]     - 能力値の上昇量。(数字)
 *
 * --------
 * ※更新に伴い非推奨 (passiveSPBSTEXを使用してください)
 * ・一定のＨＰ以下の場合のみ特定の特殊能力値をアップ(SIndomitable)
 * <passiveSINDM[能力値番号]:[HP残量率],[上昇量]>
 *  [能力値番号] - passiveSPBST参照
 *  [HP残量率]   - 効果が発揮されるHPの残量率を%で設定する。(数字)
 *  [上昇量]     - 能力値の上昇量。(数字)
 *
 * --------
 * ・属性有効度を設定(Element Rate)
 * <passiveELEM[属性番号]:[倍率]>
 *  [属性番号] - 有効度を設定する属性の番号を2桁の数値で設定する。(数字)
 *  [有効度]   - 有効度を表すパーセンテージ。(数字)
 *               職業等で設定されている属性有効度に乗算されます。
 *
 * --------
 * ・属性有効度を設定の加算バージョン(Element Rate Add Ver)
 * <passiveELEM_ADD[属性番号]:[倍率]>
 *  [属性番号] - 有効度を設定する属性の番号を2桁の数値で設定する。(数字)
 *  [有効度]   - 有効度を表すパーセンテージ。(数字)
 *               職業等で設定されている属性有効度に加算されます。
 * 
 * --------
 * ・ステート有効度を設定(State Rate)
 * <passiveSTAT[ステート番号]:[有効度]>
 *  [ステート番号] - 耐性を上昇させるステートの番号を4桁の数値で設定する。(数字)
 *  [有効度]       - 有効度を表すパーセンテージ。(数字)
 *                   職業等で設定されているステート有効度に乗算されます。
 *
 * --------
 * ・ステート有効度を設定の加算バージョン(State Rate Add Ver)
 * <passiveSTAT_ADD[ステート番号]:[有効度]>
 *  [ステート番号] - 耐性を上昇させるステートの番号を4桁の数値で設定する。(数字)
 *  [有効度]       - 有効度を表すパーセンテージ。(数字)
 *                   職業等で設定されているステート有効度に加算されます。
 *
 * --------
 * ・無効化できるステートを追加(State Regist)
 * <passiveSTREG[ステート番号]>
 *  [ステート番号] - 無効化できるステートの番号を4桁の数値で設定する。(数字)
 *
 * --------
 * ・攻撃時ステートを設定(Attack State)
 * <passiveATKST[ステート番号]:[付与率]>
 *  [ステート番号] - 攻撃時に付与するステートの番号を4桁の数値で設定する。(数字)
 *  [付与率]       - 付与率を表すパーセンテージ。(数字)
 *                   職業等で設定されているステート付与率に加算されます。
 *
 * --------
 * ・スキルタイプ追加(Add Skill Type)
 * <passiveAST[スキルタイプ番号]>
 *  [スキルタイプ番号] - スキルタイプの番号を2桁の数値で設定する。(数字)
 *
 * --------
 * ・武器装備時の通常能力値の上昇量をアップ(Weapon Mastery)
 * <passiveWPNM[武器タイプ]:[上昇量(%)]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *  [上昇量(%)]  - 装備時の能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *
 * --------
 * ・武器装備時の追加能力値の上昇量をアップ(Weapon MasteryX)
 * <passiveWPNMX[武器タイプ]:[上昇量(%)]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *  [上昇量(%)]  - 装備時の能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *
 * --------
 * ・武器装備時の特殊能力値の上昇量をアップ(Weapon MasteryS)
 * <passiveWPNMS[武器タイプ]:[上昇量(%)]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *  [上昇量(%)]  - 装備時の能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *                 (倍率は100%を基準として計算されます)
 *
 * --------
 * ・武器装備時に特定の通常能力値をアップ(Weapon Parameter Boost)
 * <passiveWPBST[武器タイプ]_[能力値番号]:[上昇量]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *  [能力値番号] - 上昇させる通常能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - ＨＰ
 *                 1 - ＭＰ
 *                 2 - 攻撃力
 *                 3 - 防御力
 *                 4 - 魔法力
 *                 5 - 魔法防御
 *                 6 - 敏捷性
 *                 7 - 運
 *  [上昇量]     - 装備時の能力値の上昇量。(数字)
 *
 * --------
 * ・武器装備時に特定の追加能力値をアップ(Weapon XParameter Boost)
 * <passiveWXPBST[武器タイプ]_[能力値番号]:[上昇量]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *  [能力値番号] - 上昇させる追加能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - 命中率
 *                 1 - 回避率
 *                 2 - 会心率
 *                 3 - 会心回避率
 *                 4 - 魔法回避率
 *                 5 - 魔法反射率
 *                 6 - 反撃率
 *                 7 - ＨＰ再生率
 *                 8 - ＭＰ再生率
 *                 9 - ＴＰ再生率
 *  [上昇量]     - 装備時の能力値の上昇量。(数字)
 *
 * --------
 * ・武器装備時に特定の特殊能力値をアップ(Weapon SParameter Boost)
 * <passiveWSPBST[武器タイプ]_[能力値番号]:[上昇量]>
 *  [武器タイプ] - 武器タイプの番号を2桁の数値で設定する。(数字)
 *  [能力値番号] - 上昇させる特殊能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - 狙われ率
 *                 1 - 防御効果率
 *                 2 - 回復効果率
 *                 3 - 薬の知識率
 *                 4 - ＭＰ消費率
 *                 5 - ＴＰチャージ率
 *                 6 - 物理ダメージ率
 *                 7 - 魔法ダメージ率
 *                 8 - 床ダメージ率
 *                 9 - 経験値獲得率
 *  [上昇量]     - 装備時の能力値の上昇量。(数字)
 *
 * --------
 * ・防具装備時の通常能力値をアップ(Armor Mastery)
 * <passiveARMM[防具タイプ]:[上昇量(%)]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *  [上昇量(%)]  - 装備時の能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *
 * --------
 * ・防具装備時の追加能力値の上昇量をアップ(Armor MasteryX)
 * <passiveARMMX[防具タイプ]:[上昇量(%)]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *  [上昇量(%)]  - 装備時の能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *
 * --------
 * ・防具装備時の特殊能力値の上昇量をアップ(Armor MasteryS)
 * <passiveARMMS[防具タイプ]:[上昇量(%)]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *  [上昇量(%)]  - 装備時の能力値の上昇量。
 *                 %ありなら倍率、なしなら直値となる。(数字)
 *                 (倍率は100%を基準として計算されます)
 * 
 * --------
 * ・防具装備時に特定の通常能力値をアップ(Armor Parameter Boost)
 * <passiveAPBST[防具タイプ]_[能力値番号]:[上昇量]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *  [能力値番号] - 上昇させる通常能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - ＨＰ
 *                 1 - ＭＰ
 *                 2 - 攻撃力
 *                 3 - 防御力
 *                 4 - 魔法力
 *                 5 - 魔法防御
 *                 6 - 敏捷性
 *                 7 - 運
 *  [上昇量]     - 装備時の能力値の上昇量。(数字)
 *
 * --------
 * ・防具装備時に特定の追加能力値をアップ(Armor XParameter Boost)
 * <passiveAXPBST[防具タイプ]_[能力値番号]:[上昇量]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *  [能力値番号] - 上昇させる追加能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - 命中率
 *                 1 - 回避率
 *                 2 - 会心率
 *                 3 - 会心回避率
 *                 4 - 魔法回避率
 *                 5 - 魔法反射率
 *                 6 - 反撃率
 *                 7 - ＨＰ再生率
 *                 8 - ＭＰ再生率
 *                 9 - ＴＰ再生率
 *  [上昇量]     - 装備時の能力値の上昇量。(数字)
 *
 * --------
 * ・防具装備時に特定の特殊能力値をアップ(Armor SParameter Boost)
 * <passiveASPBST[防具タイプ]_[能力値番号]:[上昇量]>
 *  [防具タイプ] - 防具タイプの番号を2桁の数値で設定する。(数字)
 *  [能力値番号] - 上昇させる特殊能力値の番号を1桁の数値で設定する。(数字)
 *                 0 - 狙われ率
 *                 1 - 防御効果率
 *                 2 - 回復効果率
 *                 3 - 薬の知識率
 *                 4 - ＭＰ消費率
 *                 5 - ＴＰチャージ率
 *                 6 - 物理ダメージ率
 *                 7 - 魔法ダメージ率
 *                 8 - 床ダメージ率
 *                 9 - 経験値獲得率
 *  [上昇量]     - 装備時の能力値の上昇量。(数字)
 *
 * --------
 * ・攻撃追加回数を追加する(Attack Times Add)
 * <passiveATADD:[追加量]>
 *  [追加量] - 攻撃回数を設定する。(数字)
 *
 * --------
 * ・先制攻撃率をアップ(Preemptive)
 * <passivePREE:[上昇量]>
 *  [上昇量] - 先制攻撃率のアップ率を%で設定する。(数字)
 *
 * --------
 * ・不意打ち率をダウン(Anti Surprise)
 * <passiveASUP:[下降量]>
 *  [下降量] - 不意打ち率のダウン率を%で設定する。(数字)
 * 
 * --------
 * ・二刀流を有効にする(Dual Wield)
 * <passiveDUAL>
 *
 * --------
 * ・行動回数を追加する(Action Plus)
 * <passiveAPLUS:[追加確率]>
 *  [追加確率(%)] - 行動を追加する確率を表すパーセンテージ。(数字)
 *
 * --------
 * ・自動戦闘を有効にする(Auto Battle)
 * <passiveAUTO>
 *
 * --------
 * ・防御を有効にする(Guard)
 * <passiveGUARD>
 *
 * --------
 * ・身代わり状態にする(Substitute)
 * <passiveSUBS>
 *
 * --------
 * ・TP持ち越しを有効にする(Preserve Tp)
 * <passivePRETP>
 *
 */

var Imported = Imported || {};
Imported.dsPassiveSkill = true;

(function (exports) {
	'use strict';

	exports.Param = (function() {
		var ret = {};
		var parameters = PluginManager.parameters('dsPassiveSkill');
		ret.ShowBattle = Boolean(parameters['Show Battle'] === 'true' || false);
		ret.ShowBattleSwitchId = Number(parameters['Show Battle Switch ID']);
		return ret;
	})();

	//--------------------------------------------------------------------------
	/** Utility */
	function Utility() {}

	Utility.calcParamBoost = function(baseParam, metaData)
	{
		var ret = 0;
		var re = /([-]?\d+)(%?)/i;
		var match = re.exec(metaData);
		if ( match )
		{
			if ( match[2] === '%' )
			{
				var rate = Number(match[1]) * 0.01;
				ret = Math.floor(baseParam * rate);
			}
			else
			{
				ret = Number(match[1]);
			}
		}
		return ret;
	};

	Utility.calcXParamBoost = function(metaData)
	{
		var ret = 0;
		var re = /([-]?\d+)/i;
		var match = re.exec(metaData);
		if ( match )
		{
			ret = Number(match[1]) * 0.01;
		}
		return ret;
	};

	Utility.calcSParamBoost = function(metaData)
	{
		var ret = 0;
		var re = /([-]?\d+)/i;
		var match = re.exec(metaData);
		if ( match )
		{
			ret = Number(match[1]) * 0.01;
		}
		return ret;
	};

	Utility.calcMastery = function(baseParam, metaData)
	{
		var ret = 0;
		var re = /([-]?\d+)(%?)/i;
		var match = re.exec(metaData);
		if ( match )
		{
			if ( match[2] === '%' )
			{
				var rate = Number(match[1]) * 0.01;
				ret = Math.floor(baseParam * rate);
			}
			else
			{
				ret = Number(match[1]);
			}
		}
		return ret;
	};

	Utility.calcMasteryX = function(baseParam, metaData)
	{
		var ret = 0;
		var re = /([-]?\d+)(%?)/i;
		var match = re.exec(metaData);
		if ( match )
		{
			if ( match[2] === '%' )
			{
				var rate = Number(match[1]) * 0.01;
				ret = baseParam * rate;
			}
			else
			{
				ret = Number(match[1]);
			}
		}
		return ret;
	};

	Utility.calcMasteryS = function(baseParam, metaData)
	{
		var ret = 0;
		var re = /([-]?\d+)(%?)/i;
		var match = re.exec(metaData);
		if ( match )
		{
			if ( match[2] === '%' )
			{
				var rate = Number(match[1]) * 0.01;
				ret = (baseParam-1.0) * rate;
			}
			else
			{
				ret = Number(match[1]);
			}
		}
		return ret;
	};

	//--------------------------------------------------------------------------
	/** Game_Actor */
	var _Game_Actor_initMembers = Game_Actor.prototype.initMembers;
	Game_Actor.prototype.refreshSkillTypes = function()
	{
		_Game_Actor_initMembers.call(this);
		this._psSkillTypes = [];
	};

	Game_Actor.prototype.refreshSkillTypes = function()
	{
		this._psSkillTypes = [];
		var skillTypesMax = $dataSystem.skillTypes.length;
		for ( var ii = 1; ii < skillTypesMax; ii++ )
		{
			var tag = 'passiveAST' + ('00'+ii).slice(-2);
			var find = false;
			this.iteratePassiveSkill(tag, function(metaData) {
				find = true;
			});
			if ( find )
			{
				this._psSkillTypes.push(ii);
			}
		}
	};

	var _Game_Actor_refresh = Game_Actor.prototype.refresh;
	Game_Actor.prototype.refresh = function()
	{
		_Game_Actor_refresh.call(this);
		this.refreshSkillTypes();
	};

	var _Game_Actor_learnSkill = Game_Actor.prototype.learnSkill;
	Game_Actor.prototype.learnSkill = function(skillId)
	{
		var lastDualWield = this.isDualWield();
		_Game_Actor_learnSkill.call(this, skillId);
		if ( lastDualWield !== this.isDualWield() )
		{
			this.refresh();
		}
		this.refreshSkillTypes();
	};

	Game_Actor.prototype.iteratePassiveSkill = function(metaName, callback)
	{
		this.skills().forEach(function(skill) {
			if ( skill.meta[metaName] )
			{
				callback(skill.meta[metaName]);
			}
		});
	};

	Game_Actor.prototype.evaluateCondition = function(condition, value)
	{
		var ret = false;
		switch ( condition )
		{
		case 'HPUP': ret = (this.hpRate() >= value * 0.01) ? true : false; break;
		case 'HPLW': ret = (this.hpRate() <= value * 0.01) ? true : false; break;
		case 'MPUP': ret = (this.mpRate() >= value * 0.01) ? true : false; break;
		case 'MPLW': ret = (this.mpRate() <= value * 0.01) ? true : false; break;
		case 'TPUP': ret = (this.tpRate() >= value * 0.01) ? true : false; break;
		case 'TPLW': ret = (this.tpRate() <= value * 0.01) ? true : false; break;
		case 'STAT': ret = this.isStateAffected(value);                    break;
		}
		return ret;
	};

	Game_Actor.prototype.itemTraitsWithId = function(item, code, dataId)
	{
		return item.traits.filter(function(trait) {
			return trait.code === code && trait.dataId === dataId;
		});
	};

	Game_Actor.prototype.itemTraitsSum = function(item, code, id)
	{
		return this.itemTraitsWithId(item, code, id).reduce(function(r, trait) {
			return r + trait.value;
		}, 0);
	};

	var _Game_Actor_paramBase = Game_Actor.prototype.paramBase;
	Game_Actor.prototype.paramBaseDirect = function(paramId)
	{
		return _Game_Actor_paramBase.call(this, paramId);
	};

	Game_Actor.prototype.paramBaseBoost = function(paramId)
	{
		var baseParam = this.paramBaseDirect(paramId);
		var ret = 0;
		var tagPBST = 'passivePBST' + ('0'+paramId).slice(-1);
		this.iteratePassiveSkill(tagPBST, function(metaData) {
			ret += Utility.calcParamBoost(baseParam, metaData);
		});
		var tagPBSTEX = 'passivePBSTEX' + ('0'+paramId).slice(-1);
		this.iteratePassiveSkill(tagPBSTEX, function(metaData) {
			var splitData = metaData.split(',');
			if ( this.evaluateCondition(splitData[1], Number(splitData[2])) )
			{
				ret += Utility.calcParamBoost(baseParam, splitData[0]);
			}
		}.bind(this));
		var tagINDM = 'passiveINDM' + ('0'+paramId).slice(-1);
		this.iteratePassiveSkill(tagINDM, function(metaData) {
			var re = /(\d+)\,([-]?\d+)(%?)/i;
			var match = re.exec(metaData);
			if ( match )
			{
				if ( this.hpRate() <= Number(match[1]) * 0.01 )
				{
					if ( match[3] === '%' )
					{
						var rate = Number(match[2]) * 0.01;
						ret += Math.floor(baseParam * rate);
					}
					else
					{
						ret += Number(match[2]);
					}
				}
			}
		}.bind(this));
		return ret;
	};

	Game_Actor.prototype.paramBase = function(paramId)
	{
		var ret = this.paramBaseDirect(paramId);
		ret += this.paramBaseBoost(paramId);
		return ret;
	};

	var _Game_Actor_paramPlus = Game_Actor.prototype.paramPlus;
	Game_Actor.prototype.paramPlusDirect = function(paramId)
	{
		return _Game_Actor_paramPlus.call(this, paramId);
	};

	Game_Actor.prototype.paramPlusBoost = function(paramId)
	{
		var ret = 0;
		this.equips().forEach(function(item) {
			if ( item )
			{
				if ( DataManager.isWeapon(item) )
				{
					if ( item.params[paramId] > 0 )
					{
						var tagWPNM = 'passiveWPNM' + ('00'+item.wtypeId).slice(-2);
						this.iteratePassiveSkill(tagWPNM, function(metaData) {
							ret += Utility.calcMastery(item.params[paramId], metaData);
						});
					}
					var tagWPBST = 'passiveWPBST' + ('00'+item.wtypeId).slice(-2) + '_' + paramId;
					this.iteratePassiveSkill(tagWPBST, function(metaData) {
						ret += Number(metaData);
					});
				}
				else if ( DataManager.isArmor(item) )
				{
					if ( item.params[paramId] > 0 )
					{
						var tagARMM = 'passiveARMM' + ('00'+item.atypeId).slice(-2);
						this.iteratePassiveSkill(tagARMM, function(metaData) {
							ret += Utility.calcMastery(item.params[paramId], metaData);
						});
					}
					var tagAPBST = 'passiveAPBST' + ('00'+item.atypeId).slice(-2) + '_' + paramId;
					this.iteratePassiveSkill(tagAPBST, function(metaData) {
						ret += Number(metaData);
					});
				}
			}
		}, this);
		return ret;
	};

	Game_Actor.prototype.paramPlus = function(paramId)
	{
		var ret = this.paramPlusDirect(paramId);
		ret += this.paramPlusBoost(paramId);
		return ret;
	};

	var _Game_Actor_xparam = Game_Actor.prototype.xparam;
	Game_Actor.prototype.xparamDirect = function(xparamId)
	{
		return _Game_Actor_xparam.call(this, xparamId);
	};

	Game_Actor.prototype.xparam = function(xparamId)
	{
		var ret = this.xparamDirect(xparamId);
		var tagPBST = 'passiveXPBST' + ('0'+xparamId).slice(-1);
		this.iteratePassiveSkill(tagPBST, function(metaData) {
			ret += Utility.calcXParamBoost(metaData);
		});
		var tagPBSTEX = 'passiveXPBSTEX' + ('0'+xparamId).slice(-1);
		this.iteratePassiveSkill(tagPBSTEX, function(metaData) {
			var splitData = metaData.split(',');
			if ( this.evaluateCondition(splitData[1], Number(splitData[2])) )
			{
				ret += Utility.calcXParamBoost(splitData[0]);
			}
		}.bind(this));
		var tagINDM = 'passiveXINDM' + ('0'+xparamId).slice(-1);
		this.iteratePassiveSkill(tagINDM, function(metaData) {
			var re = /(\d+)\,([-]?\d+)/i;
			var match = re.exec(metaData);
			if ( match )
			{
				if ( this.hpRate() <= Number(match[1]) * 0.01 )
				{
					ret += Number(match[2]) * 0.01;
				}
			}
		}.bind(this));
		this.equips().forEach(function(item) {
			if ( item )
			{
				var value = this.itemTraitsSum(item, Game_BattlerBase.TRAIT_XPARAM, xparamId);
				if ( DataManager.isWeapon(item) )
				{
					if ( value > 0 )
					{
						var tagWPNMX = 'passiveWPNMX' + ('00'+item.wtypeId).slice(-2);
						this.iteratePassiveSkill(tagWPNMX, function(metaData) {
							ret += Utility.calcMasteryX(value, metaData);
						});
					}
					var tagWPBST = 'passiveWXPBST' + ('00'+item.wtypeId).slice(-2) + '_' + xparamId;
					this.iteratePassiveSkill(tagWPBST, function(metaData) {
						ret += Number(metaData) * 0.01;
					});
				}
				else if ( DataManager.isArmor(item) )
				{
					if ( value > 0 )
					{
						var tagARMMX = 'passiveARMMX' + ('00'+item.atypeId).slice(-2);
						this.iteratePassiveSkill(tagARMMX, function(metaData) {
							ret += Utility.calcMasteryX(value, metaData);
						});
					}
					var tagAPBST = 'passiveAXPBST' + ('00'+item.atypeId).slice(-2) + '_' + xparamId;
					this.iteratePassiveSkill(tagAPBST, function(metaData) {
						ret += Number(metaData) * 0.01;
					});
				}
			}
		}, this);
		return ret;
	};

	var _Game_Actor_sparam = Game_Actor.prototype.sparam;
	Game_Actor.prototype.sparamDirect = function(sparamId)
	{
		return _Game_Actor_sparam.call(this, sparamId);
	};

	Game_Actor.prototype.sparam = function(sparamId)
	{
		var ret = this.sparamDirect(sparamId);
		var tagPBST = 'passiveSPBST' + ('0'+sparamId).slice(-1);
		this.iteratePassiveSkill(tagPBST, function(metaData) {
			ret += Utility.calcSParamBoost(metaData);
		});
		var tagPBSTEX = 'passiveSPBSTEX' + ('0'+sparamId).slice(-1);
		this.iteratePassiveSkill(tagPBSTEX, function(metaData) {
			var splitData = metaData.split(',');
			if ( this.evaluateCondition(splitData[1], Number(splitData[2])) )
			{
				ret += Utility.calcSParamBoost(splitData[0]);
			}
		}.bind(this));
		var tagINDM = 'passiveSINDM' + ('0'+sparamId).slice(-1);
		this.iteratePassiveSkill(tagINDM, function(metaData) {
			var re = /(\d+)\,([-]?\d+)/i;
			var match = re.exec(metaData);
			if ( match )
			{
				if ( this.hpRate() <= Number(match[1]) * 0.01 )
				{
					ret += Number(match[2]) * 0.01;
				}
			}
		}.bind(this));
		this.equips().forEach(function(item) {
			if ( item )
			{
				var value = this.itemTraitsSum(item, Game_BattlerBase.TRAIT_SPARAM, sparamId);
				if ( DataManager.isWeapon(item) )
				{
					if ( value > 0 )
					{
						var tagWPNMS = 'passiveWPNMS' + ('00'+item.wtypeId).slice(-2);
						this.iteratePassiveSkill(tagWPNMS, function(metaData) {
							ret += Utility.calcMasteryS(value, metaData);
						});
					}
					var tagWPBST = 'passiveWSPBST' + ('00'+item.wtypeId).slice(-2) + '_' + sparamId;
					this.iteratePassiveSkill(tagWPBST, function(metaData) {
						ret += Number(metaData) * 0.01;
					});
				}
				else if ( DataManager.isArmor(item) )
				{
					if ( value > 0 )
					{
						var tagARMMS = 'passiveARMMS' + ('00'+item.atypeId).slice(-2);
						this.iteratePassiveSkill(tagARMMS, function(metaData) {
							ret += Utility.calcMasteryS(value, metaData);
						});
					}
					var tagAPBST = 'passiveASPBST' + ('00'+item.atypeId).slice(-2) + '_' + sparamId;
					this.iteratePassiveSkill(tagAPBST, function(metaData) {
						ret += Number(metaData) * 0.01;
					});
				}
			}
		}, this);
		return ret;
	};

	var _Game_Actor_elementRate = Game_Actor.prototype.elementRate;
	Game_Actor.prototype.elementRate = function(elementId)
	{
		var ret = _Game_Actor_elementRate.call(this, elementId);
		var tag = 'passiveELEM' + ('00'+elementId).slice(-2);
		this.iteratePassiveSkill(tag, function(metaData) {
			ret *= Number(metaData) * 0.01;
		});
		ret += this.addElementRate(elementId);
		return Math.max(ret, 0);
	};

	Game_Actor.prototype.addElementRate = function(elementId)
	{
		var ret = 0;
		var tag = 'passiveELEM_ADD' + ('00'+elementId).slice(-2);
		this.iteratePassiveSkill(tag, function(metaData) {
			ret += Number(metaData) * 0.01;
		});
		return ret;
	};

	var _Game_Actor_stateRate = Game_Actor.prototype.stateRate;
	Game_Actor.prototype.stateRate = function(stateId)
	{
		var ret = _Game_Actor_stateRate.call(this, stateId);
		var tag = 'passiveSTAT' + ('0000'+stateId).slice(-4);
		this.iteratePassiveSkill(tag, function(metaData) {
			ret *= Number(metaData) * 0.01;
		});
		ret += this.addStateRate(stateId);
		return Math.max(ret, 0);
	};

	Game_Actor.prototype.addStateRate = function(stateId)
	{
		var ret = 0;
		var tag = 'passiveSTAT_ADD' + ('0000'+stateId).slice(-4);
		this.iteratePassiveSkill(tag, function(metaData) {
			ret += Number(metaData) * 0.01;
		});
		return ret;
	};

	var _Game_Actor_stateResistSet = Game_Actor.prototype.stateResistSet;
	Game_Actor.prototype.stateResistSet = function()
	{
		var ret = _Game_Actor_stateResistSet.call(this);
		var num = $dataStates.length;
		for ( var ii = 1; ii < num; ii++ )
		{
			var tag = 'passiveSTREG' + ('0000'+ii).slice(-4);
			this.iteratePassiveSkill(tag, function(metaData) {
				if ( !ret.contains(ii) )
				{
					ret.push(ii);
				}
			});
		}
		return ret;
	};

	var _Game_Actor_attackStates = Game_Actor.prototype.attackStates;
	Game_Actor.prototype.attackStates = function()
	{
		var ret = _Game_Actor_attackStates.call(this);
		var num = $dataStates.length;
		for ( var ii = 1; ii < num; ii++ )
		{
			var tag = 'passiveATKST' + ('0000'+ii).slice(-4);
			this.iteratePassiveSkill(tag, function(metaData) {
				if ( !ret.contains(ii) )
				{
					ret.push(ii);
				}
			});
		}
		return ret;
	};

	var _Game_Actor_attackStatesRate = Game_Actor.prototype.attackStatesRate;
	Game_Actor.prototype.attackStatesRate = function(stateId)
	{
		var ret = _Game_Actor_attackStatesRate.call(this, stateId);
		var tag = 'passiveATKST' + ('0000'+stateId).slice(-4);
		this.iteratePassiveSkill(tag, function(metaData) {
			var re = /([-]?\d+)/i;
			var match = re.exec(metaData);
			if ( match )
			{
				ret += Number(match[1]) * 0.01;
			}
		});
		return ret;
	};

	var _Game_Actor_attackTimesAdd = Game_Actor.prototype.attackTimesAdd;
	Game_Actor.prototype.attackTimesAdd = function()
	{
		var ret = _Game_Actor_attackTimesAdd.call(this);
		var tag = 'passiveATADD';
		this.iteratePassiveSkill(tag, function(metaData) {
			ret += Number(metaData);
		});
		return ret;
	};

	var _Game_Actor_addedSkillTypes = Game_Actor.prototype.addedSkillTypes;
	Game_Actor.prototype.addedSkillTypes = function()
	{
		var ret = _Game_Actor_addedSkillTypes.call(this);
		if ( this._psSkillTypes )
		{
			this._psSkillTypes.forEach(function(stype) {
				if ( ret.indexOf(stype) < 0 )
				{
					ret.push(stype);
				}
			});
		}
		return ret;
	};

	var _Game_Actor_isEquipWtypeOk = Game_Actor.prototype.isEquipWtypeOk;
	Game_Actor.prototype.isEquipWtypeOk = function(wtypeId)
	{
		var ret = _Game_Actor_isEquipWtypeOk.call(this, wtypeId);
		var tag = 'passiveEWPN' + ('00'+wtypeId).slice(-2);
		this.iteratePassiveSkill(tag, function(metaData) {
			ret = true;
		});
		return ret;
	};

	var _Game_Actor_isEquipAtypeOk = Game_Actor.prototype.isEquipAtypeOk;
	Game_Actor.prototype.isEquipAtypeOk = function(atypeId)
	{
		var ret = _Game_Actor_isEquipAtypeOk.call(this, atypeId);
		var tag = 'passiveEARM' + ('00'+atypeId).slice(-2);
		this.iteratePassiveSkill(tag , function(metaData) {
			ret = true;
		});
		return ret;
	};

	var _Game_Actor_isDualWield = Game_Actor.prototype.isDualWield;
	Game_BattlerBase.prototype.isDualWield = function()
	{
		var ret = _Game_Actor_isDualWield.call(this);
		var tag = 'passiveDUAL';
		this.iteratePassiveSkill(tag, function(metaData) {
			ret = true;
		});
		return ret;
	};

	var _Game_Actor_actionPlusSet = Game_Actor.prototype.actionPlusSet;
	Game_Actor.prototype.actionPlusSet = function()
	{
		var ret = _Game_Actor_actionPlusSet.call(this);
		var tag = 'passiveAPLUS';
		this.iteratePassiveSkill(tag, function(metaData) {
			var re = /(\d+)/i;
			var match = re.exec(metaData);
			if ( match )
			{
				ret.push(Number(match[1]) * 0.01);
			}
		});
		return ret;
	};

	var _Game_Actor_isAutoBattle = Game_Actor.prototype.isAutoBattle;
	Game_Actor.prototype.isAutoBattle = function()
	{
		var ret = _Game_Actor_isAutoBattle.call(this);
		var tag = 'passiveAUTO';
		this.iteratePassiveSkill(tag, function(metaData) {
			ret = true;
		});
		return ret;
	};

	var _Game_Actor_isGuard = Game_Actor.prototype.isGuard;
	Game_Actor.prototype.isGuard = function()
	{
		var ret = _Game_Actor_isGuard.call(this);
		if ( this.canMove() )
		{
			var tag = 'passiveGUARD';
			this.iteratePassiveSkill(tag, function(metaData) {
				ret = true;
			});
		}
		return ret;
	};

	var _Game_Actor_isSubstitute = Game_Actor.prototype.isSubstitute;
	Game_Actor.prototype.isSubstitute = function()
	{
		var ret = _Game_Actor_isSubstitute.call(this);
		if ( this.canMove() )
		{
			var tag = 'passiveSUBS';
			this.iteratePassiveSkill(tag, function(metaData) {
				ret = true;
			});
		}
		return ret;
	};

	var _Game_Actor_isPreserveTp = Game_Actor.prototype.isPreserveTp;
	Game_Actor.prototype.isPreserveTp = function(flagId)
	{
		var ret = _Game_Actor_isPreserveTp.call(this);
		var tag = 'passivePRETP';
		this.iteratePassiveSkill(tag, function(metaData) {
			ret = true;
		});
		return ret;
	};

	//--------------------------------------------------------------------------
	/** Game_Party */
	var _Game_Party_ratePreemptive = Game_Party.prototype.ratePreemptive;
	Game_Party.prototype.ratePreemptive = function(troopAgi)
	{
		var rate = _Game_Party_ratePreemptive.call(this, troopAgi);
		this.battleMembers().some(function(actor) {
			actor.iteratePassiveSkill('passivePREE', function(metaData) {
				rate += Number(metaData) * 0.01;
			});
		});
		return rate.clamp(0.0, 1.0);
	};

	var _Game_Party_rateSurprise = Game_Party.prototype.rateSurprise;
	Game_Party.prototype.rateSurprise = function(troopAgi)
	{
		var rate = _Game_Party_rateSurprise.call(this, troopAgi);
		this.battleMembers().some(function(actor) {
			actor.iteratePassiveSkill('passiveASUP', function(metaData) {
				rate -= Number(metaData) * 0.01 * rate;
			});
		});
		return rate.clamp(0.0, 1.0);
	};

	//--------------------------------------------------------------------------
	/** Window_BattleSkill */
	var _Window_BattleSkill_includes = Window_BattleSkill.prototype.includes;
	Window_BattleSkill.prototype.includes = function(item)
	{
		if ( !this.showPassiveSkill() )
		{
			if ( item )
			{
				var re = /<passive/;
				if ( re.test(item.note) )
				{
					return false;
				}
			}
		}
		return _Window_BattleSkill_includes.call(this, item);
	};

	Window_BattleSkill.prototype.showPassiveSkill = function()
	{
		if ( exports.Param.ShowBattleSwitchId > 0 )
		{
			return $gameSwitches.value(exports.Param.ShowBattleSwitchId);
		}
		else
		{
			return exports.Param.ShowBattle;
		}
	};

}((this.dsPassiveSkill = this.dsPassiveSkill || {})));