code:
//=============================================================================
// DirectlyAttackEffect.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.1.1 2016/11/13 設定次第で、戦闘終了後にセーブできなくなる場合がある不具合を修正
// 1.1.0 2016/10/05 常時残像を有効にする設定の追加
//                  BattlerGraphicExtend.jsとの連携を強化
// 1.0.0 2016/09/01 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc DirectlyAttackEffectPlugin
 * @author triacontane
 *
 * @param Duration
 * @desc 相手の元に移動するまでに掛けるフレーム数のデフォルト値です。メモ欄で指定がないとこの値が参照されます。
 * @default 12
 *
 * @param Altitude
 * @desc 相手の元に放物線移動する際の高度のデフォルト値です。メモ欄で指定がないとこの値が参照されます。
 * @default 10
 *
 * @param ValidActor
 * @desc 直接攻撃演出をアクターに適用します。OFFにすると適用されません。
 * @default ON
 *
 * @param ValidEnemy
 * @desc 直接攻撃演出を敵キャラに適用します。OFFにすると適用されません。
 * @default ON
 *
 * @param NoAfterimage
 * @desc ONにすると残像表示が無効になります。競合やパフォーマンス対策になります。
 * @default OFF
 *
 * @param AlwaysAfterimage
 * @desc ONにすると戦闘中は常に残像が表示されます。他のプラグインとの連携がしやすくなります。
 * @default OFF
 *
 * @help スキル実行時にターゲットまで近寄ってから実行します。
 * 追加で以下の機能を実装します。
 *
 * ・放物線移動
 * ・座標直接指定移動
 * ・戦闘アニメーション表示
 * ・残像表示
 *
 * 主に競合等の理由でYEPアクションシーケンスを使用しない方向けです。
 * スキルのメモ欄に以下の通り指定してください。
 *
 * <DAE攻撃:12,10,0,0>      # 12フレーム、高度10で対象まで移動
 * <DAEAttack:12,10,0,0>    # 同上
 * <DAE帰投:18,25>          # 18フレーム、高度25で元に位置に戻る
 * <DAEReturn:18,25>        # 同上
 * <DAE姿隠し>              # 移動する際にバトラーの姿を隠します。
 * <DAEHidden>              # 同上
 * <DAE残像>                # 移動する際にバトラーの残像を表示します。
 * <DAEAfterimage>          # 同上
 * <DAE帰投なし>            # 発動後に元の位置に戻らなくなります。
 * <DAENoReturn>            # 同上
 * <DAEアニメ:1>            # 発動者にID[1]のアニメーションを再生します。
 * <DAEAnimation:1>         # 同上
 * <DAE対象者アニメ:1>      # 対象者にID[1]のアニメーションを再生します。
 * <DAETargetAnimation:1>   # 同上
 * <DAE絶対位置:320,240>    # 座標[320, 240]に移動します。
 * <DAEAbsolutePos:320,240> # 同上
 * <DAE相対位置:30,10>      # 対象者から[30, 10]の位置に移動します。
 * <DAERelativePos:30,10>   # 同上
 * <DAE自己相対位置:5,0>    # 自分自身から[5, 0]の位置に移動します。
 * <DAESelfRelativePos:5,0> # 同上
 * <DAE瞬間移動:320,240>    # 座標[320, 240]に瞬間移動します。
 * <DAETeleport:320,240>    # 同上
 * <DAEアクターのみ>        # アクターが実行したときのみ演出が有効になります。
 * <DAEActorOnly>           # 同上
 * <DAE敵キャラのみ>        # 敵キャラが実行したときのみ演出が有効になります。
 * <DAEEnemyOnly>           # 同上
 * <DAE武器:1>              # 攻撃時のモーションが「攻撃：武器タイプ[1]」になります。
 * <DAEWeapon:1>            # 同上
 * <DAEモーション:dead>     # 攻撃時のモーションが「戦闘不能」になります。
 * <DAEMotion:dead>         # 同上
 *
 * メモ欄詳細
 * <DAE攻撃:[フレーム数],[高度],[Z座標],[中心移動]>
 * 指定したフレーム数で対象まで移動してからスキルを実行します。
 * 高度を設定すると放物線移動するようになります。
 * Z座標を指定すると本来の地点より高い場所に移動します。
 * 中心移動に[1]を設定すると、相手の正面ではなく中心に移動します。
 *
 * <DAE帰投:[フレーム数],[高度],[Z座標]>
 * スキル実行後に元の位置に戻ります。
 * 指定しなかった場合、攻撃と同じフレーム数、高度で戻ります。
 * 攻撃でZ座標を指定した場合は、0を指定しないと宙に浮いたままです。
 *
 * <DAE帰投なし>
 * スキル実行後に帰投しなくなります。
 * ずっとその位置に留まるので、特殊なスキルのみ指定します。
 *
 * <DAEアニメ:[アニメーションID]>
 * 対象者にID[1]のアニメーションを再生します。
 * 再生されるタイミングは、移動開始する直前です。
 * 効果音のみのアニメーションを指定すれば、任意の効果音を再生できます。
 *
 * <DAE絶対位置:[X座標],[Y座標]>
 * 移動先がターゲットとは無関係に、画面上の指定座標になります。
 * 敵キャラが使用する場合、X座標が反転します。
 *
 * <DAE相対位置:[X座標],[Y座標]>
 * 移動先がターゲットの正面から指定した座標分ずれた位置になります。
 *
 * <DAE自己相対位置:[X座標],[Y座標]>
 * 移動先が自分自身の座標から指定した座標分ずれた位置になります。
 *
 * <DAE瞬間移動:[X座標],[Y座標]>
 * 即座に指定位置に移動してから、ターゲットへの移動を開始します。
 *
 * <DAE武器:[武器タイプID]>
 * 装備武器とは無関係に指定した武器タイプIDでスキルを実行します。
 * 武器タイプIDを指定しない（<DAE武器>）と装備武器で実行します。
 *
 * <DAEモーション:[モーション名称]>
 * スキル実行時のモーションを指定したものに変更します。
 * モーション名称は以下の通りです。(「[SV]戦闘キャラ」に準拠)
 *
 * walk     歩行
 * wait     待機
 * chant    詠唱
 * guard    防御
 * damage   ダメージ
 * evade    回避
 * thrust   攻撃(突き)
 * swing    攻撃(振り)
 * missile  攻撃(飛び道具)
 * skill    スキル
 * spell    魔法
 * item     アイテム
 * escape   逃走
 * victory  勝利
 * dying    瀕死
 * abnormal 状態異常
 * sleep    睡眠
 * dead     戦闘不能
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 直接攻撃演出プラグイン
 * @author トリアコンタン
 *
 * @param フレーム数
 * @desc 相手の元に移動するまでに掛けるフレーム数のデフォルト値です。メモ欄で指定がないとこの値が参照されます。
 * @default 12
 *
 * @param 高度
 * @desc 相手の元に放物線移動する際の高度のデフォルト値です。メモ欄で指定がないとこの値が参照されます。
 * @default 10
 *
 * @param アクターに適用
 * @desc 直接攻撃演出をアクターに適用します。OFFにすると適用されません。
 * @default ON
 *
 * @param 敵キャラに適用
 * @desc 直接攻撃演出を敵キャラに適用します。OFFにすると適用されません。
 * @default ON
 *
 * @param 残像不使用
 * @desc ONにすると残像表示が無効になります。競合やパフォーマンス対策になります。
 * @default OFF
 *
 * @param 常時残像使用
 * @desc ONにすると戦闘中は常に残像が表示されます。他のプラグインとの連携がしやすくなります。
 * @default OFF
 *
 * @help スキル実行時にターゲットまで近寄ってから実行します。
 * 追加で以下の機能を実装します。
 *
 * ・放物線移動
 * ・座標直接指定移動
 * ・戦闘アニメーション表示
 * ・残像表示
 *
 * 主に競合等の理由でYEPアクションシーケンスを使用しない方向けです。
 * スキルのメモ欄に以下の通り指定してください。
 *
 * <DAE攻撃:12,10,0,0>      # 12フレーム、高度10で対象まで移動
 * <DAEAttack:12,10,0,0>    # 同上
 * <DAE帰投:18,25>          # 18フレーム、高度25で元に位置に戻る
 * <DAEReturn:18,25>        # 同上
 * <DAE姿隠し>              # 移動する際にバトラーの姿を隠します。
 * <DAEHidden>              # 同上
 * <DAE残像>                # 移動する際にバトラーの残像を表示します。
 * <DAEAfterimage>          # 同上
 * <DAE帰投なし>            # 発動後に元の位置に戻らなくなります。
 * <DAENoReturn>            # 同上
 * <DAEアニメ:1>            # 発動者にID[1]のアニメーションを再生します。
 * <DAEAnimation:1>         # 同上
 * <DAE対象者アニメ:1>      # 対象者にID[1]のアニメーションを再生します。
 * <DAETargetAnimation:1>   # 同上
 * <DAE絶対位置:320,240>    # 座標[320, 240]に移動します。
 * <DAEAbsolutePos:320,240> # 同上
 * <DAE相対位置:30,10>      # 対象者から[30, 10]の位置に移動します。
 * <DAERelativePos:30,10>   # 同上
 * <DAE自己相対位置:5,0>    # 自分自身から[5, 0]の位置に移動します。
 * <DAESelfRelativePos:5,0> # 同上
 * <DAE瞬間移動:320,240>    # 座標[320, 240]に瞬間移動します。
 * <DAETeleport:320,240>    # 同上
 * <DAEアクターのみ>        # アクターが実行したときのみ演出が有効になります。
 * <DAEActorOnly>           # 同上
 * <DAE敵キャラのみ>        # 敵キャラが実行したときのみ演出が有効になります。
 * <DAEEnemyOnly>           # 同上
 * <DAE武器:1>              # 攻撃時のモーションが「攻撃：武器タイプ[1]」になります。
 * <DAEWeapon:1>            # 同上
 * <DAEモーション:dead>     # 攻撃時のモーションが「戦闘不能」になります。
 * <DAEMotion:dead>         # 同上
 *
 * メモ欄詳細
 * <DAE攻撃:[フレーム数],[高度],[Z座標],[中心移動]>
 * 指定したフレーム数で対象まで移動してからスキルを実行します。
 * 高度を設定すると放物線移動するようになります。
 * Z座標を指定すると本来の地点より高い場所に移動します。
 * 中心移動に[1]を設定すると、相手の正面ではなく中心に移動します。
 *
 * <DAE帰投:[フレーム数],[高度],[Z座標]>
 * スキル実行後に元の位置に戻ります。
 * 指定しなかった場合、攻撃と同じフレーム数、高度で戻ります。
 * 攻撃でZ座標を指定した場合は、0を指定しないと宙に浮いたままです。
 *
 * <DAE帰投なし>
 * スキル実行後に帰投しなくなります。
 * ずっとその位置に留まるので、特殊なスキルのみ指定します。
 *
 * <DAEアニメ:[アニメーションID]>
 * 対象者にID[1]のアニメーションを再生します。
 * 再生されるタイミングは、移動開始する直前です。
 * 効果音のみのアニメーションを指定すれば、任意の効果音を再生できます。
 *
 * <DAE絶対位置:[X座標],[Y座標]>
 * 移動先がターゲットとは無関係に、画面上の指定座標になります。
 * 敵キャラが使用する場合、X座標が反転します。
 *
 * <DAE相対位置:[X座標],[Y座標]>
 * 移動先がターゲットの正面から指定した座標分ずれた位置になります。
 *
 * <DAE自己相対位置:[X座標],[Y座標]>
 * 移動先が自分自身の座標から指定した座標分ずれた位置になります。
 *
 * <DAE瞬間移動:[X座標],[Y座標]>
 * 即座に指定位置に移動してから、ターゲットへの移動を開始します。
 *
 * <DAE武器:[武器タイプID]>
 * 装備武器とは無関係に指定した武器タイプIDでスキルを実行します。
 * 武器タイプIDを指定しない（<DAE武器>）と装備武器で実行します。
 *
 * <DAEモーション:[モーション名称]>
 * スキル実行時のモーションを指定したものに変更します。
 * モーション名称は以下の通りです。(「[SV]戦闘キャラ」に準拠)
 *
 * walk     歩行
 * wait     待機
 * chant    詠唱
 * guard    防御
 * damage   ダメージ
 * evade    回避
 * thrust   攻撃(突き)
 * swing    攻撃(振り)
 * missile  攻撃(飛び道具)
 * skill    スキル
 * spell    魔法
 * item     アイテム
 * escape   逃走
 * victory  勝利
 * dying    瀕死
 * abnormal 状態異常
 * sleep    睡眠
 * dead     戦闘不能
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    var pluginName = 'DirectlyAttackEffect';
    var metaTagPrefix = 'DAE';

    var getParamOther = function (paramNames) {
        if (!Array.isArray(paramNames)) paramNames = [paramNames];
        for (var i = 0; i < paramNames.length; i++) {
            var name = PluginManager.parameters(pluginName)[paramNames[i]];
            if (name) return name;
        }
        return null;
    };

    var getParamNumber = function (paramNames, min, max) {
        var value = getParamOther(paramNames);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        return (parseInt(value, 10) || 0).clamp(min, max);
    };

    var getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON';
    };

    var getArgNumber = function (arg, min, max) {
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        return (parseInt(convertEscapeCharacters(arg), 10) || 0).clamp(min, max);
    };

    var getArgArrayString = function (args, upperFlg) {
        var values = getArgString(args, upperFlg).split(',');
        if (values[0] === '') values = [];
        for (var i = 0; i < values.length; i++) values[i] = values[i].trim();
        return values;
    };

    var getArgArrayNumber = function (args, min, max) {
        var values = getArgArrayString(args, false);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        for (var i = 0; i < values.length; i++) values[i] = (parseInt(values[i], 10) || 0).clamp(min, max);
        return values;
    };

    var getArgArrayEval = function (args, min, max) {
        var values = getArgArrayString(args, false);
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        for (var i = 0; i < values.length; i++) values[i] = eval(values[i]).clamp(min, max);
        return values;
    };

    var getArgString = function (arg, upperFlg) {
        arg = convertEscapeCharacters(arg);
        return upperFlg ? arg.toUpperCase() : arg;
    };

    var convertEscapeCharacters = function (text) {
        if (text == null || text === true) text = '';
        var windowLayer = SceneManager._scene._windowLayer;
        return windowLayer ? windowLayer.children[0].convertEscapeCharacters(text) : text;
    };

    var getMetaValue = function (object, name) {
        var metaTagName = metaTagPrefix + (name ? name : '');
        return object.meta.hasOwnProperty(metaTagName) ? object.meta[metaTagName] : undefined;
    };

    var getMetaValues = function (object, names) {
        if (!Array.isArray(names)) return getMetaValue(object, names);
        for (var i = 0, n = names.length; i < n; i++) {
            var value = getMetaValue(object, names[i]);
            if (value !== undefined) return value;
        }
        return undefined;
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramAltitude = getParamNumber(['Altitude', '高度'], 0);
    var paramDuration = getParamNumber(['Duration', 'フレーム数'], 1);
    var paramValidActor = getParamBoolean(['ValidActor', 'アクターに適用']);
    var paramValidEnemy = getParamBoolean(['ValidEnemy', '敵キャラに適用']);
    var paramNoAfterimage = getParamBoolean(['NoAfterimage', '残像不使用']);
    var paramAlwaysAfterimage = getParamBoolean(['AlwaysAfterimage', '常時残像使用']);

    //=============================================================================
    // Game_Battler
    //  対象に接近する演出をリクエストします。
    //=============================================================================
    var _Game_Battler_initMembers = Game_Battler.prototype.initMembers;
    Game_Battler.prototype.initMembers = function () {
        _Game_Battler_initMembers.apply(this, arguments);
        this.initDirectlyAttack();
    };

    Game_Battler.prototype.initDirectlyAttack = function () {
        this._directlyAttackInfo = null;
        this._directlyReturnInfo = null;
        this._directlyAdditionalInfo = null;
    };

    Game_Battler.prototype.setDirectlyAttack = function (target, action) {
        var attackArgs = getMetaValues(action.item(), ['Attack', '攻撃']);
        if (attackArgs) {
            this._directlyAttackInfo = this.makeDirectlyInfo(target, getArgArrayNumber(attackArgs));
        } else {
            this._directlyAttackInfo = null;
        }
        var returnArgs = getMetaValues(action.item(), ['Return', '帰投']);
        if (returnArgs) {
            this._directlyReturnInfo = this.makeDirectlyInfo(target, getArgArrayNumber(returnArgs));
        } else {
            this._directlyReturnInfo = this._directlyAttackInfo;
        }
        this.setDirectlyAttackAdditionalInfo(action.item());
    };

    Game_Battler.prototype.setDirectlyAttackAdditionalInfo = function (item) {
        var info = {};
        var hidden = getMetaValues(item, ['姿隠し', 'Hidden']);
        if (hidden) info.hidden = true;
        var afterimage = getMetaValues(item, ['残像', 'Afterimage']);
        if (afterimage) info.afterimage = true;
        var absPos = getMetaValues(item, ['絶対位置', 'AbsolutePos']);
        if (absPos) info.absolutePosition = getArgArrayEval(absPos);
        var relPos = getMetaValues(item, ['相対位置', 'RelativePos']);
        if (relPos) info.relativePosition = getArgArrayEval(relPos);
        var selfRelPos = getMetaValues(item, ['自己相対位置', 'SelfRelativePos']);
        if (selfRelPos) info.selfRelativePosition = getArgArrayEval(selfRelPos);
        var telPos = getMetaValues(item, ['瞬間移動', 'Teleport']);
        if (telPos) info.teleportPosition = getArgArrayEval(telPos);
        var noReturn = getMetaValues(item, ['帰投なし', 'NoReturn']);
        if (noReturn) info.noReturn = true;
        var subjectAnimationId = getMetaValues(item, ['アニメ', 'Animation']);
        if (subjectAnimationId) info.subjectAnimationId = getArgNumber(subjectAnimationId, 1);
        var targetAnimationId = getMetaValues(item, ['対象者アニメ', 'TargetAnimation']);
        if (targetAnimationId) info.targetAnimationId = getArgNumber(targetAnimationId, 1);
        var actorOnly = getMetaValues(item, ['アクターのみ', 'ActorOnly']);
        if (actorOnly) info.actorOnly = true;
        var enemyOnly = getMetaValues(item, ['敵キャラのみ', 'EnemyOnly']);
        if (enemyOnly) info.enemyOnly = true;
        this._directlyAdditionalInfo = info;
    };

    Game_Battler.prototype.makeDirectlyInfo = function (target, args) {
        var directlyAttack = {};
        directlyAttack.target = target;
        directlyAttack.duration = args[0] !== undefined ? args[0] : paramDuration;
        directlyAttack.altitude = args[1] !== undefined ? args[1] : paramAltitude;
        directlyAttack.z = args[2] !== undefined ? args[2] : 0;
        directlyAttack.moveCenter = !!args[3];
        return directlyAttack;
    };

    Game_Battler.prototype.getDirectoryAttack = function () {
        return this._directlyAttackInfo;
    };

    Game_Battler.prototype.getDirectoryReturn = function () {
        return this._directlyReturnInfo;
    };

    Game_Battler.prototype.getDirectoryAddition = function () {
        return this._directlyAdditionalInfo;
    };

    Game_Battler.prototype.hasDirectoryAttack = function () {
        return !!this._directlyAttackInfo;
    };

    var _Game_Battler_performActionStart = Game_Battler.prototype.performActionStart;
    Game_Battler.prototype.performActionStart = function (action) {
        _Game_Battler_performActionStart.apply(this, arguments);
        if (this.hasDirectoryAttack()) {
            this._directlyAttack = true;
        }
    };

    var _Game_Battler_performActionEnd = Game_Battler.prototype.performActionEnd;
    Game_Battler.prototype.performActionEnd = function () {
        _Game_Battler_performActionEnd.apply(this, arguments);
        if (this.hasDirectoryAttack()) {
            this._directlyReturn = true;
        }
    };

    Game_Battler.prototype.isDirectlyAttackRequested = function () {
        return this._directlyAttack;
    };

    Game_Battler.prototype.isDirectlyReturnRequested = function () {
        return this._directlyReturn;
    };

    Game_Battler.prototype.resetDirectlyAttackRequest = function () {
        this._directlyAttack = false;
    };

    Game_Battler.prototype.resetDirectlyReturnRequest = function () {
        this._directlyReturn = false;
    };

    //=============================================================================
    // Game_Actor
    //  攻撃モーションをスキルごとに設定します。
    //=============================================================================
    Game_Actor.prototype.hasDirectoryAttack = function () {
        var info = this._directlyAdditionalInfo;
        return Game_Battler.prototype.hasDirectoryAttack.apply(this, arguments) &&
            ((!info.enemyOnly && paramValidActor) || info.actorOnly);
    };

    var _Game_Actor_performAction = Game_Actor.prototype.performAction;
    Game_Actor.prototype.performAction = function (action) {
        if (paramValidActor) {
            var customMotion = getMetaValues(action.item(), ['モーション', 'Motion']);
            if (customMotion) {
                this.requestMotion(getArgString(customMotion).toLowerCase());
                return;
            }
            var attackMotion = getMetaValues(action.item(), ['武器', 'Weapon']);
            if (attackMotion) {
                if (attackMotion !== true) {
                    this._motionWeapon = { wtypeId: getArgNumber(attackMotion) };
                }
                this.performAttack();
                this._motionWeapon = null;
                return;
            }
        }
        _Game_Actor_performAction.apply(this, arguments);
    };

    var _Game_Actor_weapons = Game_Actor.prototype.weapons;
    Game_Actor.prototype.weapons = function () {
        if (this._motionWeapon) {
            return [this._motionWeapon];
        } else {
            return _Game_Actor_weapons.apply(this, arguments);
        }
    };

    //=============================================================================
    // Game_Enemy
    //  直接攻撃演出の可否を判定します。
    //=============================================================================
    Game_Enemy.prototype.hasDirectoryAttack = function () {
        var info = this._directlyAdditionalInfo;
        return Game_Battler.prototype.hasDirectoryAttack.apply(this, arguments) &&
            ((!info.actorOnly && paramValidEnemy) || info.enemyOnly);
    };

    //=============================================================================
    // BattleManager
    //  戦闘終了後に直接攻撃用の参照を破棄します。
    //=============================================================================
    var _BattleManager_endAction = BattleManager.endBattle;
    BattleManager.endBattle = function (result) {
        _BattleManager_endAction.apply(this, arguments);
        $gameParty.battleMembers().forEach(function (member) {
            member.initDirectlyAttack();
        });
    };

    //=============================================================================
    // Window_BattleLog
    //  ターゲットへの直接攻撃演出を追加定義します。
    //=============================================================================
    var _Window_BattleLog_updateWaitMode = Window_BattleLog.prototype.updateWaitMode;
    Window_BattleLog.prototype.updateWaitMode = function () {
        var waiting = false;
        switch (this._waitMode) {
            case 'animation':
                waiting = this._spriteset.isAnimationPlaying();
                break;
        }
        if (!waiting) {
            waiting = _Window_BattleLog_updateWaitMode.apply(this, arguments);
        }
        return waiting;
    };

    Window_BattleLog.prototype.waitForAnimation = function () {
        this.setWaitMode('animation');
    };

    var _Window_BattleLog_startAction = Window_BattleLog.prototype.startAction;
    Window_BattleLog.prototype.startAction = function (subject, action, targets) {
        var target = (targets[0] && subject.opponentsUnit() !== targets[0].opponentsUnit() ? targets[0] : null);
        subject.setDirectlyAttack(target, action);
        this.startActionAnimation(subject, targets);
        _Window_BattleLog_startAction.apply(this, arguments);
    };

    Window_BattleLog.prototype.startActionAnimation = function (subject, targets) {
        var attackInfo = subject.getDirectoryAddition();
        if (!attackInfo) return;
        if (attackInfo.subjectAnimationId > 0) {
            this.push('showAnimation', subject, [subject], attackInfo.subjectAnimationId);
            this.push('waitForAnimation');
        }
        if (attackInfo.targetAnimationId > 0) {
            this.push('showAnimation', subject, targets, attackInfo.targetAnimationId);
            this.push('waitForAnimation');
        }
    };

    var _Window_BattleLog_performActionStart = Window_BattleLog.prototype.performActionStart;
    Window_BattleLog.prototype.performActionStart = function (subject, action) {
        _Window_BattleLog_performActionStart.apply(this, arguments);
        this.push('waitForMovement');
    };

    var _Window_BattleLog_performActionEnd = Window_BattleLog.prototype.performActionEnd;
    Window_BattleLog.prototype.performActionEnd = function (subject) {
        _Window_BattleLog_performActionEnd.apply(this, arguments);
        this.push('waitForMovement');
    };

    //=============================================================================
    // Sprite_Battler
    //  ターゲットへの直接攻撃演出を追加定義します。
    //=============================================================================
    Sprite_Battler.prototype.isAfterImage = function () {
        return false;
    };

    Sprite_Battler.prototype.createAfterimageSprites = function () {
        if (paramNoAfterimage) return;
        var numbers = this.getAfterimageNumbers();
        for (var i = 0; i < numbers; i++) {
            this.createAfterimageSprite(i);
        }
    };

    Sprite_Battler.prototype.setSpriteSet = function (spriteSet) {
        this._spriteSet = spriteSet;
    };

    Sprite_Battler.prototype.createAfterimageSprite = function (index) {
        var sprite = this.getObjectSpriteAfterimage();
        sprite.setAfterimageIndex(index);
        sprite.visible = false;
        sprite.setOriginalSprite(this);
        this._afterimageSprites.push(sprite);
        this.parent.addChildAt(sprite, this.parent.getChildIndex(this) - index);
    };

    Sprite_Battler.prototype.getObjectSpriteAfterimage = function () {
        return this instanceof Sprite_Actor ? new Sprite_AfterimageActor(this._battler) :
            new Sprite_AfterimageEnemy(this._battler);
    };

    var _Sprite_Battler_initMembers = Sprite_Battler.prototype.initMembers;
    Sprite_Battler.prototype.initMembers = function () {
        _Sprite_Battler_initMembers.apply(this, arguments);
        this._attackX = 0;
        this._attackY = 0;
        this._attackZ = 0;
        this._afterimageSprites = [];
        this._afterimageLocus = [];
        this._afterimageViaibleCounter = 0;
        this.setVisibleAfterImage(false);
    };

    Sprite_Battler.prototype.setVisibleAfterImage = function (value) {
        this._visibleAfterimage = value || paramAlwaysAfterimage;
    };

    var _Sprite_Battler_setBattler = Sprite_Battler.prototype.setBattler;
    Sprite_Battler.prototype.setBattler = function (battler) {
        if (!this.isAfterImage()) {
            _Sprite_Battler_setBattler.apply(this, arguments);
        } else {
            this._battler = battler;
        }
        this._afterimageSprites.forEach(function (sprite) {
            sprite.setBattler(battler);
        });
    };

    var _Sprite_Battler_update = Sprite_Battler.prototype.update;
    Sprite_Battler.prototype.update = function () {
        _Sprite_Battler_update.apply(this, arguments);
        if (this._battler) {
            this.updateDirectly();
        }
    };

    Sprite_Battler.prototype.setPriorityMostFront = function () {
        if (!this.isAfterImage()) {
            this._afterimageSprites.forEach(function (sprite) {
                sprite.setPriorityMostFront();
            });
        }
        this.parent.setChildIndex(this, this.parent.children.length - 1);
    };

    Sprite_Battler.prototype.updateDirectly = function () {
        if (this._battler.isDirectlyAttackRequested()) {
            this._battler.resetDirectlyAttackRequest();
            this._targetSprite = this.getActionTargetSprite();
            var attackInfo = this._battler.getDirectoryAttack();
            this._attackMoveCenter = attackInfo.moveCenter;
            var position = this.getDirectoryPosition();
            this.startAttackMotion(position.x, position.y, attackInfo, false);
        }
        if (this._battler.isDirectlyReturnRequested()) {
            this._battler.resetDirectlyReturnRequest();
            var returnInfo = this._battler.getDirectoryReturn();
            if (!this._noReturn) {
                this.startReturnMotion(returnInfo);
            }
            this._noReturn = false;
        }
    };

    Sprite_Battler.prototype.getDirectoryPosition = function () {
        var target = this._targetSprite;
        var x = (target ? target.x - this.getNoAttackX() + this.getDirectoryPositionShiftX() : 0);
        var y = (target ? target.y - this.getNoAttackY() + this.getDirectoryPositionShiftY() : 0);
        return { x: x, y: y };
    };

    Sprite_Battler.prototype.getDirectoryPositionShiftX = function () {
        return 0;
    };

    Sprite_Battler.prototype.getDirectoryPositionShiftY = function () {
        return 0;
    };

    Sprite_Battler.prototype.getBattler = function () {
        return this._battler;
    };

    Sprite_Battler.prototype.getActionTargetSprite = function () {
        var spriteSet = this.parent.parent.parent;
        return spriteSet.getBattlerSprite(this._battler.getDirectoryAttack().target);
    };

    Sprite_Battler.prototype.startAttackMotion = function (x, y, attackInfo, returnFlg) {
        if (this.isPlayingAttackMotion()) return;
        var additionalInfo = this._battler.getDirectoryAddition();
        if (!returnFlg) {
            var newPos = this.shiftAttackMotion(x, y, additionalInfo);
            this._targetAttackX = newPos.x;
            this._targetAttackY = newPos.y;
        } else {
            this._targetAttackX = x;
            this._targetAttackY = y;
        }
        this._targetAttackZ = attackInfo.z;
        this._attackDuration = attackInfo.duration;
        this._attackDurationTime = this._attackDuration;
        this._attackAltitude = attackInfo.altitude;
        this._noReturn = additionalInfo.noReturn;
        this._originalOpacity = (additionalInfo.hidden ? this.opacity : null);
        if (attackInfo.duration === 0) {
            this._attackX = this._targetAttackX;
            this._attackY = this._targetAttackY;
            this._attackZ = this._targetAttackZ;
        } else {
            this.setPriorityMostFront();
            if (additionalInfo.afterimage && !paramNoAfterimage) {
                this.setVisibleAfterImage(true);
            }
        }
    };

    Sprite_Battler.prototype.shiftAttackMotion = function (x, y, additionalInfo) {
        var absPos = additionalInfo.absolutePosition;
        if (absPos) {
            x = this.getEnemyReverseX(absPos[0] || 0) - this.getNoAttackX();
            y = (absPos[1] || 0) - this.getNoAttackY();
        }
        var selfRelPos = additionalInfo.selfRelativePosition;
        if (selfRelPos) {
            x = (selfRelPos[0] || 0) * (this.isEnemySprite() ? -1 : 1);
            y = (selfRelPos[1] || 0);
        }
        var relPos = additionalInfo.relativePosition;
        if (relPos) {
            x = relPos[0] ? x + relPos[0] * (this.isEnemySprite() ? -1 : 1) : x;
            y = relPos[1] ? y + relPos[1] : y;
        }
        var telPos = additionalInfo.teleportPosition;
        if (telPos) {
            this._attackX = this.getEnemyReverseX(absPos[0] || 0) - this.getNoAttackX();
            this._attackY = (absPos[1] || 0) - this.getNoAttackY();
        }
        return { x: x, y: y };
    };

    Sprite_Battler.prototype.startReturnMotion = function (returnInfo) {
        this.startAttackMotion(0, 0, returnInfo, true);
    };

    var _Sprite_Battler_updateMove = Sprite_Battler.prototype.updateMove;
    Sprite_Battler.prototype.updateMove = function () {
        _Sprite_Battler_updateMove.apply(this, arguments);
        this.updateAttackMotion();
    };

    Sprite_Battler.prototype.updateAttackMotion = function () {
        if (this._attackDuration > 0) {
            var d = this._attackDuration;
            this._attackX = (this._attackX * (d - 1) + this._targetAttackX) / d;
            this._attackY = (this._attackY * (d - 1) + this._targetAttackY) / d;
            this._attackZ = (this._attackZ * (d - 1) + this._targetAttackZ) / d;
            this._attackDuration--;
            if (this.isAttackMotionHidden()) this.getMainSprite().opacity = this.getAttackMotionOpacity();
            if (this._attackDuration === 0) {
                this.onMoveEnd();
                if (this._attackX === 0 && this._attackY === 0) {
                    this._spriteSet.resetBattlerOrder();
                }
                this._attackEndFrame = Graphics.frameCount;
                this.setVisibleAfterImage(false);
            }
        }
    };

    Sprite_Battler.prototype.getAttackMotionOpacity = function () {
        var t = this._attackDurationTime;
        var d = this._attackDuration;
        return this._originalOpacity * Math.pow(this.getDaTimeLine(d, t), 4);
    };

    var _Sprite_Battler_updatePosition = Sprite_Battler.prototype.updatePosition;
    Sprite_Battler.prototype.updatePosition = function () {
        _Sprite_Battler_updatePosition.apply(this, arguments);
        this.x += this._attackX;
        this.y += this._attackY - this.getAttackAltitude();
        if (this.isVisibleAfterimage()) {
            this.updateAfterimages();
        } else if (this._afterimageLocus.length > 0) {
            this._afterimageLocus = [];
        }
    };

    Sprite_Battler.prototype.updateAfterimages = function () {
        this._afterimageLocus.unshift([this.getRealX(), this.getRealY()]);
        var interval = this.getAfterimageInterval();
        var numbers = this.getAfterimageNumbers();
        var counter = this._afterimageViaibleCounter;
        if (this._afterimageLocus.length % interval === 0 && counter < numbers && this._visibleAfterimage) {
            this._afterimageSprites[counter].visible = true;
            this._afterimageViaibleCounter++;
        }
        for (var i = 0; i < this._afterimageSprites.length; i++) {
            this.updateAfterimage(this._afterimageSprites[i]);
        }
        if (this._afterimageLocus.length > interval * numbers) {
            this._afterimageLocus.pop();
        }
    };

    Sprite_Battler.prototype.getRealX = function () {
        return this.x;
    };

    Sprite_Battler.prototype.getRealY = function () {
        return this.y;
    };

    Sprite_Battler.prototype.updateAfterimage = function (afterimage) {
        if (!afterimage.visible) return;
        var afterimageIndex = afterimage.getAfterimageIndex();
        var interval = this.getAfterimageInterval();
        var frameDelay = Math.min(afterimageIndex * interval, this._afterimageLocus.length - 1);
        var x = this._afterimageLocus[frameDelay][0];
        var y = this._afterimageLocus[frameDelay][1];
        if (!this._visibleAfterimage && Graphics.frameCount - this._attackEndFrame > frameDelay && afterimage.visible) {
            afterimage.visible = false;
            this._afterimageViaibleCounter--;
        }
        afterimage.move(x, y);
    };

    Sprite_Battler.prototype.getAfterimageInterval = function () {
        return this._attackDurationTime > 60 ? 4 : 2;
    };

    Sprite_Battler.prototype.getAfterimageNumbers = function () {
        return this._attackDurationTime > 60 ? 6 : 8;
    };

    Sprite_Battler.prototype.isVisibleAfterimage = function () {
        return !this.isAfterImage() && (this._visibleAfterimage || this._afterimageViaibleCounter > 0);
    };

    Sprite_Battler.prototype.getAttackAltitude = function () {
        var t = this._attackDurationTime;
        var d = this._attackDuration;
        return (this.isPlayingAttackMotion() ? this._calcAltitude(1, t) - this._calcAltitude(d, t) : 0) + this._attackZ;
    };

    Sprite_Battler.prototype._calcAltitude = function (d, t) {
        var altitude = Math.floor(Math.pow(this.getDaTimeLine(d, t) * this._attackAltitude, 2));
        if (this._attackAltitude < 0) altitude *= -1;
        return altitude;
    };

    Sprite_Battler.prototype.getDaTimeLine = function (d, t) {
        return ((d - (t / 2)) / (t / 2));
    };

    var _Sprite_Battler_isMoving = Sprite_Battler.prototype.isMoving;
    Sprite_Battler.prototype.isMoving = function () {
        return _Sprite_Battler_isMoving.apply(this, arguments) || this.isPlayingAttackMotion();
    };

    Sprite_Battler.prototype.isPlayingAttackMotion = function () {
        return this._attackDuration > 0;
    };

    Sprite_Battler.prototype.isAttackMotionHidden = function () {
        return !!this._originalOpacity;
    };

    Sprite_Battler.prototype.isEnemySprite = function () {
        return this._battler.isEnemy();
    };

    Sprite_Battler.prototype.getNoAttackX = function () {
        return this.x - this._attackX;
    };

    Sprite_Battler.prototype.getNoAttackY = function () {
        return this.y - this._attackY + this._attackZ;
    };

    Sprite_Battler.prototype.getEnemyReverseX = function (x) {
        return x;
    };

    Sprite_Battler.prototype.moveForward = function () {

    };

    //=============================================================================
    // Sprite_Actor
    //  ターゲットへの直接攻撃演出を追加定義します。
    //=============================================================================
    var _Sprite_Actor_updatePosition = Sprite_Actor.prototype.hasOwnProperty('updatePosition') ?
        Sprite_Actor.prototype.updatePosition : null;
    Sprite_Actor.prototype.updatePosition = function () {
        if (_Sprite_Actor_updatePosition) {
            _Sprite_Actor_updatePosition.apply(this, arguments);
        } else {
            Sprite_Battler.prototype.updatePosition.call(this);
        }
        var altitude = this.getAttackAltitude();
        if (altitude >= 0) {
            this._shadowSprite.y = this.getAttackAltitude();
            this._shadowSprite.opacity = 255 - this._shadowSprite.y / 2;
        }
    };

    Sprite_Actor.prototype.getDirectoryPositionShiftX = function () {
        if (this._attackMoveCenter) {
            return Sprite_Battler.prototype.getDirectoryPositionShiftX.apply(this, arguments);
        }
        var targetSprite = this._targetSprite;
        return this.anchor.x * this.width + (1 - targetSprite.anchor.x) * targetSprite.width + 16;
    };

    var _Sprite_Actor_stepForward = Sprite_Actor.prototype.stepForward;
    Sprite_Actor.prototype.stepForward = function () {
        if (this._battler.hasDirectoryAttack()) return;
        _Sprite_Actor_stepForward.apply(this, arguments);
    };

    Sprite_Actor.prototype.getRealX = function () {
        return Sprite_Battler.prototype.getRealX.apply(this, arguments) + this._mainSprite.x;
    };

    Sprite_Actor.prototype.getRealY = function () {
        return Sprite_Battler.prototype.getRealY.apply(this, arguments) + this._mainSprite.y * this.scale.y;
    };

    Sprite_Actor.prototype.getMainSprite = function () {
        return this._mainSprite;
    };

    //=============================================================================
    // Sprite_Enemy
    //  ターゲットへの直接攻撃演出を追加定義します。
    //=============================================================================
    Sprite_Enemy.prototype.getDirectoryPositionShiftX = function () {
        if (this._attackMoveCenter) {
            return Sprite_Battler.prototype.getDirectoryPositionShiftX.apply(this, arguments);
        }
        var targetSprite = this._targetSprite;
        return -((1 - this.anchor.x) * this.width + targetSprite.anchor.x * targetSprite.width + 16);
    };

    Sprite_Enemy.prototype.getEnemyReverseX = function (x) {
        return Graphics.width - Sprite_Battler.prototype.getEnemyReverseX.apply(this, arguments);
    };

    Sprite_Enemy.prototype.getMainSprite = function () {
        return this;
    };

    //=============================================================================
    // Sprite_AfterimageActor
    //  アクターの残像クラス
    //=============================================================================
    function Sprite_AfterimageActor() {
        this.initialize.apply(this, arguments);
    }

    Sprite_AfterimageActor.prototype = Object.create(Sprite_Actor.prototype);
    Sprite_AfterimageActor.prototype.constructor = Sprite_AfterimageActor;

    Sprite_AfterimageActor.prototype.updateMotion = function () { };
    Sprite_AfterimageActor.prototype.updatePosition = function () { };

    Sprite_AfterimageActor.prototype.setBattler = function (battler) {
        Sprite_Actor.prototype.setBattler.apply(this, arguments);
    };

    Sprite_AfterimageActor.prototype.createShadowSprite = function () {
        this._shadowSprite = new Sprite_Dummy();
    };

    Sprite_AfterimageActor.prototype.createStateSprite = function () {
        this._stateSprite = new Sprite_Dummy();
    };

    Sprite_AfterimageActor.prototype.createWeaponSprite = function () {
        this._weaponSprite = new Sprite_Dummy();
    };

    Sprite_AfterimageActor.prototype.setAfterimageIndex = function (index) {
        this._afterimageIndex = index;
        var numbers = this.getAfterimageNumbers();
        this._opacityRate = (numbers - index) / numbers;
    };

    Sprite_AfterimageActor.prototype.getAfterimageIndex = function () {
        return this._afterimageIndex;
    };

    Sprite_AfterimageActor.prototype.update = function () {
        if (this._battler) {
            this.updateMain();
            this.updateProperty();
        } else {
            this.bitmap = null;
        }
    };

    Sprite_AfterimageActor.prototype.updateProperty = function () {
        this.scale.x = this._originalSprite.scale.x;
        this.scale.y = this._originalSprite.scale.y;
        this.opacity = this._originalMainSprite.opacity * this._opacityRate;
        this.blendMode = this._originalMainSprite.blendMode;
        this.setColorTone(this._originalMainSprite.getColorTone());
        this.setBlendColor(this._originalMainSprite.getBlendColor());
        if (paramAlwaysAfterimage) {
            this.visible = (this.x !== this._originalSprite.getRealX() || this.y !== this._originalSprite.getRealY());
        }
    };

    Sprite_AfterimageActor.prototype.setOriginalSprite = function (originalSprite) {
        this._originalSprite = originalSprite;
        this._originalMainSprite = originalSprite.getMainSprite();
    };

    Sprite_AfterimageActor.prototype.isAfterImage = function () {
        return true;
    };

    //=============================================================================
    // Sprite_AfterimageEnemy
    //  敵キャラの残像クラス
    //=============================================================================
    function Sprite_AfterimageEnemy() {
        this.initialize.apply(this, arguments);
    }

    Sprite_AfterimageEnemy.prototype = Object.create(Sprite_Enemy.prototype);
    Sprite_AfterimageEnemy.prototype.constructor = Sprite_AfterimageEnemy;

    Sprite_AfterimageEnemy.prototype.updatePosition = function () { };

    Sprite_AfterimageEnemy.prototype.createStateIconSprite = function () {
        this._stateIconSprite = new Sprite_Dummy();
    };

    Sprite_AfterimageEnemy.prototype.isAfterImage = function () {
        return true;
    };

    Sprite_AfterimageEnemy.prototype.update = Sprite_AfterimageActor.prototype.update;
    Sprite_AfterimageEnemy.prototype.updateProperty = Sprite_AfterimageActor.prototype.updateProperty;
    Sprite_AfterimageEnemy.prototype.setOriginalSprite = Sprite_AfterimageActor.prototype.setOriginalSprite;
    Sprite_AfterimageEnemy.prototype.setAfterimageIndex = Sprite_AfterimageActor.prototype.setAfterimageIndex;
    Sprite_AfterimageEnemy.prototype.getAfterimageIndex = Sprite_AfterimageActor.prototype.getAfterimageIndex;

    //=============================================================================
    // Sprite_Dummy
    //  ダミースプライト
    //=============================================================================
    function Sprite_Dummy() {
        this.initialize.apply(this, arguments);
    }

    Sprite_Dummy.prototype.initialize = function () { };

    Sprite_Dummy.prototype.constructor = Sprite_Dummy;

    Sprite_Dummy.prototype.setup = function () { };

    //=============================================================================
    // Spriteset_Battle
    //  バトラースプライトを取得可能にします。
    //=============================================================================
    Spriteset_Battle.prototype.getBattlerSprite = function (battler) {
        if (!battler) return null;
        var sprites = (battler.isActor() ? this._actorSprites : this._enemySprites);
        return sprites.filter(function (sprite) {
            return sprite.getBattler() === battler;
        })[0];
    };

    var _Spriteset_Battle_createEnemies = Spriteset_Battle.prototype.createEnemies;
    Spriteset_Battle.prototype.createEnemies = function () {
        _Spriteset_Battle_createEnemies.apply(this, arguments);
        this.iterateEnemySprites(this.createBattlerAfterimage.bind(this));
    };

    var _Spriteset_Battle_createActors = Spriteset_Battle.prototype.createActors;
    Spriteset_Battle.prototype.createActors = function () {
        _Spriteset_Battle_createActors.apply(this, arguments);
        this.iterateActorSprites(this.createBattlerAfterimage.bind(this));
    };

    Spriteset_Battle.prototype.createBattlerAfterimage = function (sprite) {
        sprite.createAfterimageSprites();
        sprite.setSpriteSet(this);
    };

    Spriteset_Battle.prototype.resetBattlerOrder = function () {
        this.iterateActorSprites(this.setBattlerPriorityMostFront);
        this.iterateEnemySprites(this.setBattlerPriorityMostFront);
    };

    Spriteset_Battle.prototype.setBattlerPriorityMostFront = function (sprite, playingOnly) {
        if (!playingOnly || sprite.isPlayingAttackMotion()) sprite.setPriorityMostFront();
    };

    var _Spriteset_Battle_updateZCoordinates = Spriteset_Battle.prototype.updateZCoordinates;
    Spriteset_Battle.prototype.updateZCoordinates = function () {
        _Spriteset_Battle_updateZCoordinates.apply(this, arguments);
        this.iterateEnemySprites(this.setBattlerPriorityMostFront, true);
        this.iterateActorSprites(this.setBattlerPriorityMostFront, true);
    };

    Spriteset_Battle.prototype.iterateActorSprites = function (callBack, extend) {
        this.iterateBattlerSprites(this._actorSprites, callBack, extend);
    };

    Spriteset_Battle.prototype.iterateEnemySprites = function (callBack, extend) {
        this.iterateBattlerSprites(this._enemySprites, callBack, extend);
    };

    Spriteset_Battle.prototype.iterateBattlerSprites = function (sprites, callBack, extend) {
        for (var i = 0, n = sprites.length; i < n; i++) {
            callBack.call(this, sprites[i], extend);
        }
    };
})();


code:
//=============================================================================
// DisableFastForward.js
// ----------------------------------------------------------------------------
// (C)2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.0.2 2021/01/31 ヘルプの文言を変更
// 1.0.1 2020/01/05 不要な記述を削除
// 1.0.0 2016/02/22 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc イベント高速化禁止プラグイン
 * @author トリアコンタン
 *
 * @help イベント中に決定ボタンやマウスを長押しした場合の
 * イベントの倍速処理を無効化できます。
 * メッセージ送りや戦闘画面の高速化には影響を与えません。
 *
 * プラグインコマンドから禁止/許可の設定ができます。
 * 設定値はセーブデータに保存されます。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 *  イベント高速化禁止 or DISABLE_FAST_FORWARD
 *   イベントの高速スキップを禁止します。
 *
 *  イベント高速化許可 or ENABLE_FAST_FORWARD
 *   イベントの高速スキップを許可します。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';

    var getCommandName = function (command) {
        return (command || '').toUpperCase();
    };

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        this.pluginCommandDisableFastForward(command, args);
    };

    Game_Interpreter.prototype.pluginCommandDisableFastForward = function (command, args) {
        switch (getCommandName(command)) {
            case 'イベント高速化禁止':
            case 'DISABLE_FAST_FORWARD':
                $gameSystem.disableFastForward = true;
                break;
            case 'イベント高速化許可':
            case 'ENABLE_FAST_FORWARD':
                $gameSystem.disableFastForward = false;
                break;
        }
    };

    var _Game_System_initialize = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function () {
        _Game_System_initialize.apply(this, arguments);
        this.disableFastForward = false;
    };

    var _Scene_Map_isFastForward = Scene_Map.prototype.isFastForward;
    Scene_Map.prototype.isFastForward = function () {
        return !$gameSystem.disableFastForward && _Scene_Map_isFastForward.apply(this, arguments);
    };
})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// Durability.js
//=============================================================================

/*:
 * @plugindesc Adds Minecraft-like durability of weapons/armors.
 * <KockaDurability>
 * @author KockaAdmiralac
 *
 * @help
 * ============================================================================
 *                              INTRODUCTION
 * ============================================================================
 * This plugin allows you to manage durability of your weapons and
 * armors. It's very simple how durability is calculated :
 * 1) When you are attacked, your armor loses durability.
 * 2) When you attack, your weapons lose durability.
 * After your weapon/armor loses all durability it cracks and you don't
 * have it in equips anymore.
 *
 * This plugin is made self-initiative.
 * ============================================================================
 *                              	NOTETAGS
 * ============================================================================
 * There are three notetags :
 * - Weapon and Armor notetag :
 *     <durability:x>
 *   This sets initial weapon/armor durability to a certain value.
 *   Example : <durability:1>
 *   Weapon/Armor in which this is put has durability 1.
 *   If no durability is specified, item is indestructible.
 *
 * - Item and Skill notetags :
 *     <durability_use:x>
 *   This sets how many durability points are losed when this is used.
 *   Example : <durability_use:10>
 *   If this Item/Skill is used by actor, he loses 10 durability on his
 *   weapons. If this Item/Skill is used by enemy, actors which are attacked
 *   lose 10 durability points on their armor.
 *
 *     <durability_increase:[equips] increase>
 *   This sets how much durability will be regenerated.
 *   	[equips] - numbers separated with one space that modify which equips
 *   will that increasing effect.
 *   	increase - if it's a number it'll specify by how much will your equips
 *   regenerate durability. It can be also set to "MAX", and then it'll
 *   just set your durability to max value.
 *   Example :
 *   Notetag : <durability_increase:[1 2 3] 10>
 *   This will increase durability for your Weapon, Shield and Head by 10.
 *   Notetag : <durability_increase[2 3 4] MAX>
 *   This will set durability for your Shield, Head and Body to maximum.
 *
 * Since version 1.1.1 you can set variable durability use/increase.
 * You can now set to depend on HP, MP, TP damage or even some variable.
 * 	Example:
 *	Notetag : <durability_use:hpDamage>
 * 	Result : This skill consumes durability in same amount as damage dealt.
 *
 * 	Notetag : <durability_increase:$gameVariables.variable(1)>
 *	Result : This skill/item will regenerate durability equal amount as
 *  variable iD 1's value.
 * ============================================================================
 *                              VERSION HISTORY
 * ============================================================================
 * Version | Description
 * ________|___________________________________________________________________
 * 1.0.0   | Initial release
 * 1.1.0   | Added option for regenerating durability.									[Adlw]
 * 1.1.1   | Added option for variable durability use										[Ozuma]
 * ============================================================================
 *                               COMPATIBILITY
 * ============================================================================
 * NEW :
 *	<None>
 *
 * ALIASED :
 *	- Game_Action :
 *		- apply
 *		- useItem
 *
 * OVERWRITTEN :
 *	<None>
 * ============================================================================
 * @param Weapons
 * @desc Specify what are your weapon slots here, separated by a space
 * @default 1
 *
 * @param Armors
 * @desc Specify what are your armor slots here, separated by a space
 * @default 2 3 4 5
 *
 * @param Default durability use
 * @desc How much durability points will item/skill take from weapon/armor
 * when none is specified?
 * @default 1
 *
 * @param Durability message
 * @desc What message will be displayed when weapon/armor cracks?
 * Set to empty to disable.
 * @default %1 cracked!
 */
(function () {

	// Aliases
	var _kocka_random_alias_apply_M7cAp2B8 = Game_Action.prototype.apply;
	var _kocka_random_alias_useItem_eb8T3mP2 = Game_Actor.prototype.useItem;

	// Parameters
	var _plugin_params = $plugins.filter(function (p) { return p.description.contains('<KockaDurability>'); })[0].parameters;
	var temp_weapons = _plugin_params["Weapons"];
	var temp_armors = _plugin_params["Armors"];
	var default_durability_use = Number(_plugin_params["Default durability use"]);
	var durability_message = _plugin_params["Durability message"];

	//-----------------------------------------------------------------------------
	// Game_Action
	//
	// The game object class for a battle action.

	Game_Action.prototype.apply = function (target) {
		_kocka_random_alias_apply_M7cAp2B8.apply(this, arguments);
		if (target.result().isHit()) {
			var array = ((this.subject() instanceof Game_Actor) ? temp_weapons : temp_armors).split(" ");
			var actor = (this.subject() instanceof Game_Actor) ? this.subject() : target;
			for (var i = 0; i < array.length; ++i) {
				var equip = actor.equips()[array[i] - 1];
				if (equip) {
					if (!equip.durability) equip.durability = equip.meta.durability ? equip.meta.durability : -1;
					var hasDurability = equip.durability != -1;
					var result = target.result();
					var hpDamage = result.hpDamage;
					var mpDamage = result.mpDamage;
					var tpDamage = result.tpDamage;
					if (hasDurability) equip.durability -= this.item().meta.durability_use ? eval(this.item().meta.durability_use) : this.item().meta.durability_increase ? 0 : eval(default_durability_use);
					if (equip.durability <= 0 && hasDurability) {
						if (durability_message != "") $gameMessage.add(durability_message.format(equip.name));
						actor.changeEquipById(array[i], 0);
					}
				}
			}
		}
	}

	Game_Actor.prototype.useItem = function (item) {
		_kocka_random_alias_useItem_eb8T3mP2.apply(this, arguments);
		if (item.meta.durability_increase) {
			var arr = /\[(.+)\]\s*(\w+)/ig.exec(item.meta.durability_increase);
			if (arr) {
				var equips = this.equips();
				var splitEquips = arr[1].split(" ");
				for (var i = 0; i < splitEquips.length; ++i) {
					var equip = equips[Number(splitEquips[i]) - 1];
					if (equip) {
						if (equip.meta.durability) {
							var maxDurability = Number(equip.meta.durability);
							if (!equip.durability) equip.durability = maxDurability;
							else {
								if (arr[2] === "MAX") equip.durability = maxDurability;
								else {
									equip.durability += Number(arr[2]);
									if (equip.durability > maxDurability) equip.durability = maxDurability;
								}
							}
						}
						else console.log("[Durability] You can't increase durability on equip that has no durability!");
					}
				}
			}
		}
	}

})();


code:
//=============================================================================
// EnemyBook.js
//=============================================================================

/*:
 * @plugindesc Displays detailed statuses of enemies.
 * @author Yoji Ojima
 *
 * @param Unknown Data
 * @desc The index name for an unknown enemy.
 * @default ??????
 *
 * @help
 *
 * Plugin Command:
 *   EnemyBook open         # Open the enemy book screen
 *   EnemyBook add 3        # Add enemy #3 to the enemy book
 *   EnemyBook remove 4     # Remove enemy #4 from the enemy book
 *   EnemyBook complete     # Complete the enemy book
 *   EnemyBook clear        # Clear the enemy book
 *
 * Enemy Note:
 *   <desc1:foobar>         # Description text in the enemy book, line 1
 *   <desc2:blahblah>       # Description text in the enemy book, line 2
 *   <book:no>              # This enemy does not appear in the enemy book
 */

/*:ja
 * @plugindesc モンスター図鑑です。敵キャラの詳細なステータスを表示します。
 * @author Yoji Ojima
 *
 * @param Unknown Data
 * @desc 未確認の敵キャラの索引名です。
 * @default ？？？？？？
 *
 * @help
 *
 * プラグインコマンド:
 *   EnemyBook open         # 図鑑画面を開く
 *   EnemyBook add 3        # 敵キャラ３番を図鑑に追加
 *   EnemyBook remove 4     # 敵キャラ４番を図鑑から削除
 *   EnemyBook complete     # 図鑑を完成させる
 *   EnemyBook clear        # 図鑑をクリアする
 *
 * 敵キャラのメモ:
 *   <desc1:なんとか>       # 説明１行目
 *   <desc2:かんとか>       # 説明２行目
 *   <book:no>              # 図鑑に載せない場合
 */

(function () {

    var parameters = PluginManager.parameters('EnemyBook');
    var unknownData = String(parameters['Unknown Data'] || '??????');

    var _Game_Interpreter_pluginCommand =
        Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === 'EnemyBook') {
            switch (args[0]) {
                case 'open':
                    SceneManager.push(Scene_EnemyBook);
                    break;
                case 'add':
                    $gameSystem.addToEnemyBook(Number(args[1]));
                    break;
                case 'remove':
                    $gameSystem.removeFromEnemyBook(Number(args[1]));
                    break;
                case 'complete':
                    $gameSystem.completeEnemyBook();
                    break;
                case 'clear':
                    $gameSystem.clearEnemyBook();
                    break;
            }
        }
    };

    Game_System.prototype.addToEnemyBook = function (enemyId) {
        if (!this._enemyBookFlags) {
            this.clearEnemyBook();
        }
        this._enemyBookFlags[enemyId] = true;
    };

    Game_System.prototype.removeFromEnemyBook = function (enemyId) {
        if (this._enemyBookFlags) {
            this._enemyBookFlags[enemyId] = false;
        }
    };

    Game_System.prototype.completeEnemyBook = function () {
        this.clearEnemyBook();
        for (var i = 1; i < $dataEnemies.length; i++) {
            this._enemyBookFlags[i] = true;
        }
    };

    Game_System.prototype.clearEnemyBook = function () {
        this._enemyBookFlags = [];
    };

    Game_System.prototype.isInEnemyBook = function (enemy) {
        if (this._enemyBookFlags && enemy) {
            return !!this._enemyBookFlags[enemy.id];
        } else {
            return false;
        }
    };

    var _Game_Troop_setup = Game_Troop.prototype.setup;
    Game_Troop.prototype.setup = function (troopId) {
        _Game_Troop_setup.call(this, troopId);
        this.members().forEach(function (enemy) {
            if (enemy.isAppeared()) {
                $gameSystem.addToEnemyBook(enemy.enemyId());
            }
        }, this);
    };

    var _Game_Enemy_appear = Game_Enemy.prototype.appear;
    Game_Enemy.prototype.appear = function () {
        _Game_Enemy_appear.call(this);
        $gameSystem.addToEnemyBook(this._enemyId);
    };

    var _Game_Enemy_transform = Game_Enemy.prototype.transform;
    Game_Enemy.prototype.transform = function (enemyId) {
        _Game_Enemy_transform.call(this, enemyId);
        $gameSystem.addToEnemyBook(enemyId);
    };

    function Scene_EnemyBook() {
        this.initialize.apply(this, arguments);
    }

    Scene_EnemyBook.prototype = Object.create(Scene_MenuBase.prototype);
    Scene_EnemyBook.prototype.constructor = Scene_EnemyBook;

    Scene_EnemyBook.prototype.initialize = function () {
        Scene_MenuBase.prototype.initialize.call(this);
    };

    Scene_EnemyBook.prototype.create = function () {
        Scene_MenuBase.prototype.create.call(this);
        this._indexWindow = new Window_EnemyBookIndex(0, 0);
        this._indexWindow.setHandler('cancel', this.popScene.bind(this));
        var wy = this._indexWindow.height;
        var ww = Graphics.boxWidth;
        var wh = Graphics.boxHeight - wy;
        this._statusWindow = new Window_EnemyBookStatus(0, wy, ww, wh);
        this.addWindow(this._indexWindow);
        this.addWindow(this._statusWindow);
        this._indexWindow.setStatusWindow(this._statusWindow);
    };

    function Window_EnemyBookIndex() {
        this.initialize.apply(this, arguments);
    }

    Window_EnemyBookIndex.prototype = Object.create(Window_Selectable.prototype);
    Window_EnemyBookIndex.prototype.constructor = Window_EnemyBookIndex;

    Window_EnemyBookIndex.lastTopRow = 0;
    Window_EnemyBookIndex.lastIndex = 0;

    Window_EnemyBookIndex.prototype.initialize = function (x, y) {
        var width = Graphics.boxWidth;
        var height = this.fittingHeight(6);
        Window_Selectable.prototype.initialize.call(this, x, y, width, height);
        this.refresh();
        this.setTopRow(Window_EnemyBookIndex.lastTopRow);
        this.select(Window_EnemyBookIndex.lastIndex);
        this.activate();
    };

    Window_EnemyBookIndex.prototype.maxCols = function () {
        return 3;
    };

    Window_EnemyBookIndex.prototype.maxItems = function () {
        return this._list ? this._list.length : 0;
    };

    Window_EnemyBookIndex.prototype.setStatusWindow = function (statusWindow) {
        this._statusWindow = statusWindow;
        this.updateStatus();
    };

    Window_EnemyBookIndex.prototype.update = function () {
        Window_Selectable.prototype.update.call(this);
        this.updateStatus();
    };

    Window_EnemyBookIndex.prototype.updateStatus = function () {
        if (this._statusWindow) {
            var enemy = this._list[this.index()];
            this._statusWindow.setEnemy(enemy);
        }
    };

    Window_EnemyBookIndex.prototype.refresh = function () {
        this._list = [];
        for (var i = 1; i < $dataEnemies.length; i++) {
            var enemy = $dataEnemies[i];
            if (enemy.name && enemy.meta.book !== 'no') {
                this._list.push(enemy);
            }
        }
        this.createContents();
        this.drawAllItems();
    };

    Window_EnemyBookIndex.prototype.drawItem = function (index) {
        var enemy = this._list[index];
        var rect = this.itemRectForText(index);
        var name;
        if ($gameSystem.isInEnemyBook(enemy)) {
            name = enemy.name;
        } else {
            name = unknownData;
        }
        this.drawText(name, rect.x, rect.y, rect.width);
    };

    Window_EnemyBookIndex.prototype.processCancel = function () {
        Window_Selectable.prototype.processCancel.call(this);
        Window_EnemyBookIndex.lastTopRow = this.topRow();
        Window_EnemyBookIndex.lastIndex = this.index();
    };

    function Window_EnemyBookStatus() {
        this.initialize.apply(this, arguments);
    }

    Window_EnemyBookStatus.prototype = Object.create(Window_Base.prototype);
    Window_EnemyBookStatus.prototype.constructor = Window_EnemyBookStatus;

    Window_EnemyBookStatus.prototype.initialize = function (x, y, width, height) {
        Window_Base.prototype.initialize.call(this, x, y, width, height);
        this._enemy = null;
        this._enemySprite = new Sprite();
        this._enemySprite.anchor.x = 0.5;
        this._enemySprite.anchor.y = 0.5;
        this._enemySprite.x = width / 2 - 20;
        this._enemySprite.y = height / 2;
        this.addChildToBack(this._enemySprite);
        this.refresh();
    };

    Window_EnemyBookStatus.prototype.setEnemy = function (enemy) {
        if (this._enemy !== enemy) {
            this._enemy = enemy;
            this.refresh();
        }
    };

    Window_EnemyBookStatus.prototype.update = function () {
        Window_Base.prototype.update.call(this);
        if (this._enemySprite.bitmap) {
            var bitmapHeight = this._enemySprite.bitmap.height;
            var contentsHeight = this.contents.height;
            var scale = 1;
            if (bitmapHeight > contentsHeight) {
                scale = contentsHeight / bitmapHeight;
            }
            this._enemySprite.scale.x = scale;
            this._enemySprite.scale.y = scale;
        }
    };

    Window_EnemyBookStatus.prototype.refresh = function () {
        var enemy = this._enemy;
        var x = 0;
        var y = 0;
        var lineHeight = this.lineHeight();

        this.contents.clear();

        if (!enemy || !$gameSystem.isInEnemyBook(enemy)) {
            this._enemySprite.bitmap = null;
            return;
        }

        var name = enemy.battlerName;
        var hue = enemy.battlerHue;
        var bitmap;
        if ($gameSystem.isSideView()) {
            bitmap = ImageManager.loadSvEnemy(name, hue);
        } else {
            bitmap = ImageManager.loadEnemy(name, hue);
        }
        this._enemySprite.bitmap = bitmap;

        this.resetTextColor();
        this.drawText(enemy.name, x, y);

        x = this.textPadding();
        y = lineHeight + this.textPadding();

        for (var i = 0; i < 8; i++) {
            this.changeTextColor(this.systemColor());
            this.drawText(TextManager.param(i), x, y, 160);
            this.resetTextColor();
            this.drawText(enemy.params[i], x + 160, y, 60, 'right');
            y += lineHeight;
        }

        var rewardsWidth = 280;
        x = this.contents.width - rewardsWidth;
        y = lineHeight + this.textPadding();

        this.resetTextColor();
        this.drawText(enemy.exp, x, y);
        x += this.textWidth(enemy.exp) + 6;
        this.changeTextColor(this.systemColor());
        this.drawText(TextManager.expA, x, y);
        x += this.textWidth(TextManager.expA + '  ');

        this.resetTextColor();
        this.drawText(enemy.gold, x, y);
        x += this.textWidth(enemy.gold) + 6;
        this.changeTextColor(this.systemColor());
        this.drawText(TextManager.currencyUnit, x, y);

        x = this.contents.width - rewardsWidth;
        y += lineHeight;

        for (var j = 0; j < enemy.dropItems.length; j++) {
            var di = enemy.dropItems[j];
            if (di.kind > 0) {
                var item = Game_Enemy.prototype.itemObject(di.kind, di.dataId);
                this.drawItemName(item, x, y, rewardsWidth);
                y += lineHeight;
            }
        }

        var descWidth = 480;
        x = this.contents.width - descWidth;
        y = this.textPadding() + lineHeight * 7;
        this.drawTextEx(enemy.meta.desc1, x, y + lineHeight * 0, descWidth);
        this.drawTextEx(enemy.meta.desc2, x, y + lineHeight * 1, descWidth);
    };

})();


code:
//
//  エネミークラス ver1.00
//
// author yana
//

var Imported = Imported || {};
Imported['EnemyClass'] = 1.00;

/*:
 * @plugindesc ver1.00/ダメージに補正を与える色々な機能を追加します。
 * @author Yana
 *
 * @param Empty Class ID
 * @desc 空クラスとして使用されるクラスのIDです。
 * 指定したIDのクラスは通常使用はできなくなります。
 * @default 1000
 *
 * @param Default Level
 * @desc エネミーのレベルの初期値として設定されるレベルです。
 * 最低レベル設定がない場合、この値が使用されます。
 * @default 1
 *
 * @param Usable Skills
 * @desc エネミーが覚えていなくても使用できるスキルです。
 * 詳しい解説はヘルプを参照してください。
 * @default 1,2,3,4,5,6,7
 *
 * @param Growing Pattern
 * @desc エネミーの成長パターンです。
 * 詳しい解説はヘルプを参照してください。
 * @default -2
 *
 * @param Level Amplitude
 * @desc レベルの振れ幅です。この値の分だけ+-でレベルが上下します。
 * ※2に設定すると、-2~+2のエネミーが出現します。
 * @default 2
 *
 * @param Show Level ESWindow
 * @desc エネミー選択のウィンドウで敵レベルを描画するかの設定です。
 * @default true
 *
 *
 * @help------------------------------------------------------
 *  プラグインコマンドはありません。
 * ------------------------------------------------------
 * ------------------------------------------------------
 * 解説
 * ------------------------------------------------------
 * このプラグインはエネミーにクラスを設定し、エネミーにレベルの概念を追加します。
 * これにより、エネミーがレベルで成長していくような設定が可能です。
 * また、エネミーは覚えていないスキルは使用できなくなるため、レベルで新しいスキルを使用してくる
 * などの仕組みも設定することができるようになります。
 * パッシブスキルも同様に機能するため、同時に導入することでレベルによって新たに特徴を付与する
 * ような設定も可能です。
 *
 * ・Usable Skillsの設定詳細
 * クラスが設定されているエネミーはUsable Skillsで設定されているスキル以外は、
 * 習得していなければ使用できません。
 *
 * ・Growing Patternの設定詳細
 * この設定では、-2,-1,0,1以上の4種類のいずれかの値を設定します。
 * それぞれの値の意味は、
 * -2:被ダメージを経験値として蓄積し、レベルを決めます。
 * -1:パーティの戦闘メンバーの平均レベルを参照して、レベルを決めます。
 * 0:パーティ全員の平均レベルを参照して、レベルを決めます。
 * 1以上:対応するIDの変数の値を参照して、レベルを決めます。
 * ------------------------------------------------------
 * 設定方法
 * ------------------------------------------------------
 * ・エネミーのメモ欄に記述する設定
 *
 * エネミーのクラスをIDx番のクラスに設定します。
 * <エネミークラス:x>
 * <ENEMY_CLASS:x>
 *
 * エネミーの最低レベルをxに設定します。成長パターンや振れ幅の設定がどうなっていても、
 * この値以下のレベルになることはありません。
 * <敵最低レベル:x>
 * <ENEMY_MIN_LEVEL:x>
 *
 * エネミーの最大レベルをxに設定します。
 * <敵最大レベル:x>
 * <ENEMY_MAX_LEVEL:x>
 *
 * エネミーのレベルによって上昇する経験値の基準値を設定します。
 * 経験値は元の経験値+(レベル*基準値)で計算されます。
 * この値には小数も設定可能で、最終的な値は小数点以下が切り捨てられます。
 * <レベル経験値基準値:x>
 * <LEVEL_EXP_BASE:x>
 *
 * エネミーのレベルによって上昇するゴールドの基準値を設定します。
 * 経験値は元の経験値+(レベル*基準値)で計算されます。
 * この値には小数も設定可能で、最終的な値は小数点以下が切り捨てられます。
 * <レベルゴールド基準値:x>
 * <LEVEL_GOLD_BASE:x>
 *
 * エネミーのレベルによって上昇するABPの基準値を設定します。
 * 経験値は元の経験値+(レベル*基準値)で計算されます。
 * この値には小数も設定可能で、最終的な値は小数点以下が切り捨てられます。
 * <レベルABP基準値:x>
 * <LEVEL_ABP_BASE:x>
 *
 * エネミーのレベルによって追加されるドロップを設定します。
 * a:IWAのいずれか,b:アイテムID,c:ドロップするレベル,d:ドロップ率%
 * <追加ドロップ:ab,LVc,d%>
 * <ADDITIONAL_DROP:ab,LVc,d%>
 * 例:Lv5以上でID5番の武器を20%の確率でドロップする
 * <追加ドロップ:W5,LV5,20%>
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.00:
 * 公開
 */

(function () {

	var parameters = PluginManager.parameters('EnemyClass');
	var emptyClassId = Number(parameters['Empty Class ID'] || 1000);
	var defaultLevel = Number(parameters['Default Level'] || 1);
	var usableSkills = String(parameters['Usable Skills'] || '1,2,3,4,5,6,7').split(',');
	var growingPattern = Number(parameters['Growing Pattern'] || -2);
	var levelAmplitude = Number(parameters['Level Amplitude'] || 2);
	var showLevelESWindow = String(parameters['Show Level ESWindow']) === 'true'

	for (var i = 0; i < usableSkills.length; i++) {
		usableSkills[i] = Number(usableSkills[i]);
	}

	showLevelESWindow = true;

	DataManager.itemObject = function (kind, itemId) {
		switch (kind) {
			case 1:
				return $dataItems[itemId];
			case 2:
				return $dataWeapons[itemId];
			case 3:
				return $dataArmors[itemId];
		}
		return null;
	};

	Game_System.prototype.enemyExpList = function (enemyId, value, exp) {
		if (this._enemyExpList === undefined) { this._enemyExpList = {} }
		if (value === undefined || value === null) {
			var enemy = $dataEnemies[enemyId];
			if (this._enemyExpList[enemyId] === undefined || exp !== undefined) {
				if (exp === undefined) { exp = 0 }
				this._enemyExpList[enemyId] = exp;
			}
		} else {
			this._enemyExpList[enemyId] = this._enemyExpList[enemyId] + value;
		}
		return this._enemyExpList[enemyId];
	};

	var _EnC_GEnemy_initialize = Game_Enemy.prototype.initialize;
	Game_Enemy.prototype.initialize = function (enemyId, x, y) {
		_EnC_GEnemy_initialize.call(this, enemyId, x, y);
		this.setLevel();
		this._hp = this.mhp;
		this._mp = this.mmp;
	};

	Game_Enemy.prototype.levelForExp = function () {
		var eexp = $gameSystem.enemyExpList(this.enemy().id);
		for (var i = this.level(); i < this.maxLevel(); i++) {
			if (this.expForLevel(i) > eexp) { return i - 1 }
		}
		return this.maxLevel();
	};

	Game_Enemy.prototype.expForLevel = function (level) {
		var c = this.enemyClass();
		var basis = c.expParams[0];
		var extra = c.expParams[1];
		var acc_a = c.expParams[2];
		var acc_b = c.expParams[3];
		return Math.round(basis * (Math.pow(level - 1, 0.9 + acc_a / 250)) * level *
			(level + 1) / (6 + Math.pow(level, 2) / 50 / acc_b) + (level - 1) * extra);
	};

	Game_Enemy.prototype.setLevel = function () {
		var lv = 1;
		var r = 0;
		switch (growingPattern) {
			case -2:
				lv = this._level;
				if ($gameSystem._enemyExpList && $gameSystem._enemyExpList[this.enemy().id]) {
					lv = this.levelForExp();
				} else {
					$gameSystem.enemyExpList(this.enemy().id, null, this.expForLevel(lv));
				}
				break;
			case -1:
				var r = $gameParty.battleMembers().reduce(function (r, m) { return r + m._level }, 0);
				lv = Math.floor(r / $gameParty.battleMembers().length);
				break;
			case 0:
				var r = $gameParty.members().reduce(function (r, m) { return r + m._level }, 0);
				lv = Math.floor(r / $gameParty.members().length);
				break;
			default:
				lv = $gameVariables.value(growingPattern);
		}
		lv = Math.max(lv, this.level());
		amplitude = levelAmplitude;
		this._level = Math.min(Math.max(Math.max((lv - amplitude) + Math.randomInt(amplitude * 2) + 1, 1), this.level()), this.maxLevel());
	};

	Game_Enemy.prototype.level = function () {
		if (this._level) { return this._level }
		if (this.enemy().meta['敵最低レベル']) {
			this._level = Number(this.enemy().meta['敵最低レベル']);
		} else if (this.enemy().meta['ENEMY_MIN_LEVEL']) {
			this._level = Number(this.enemy().meta['ENEMY_MIN_LEVEL']);
		} else {
			this._level = defaultLevel;
			if (this._level === 0) { this._level = Math.floor(this.enemy().id / 10) }
		}
		this._level = Math.max(this._level, 1);
		return this._level;
	};

	Game_Enemy.prototype.expBase = function () {
		if (this.enemy().meta['レベル経験値基準値']) {
			return Number(this.enemy().meta['レベル経験値基準値']);
		} else if (this.enemy().meta['LEVEL_EXP_BASE']) {
			return Number(this.enemy().meta['LEVEL_EXP_BASE']);
		}
		return 0;
	};
	Game_Enemy.prototype.goldBase = function () {
		if (this.enemy().meta['レベルゴールド基準値']) {
			return Number(this.enemy().meta['レベルゴールド基準値']);
		} else if (this.enemy().meta['LEVEL_GOLD_BASE']) {
			return Number(this.enemy().meta['LEVEL_GOLD_BASE']);
		}
		return 0;
	};
	if (Imported['VXandAceHybridClass']) {
		var _EnC_GEnemy_abp = Game_Enemy.prototype.abp;
		Game_Enemy.prototype.abp = function () {
			var abp = _EnC_GEnemy_abp.call(this);
			return abp + Math.floor(this.abpBase() * this.level());
		};
		Game_Enemy.prototype.abpBase = function () {
			if (this.enemy().meta['レベルABP基準値']) {
				return Number(this.enemy().meta['レベルABP基準値']);
			} else if (this.enemy().meta['LEVEL_ABP_BASE']) {
				return Number(this.enemy().meta['LEVEL_ABP_BASE']);
			}
			return 0;
		};
	}

	Game_Enemy.prototype.additionalDrop = function () {
		var texts = this.enemy().note.split('\n');
		var drop = [];
		var kind = 0;
		for (var i = 0; i < texts.length; i++) {
			var text = texts[i];
			if (text.match(/^[<＜](?:追加ドロップ|ADDITIONAL_DROP)[:：]([IWA])(\d+)[,，]LV(\d+)[,，](\d+)[%％][＞>]/)) {
				switch (RegExp.$1) {
					case 'I':
						kind = 1;
						break;
					case 'W':
						kind = 2;
						break;
					case 'A':
						kind = 3;
						break;
				}
				var r = [DataManager.itemObject(kind, Number(RegExp.$2)), Number(RegExp.$3), Number(RegExp.$4)];
				drop.push(r);
			}
		}
		return drop;
	};

	Game_Enemy.prototype.additionalDropForReal = function () {
		var result = [];
		var drops = this.additionalDrop();
		for (var i = 0; i < drops.length; i++) {
			var drop = drops[i];
			if (drop[1] <= this.level() && ((drop[2] * this.dropItemRate()) / 100) > Math.random()) {
				result.push(drop[0]);
			}
		}
		return result;
	};

	var _EnC_GEnemy_makeDropItems = Game_Enemy.prototype.makeDropItems;
	Game_Enemy.prototype.makeDropItems = function () {
		var dropItems = _EnC_GEnemy_makeDropItems.call(this);
		var additionalDrop = this.additionalDropForReal();
		return dropItems.concat(additionalDrop);
	};

	var _EnC_GEnemy_exp = Game_Enemy.prototype.exp;
	Game_Enemy.prototype.exp = function () {
		var exp = _EnC_GEnemy_exp.call(this);
		return exp + Math.floor(this.expBase() * this.level());
	};

	var _EnC_GEnemy_gold = Game_Enemy.prototype.gold;
	Game_Enemy.prototype.gold = function () {
		var gold = _EnC_GEnemy_gold.call(this);
		return gold + Math.floor(this.goldBase() * this.level());
	};

	Game_Enemy.prototype.maxLevel = function () {
		if (this.enemy().meta['敵最大レベル']) {
			return Number(this.enemy().meta['敵最大レベル']);
		} else if (this.enemy().meta['ENEMY_MAX_LEVEL']) {
			return Number(this.enemy().meta['ENEMY_MAX_LEVEL']);
		} else if (this._classId === emptyClassId) {
			return 1;
		} else {
			return 99;
		}
	};

	Game_Enemy.prototype.enemyClass = function () {
		if (!this._classId) { this.initEnemyClass() }
		if (!$dataClasses[this._classId]) { this.initEmptyClass() }
		return $dataClasses[this._classId];
	};

	Game_Enemy.prototype.initEnemyClass = function () {
		if (this.enemy().meta['敵クラス']) {
			this._classId = Number(this.enemy().meta['敵クラス']);
		} else if (this.enemy().meta['ENEMY_CLASS']) {
			this._classId = Number(this.enemy().meta['ENEMY_CLASS']);
		} else {
			if (!$dataClasses[emptyClassId]) {
				this.initEmptyClass();
			}
			this._classId = emptyClassId;
		}
	};

	Game_Enemy.prototype.initEmptyClass = function () {
		var c = {
			'id': emptyClassId,
			'name': '',
			'note': '',
			'traits': [],
			'params': [],
			'expParams': [30, 20, 30, 30],
			'learnings': [],
			'meta': {}
		};
		for (var i = 0; i < 8; i++) {
			c['params'][i] = [];
			for (var j = 0; j < 100; j++) {
				c['params'][i][j] = 0;
			}
		}
		//if (Imported['VXandAceHybridClass']){ c.note　+= '<クラスチェンジ不可>' }
		$dataClasses[emptyClassId] = c;
	};

	var _EnC_GEnemy_paramBase = Game_Enemy.prototype.paramBase;
	Game_Enemy.prototype.paramBase = function (paramId) {
		var param1 = _EnC_GEnemy_paramBase.call(this, paramId);
		var param2 = this.enemyClass().params[paramId][this.level()];
		return param1 + param2;
	};

	var _EnC_GEnemy_selectAllActions = Game_Enemy.prototype.selectAllActions;
	Game_Enemy.prototype.selectAllActions = function (actionList) {
		var result = actionList;
		if (this.enemyClass().id !== emptyClassId) {
			result = [];
			for (var i = 0; i < actionList.length; i++) {
				var action = actionList[i];
				if (usableSkills.contains(action.skillId) || this.eSkills().contains(action.skillId)) {
					result.push(action);
				}
			}
		}
		return _EnC_GEnemy_selectAllActions.call(this, result);
	};

	Game_Enemy.prototype.eSkills = function () {
		var learnings = this.enemyClass().learnings;
		var result = [];
		for (var i = 0; i < learnings.length; i++) {
			if (learnings[i].level <= this.level()) {
				result.push(learnings[i].skillId);
			}
		}
		return result;
	};

	var _EnC_GEnemy_traitObjects = Game_Enemy.prototype.traitObjects;
	Game_Enemy.prototype.traitObjects = function () {
		var objects = [];
		if (Imported['yPassiveSkill']) {
			var skills = this.eSkills().concat(usableSkills);
			var result = [];
			for (var i = 0; i < skills.length; i++) {
				var skill = $dataSkills[skills[i]];
				PassiveSkillManager.initPassiveSkill(skill);
				if (skill.traits && skill.traits.length > 0) {
					result.push(skill);
				}
			}
			objects = objects.concat(result);
		}
		return _EnC_GEnemy_traitObjects.call(this).concat(objects);
	};

	var _EnC_GAction_executeHpDamage = Game_Action.prototype.executeHpDamage;
	Game_Action.prototype.executeHpDamage = function (target, value) {
		_EnC_GAction_executeHpDamage.call(this, target, value);
		if (target.isEnemy() && value > 0 && $gameSystem._enemyExpList) {
			$gameSystem.enemyExpList(target.enemy().id, value);
		};
	};
	if (showLevelESWindow) {
		Window_BattleEnemy.prototype.drawItem = function (index) {
			this.resetTextColor();
			var enemy = this._enemies[index];
			var name = enemy.name();
			name += enemy._classId === emptyClassId ? '' : '(Lv' + enemy.level() + ')'
			var rect = this.itemRectForText(index);
			this.drawText(name, rect.x, rect.y, rect.width);
		};
	}
}());


code:
//=============================================================================
// EquipmentAcrobat.js
//=============================================================================

/*:ja
 * @plugindesc ver1.01 ステータスで装備アイテムを描画しなくなります。
 * @author まっつＵＰ
 *
 *
 *
 * @help
 *
 * RPGで笑顔を・・・
 *
 * このヘルプとパラメータの説明をよくお読みになってからお使いください。
 *
 * パラメータとプラグインコマンドともにありません。
 *
 * このプラグインを利用する場合は
 * readmeなどに「まっつＵＰ」の名を入れてください。
 * また、素材のみの販売はダメです。
 * 上記以外の規約等はございません。
 * もちろんツクールMVで使用する前提です。
 * 何か不具合ありましたら気軽にどうぞ。
 *
 * ver1.01 アイテムカテゴリから武器や防具の項目を非表示に。
 *
 * 免責事項：
 * このプラグインを利用したことによるいかなる損害も制作者は一切の責任を負いません。
 *
 */

(function () {

    //var parameters = PluginManager.parameters('hikae');
    //var HBrate = Number(parameters['rate'] || 100);

    Window_ItemCategory.prototype.maxCols = function () {
        return 2; //元は4
    };

    Window_ItemCategory.prototype.makeCommandList = function () {
        this.addCommand(TextManager.item, 'item');
        //this.addCommand(TextManager.weapon,  'weapon');
        //this.addCommand(TextManager.armor,   'armor');
        this.addCommand(TextManager.keyItem, 'keyItem');
    };

    Window_Status.prototype.drawEquipments = function (x, y) {

    };

})();


code:
// EventConditionsEx.js Ver.1.0.1
// MIT License (C) 2022 あわやまたな
// http://opensource.org/licenses/mit-license.php

/*:
* @target MZ MV
* @plugindesc 出現条件をより細かく設定可能になります。
* @author あわやまたな (Awaya_Matana)
* @url https://awaya3ji.seesaa.net/
* @help [出現条件]
* (1) パラメータで設定したスイッチを出現条件に指定します。
* (2) パラメータで設定したラベル名をラベルジャンプとラベルに設定します。
* (3) (2)のラベルジャンプとラベルの間に出現条件を設定します。
*
* ◆注釈：true に到達すると出現条件を満たします。
* ◆注釈：false に到達すると出現条件を満たしません。
* ◆注釈：true に到達しなかった場合も出現条件を満たしません。
* マップイベント、バトルイベントに使用できます。
*
* [スクリプト]
* this.return(true/false); //注釈と同じ扱いです。
*
* [更新履歴]
* 2022/11/13：Ver.1.0.0　公開
* 2022/11/21：Ver.1.0.1　メソッド名変更。
*
* @param labelOfConditions
* @text ラベル名
* @desc 出現条件に利用するラベル名です。
* この名前のラベルジャンプとラベルで出現条件を囲みます。
* @default 出現条件
*
* @param switchId
* @text スイッチID
* @desc 出現条件でこのスイッチを指定した場合、特殊な出現条件を設定可能にします。
* @type switch
* @default 1
*
* @param enableTimerRefresh
* @text タイマーのリフレッシュ有効
* @desc タイマーの数値が変化した瞬間にマップをリフレッシュします。
* これによってタイマーを出現条件に利用する事ができます。
* @type boolean
* @default true
*
*/

'use strict';

{
	const useMZ = Utils.RPGMAKER_NAME === "MZ";
	const pluginName = document.currentScript.src.match(/^.*\/(.*).js$/)[1];
	const hasPluginCommonBase = typeof PluginManagerEx === "function";
	const parameters = PluginManager.parameters(pluginName);
	const switchId = Number(parameters["switchId"]);
	const labelOfConditions = parameters["labelOfConditions"];
	const enableTimerRefresh = parameters["enableTimerRefresh"] === "true";

	//-----------------------------------------------------------------------------
	// Game_EventConditionsEx

	function Game_EventConditionsEx() {
		this.initialize(...arguments);
	}

	Game_EventConditionsEx.prototype = Object.create(Game_Interpreter.prototype);
	Game_EventConditionsEx.prototype.constructor = Game_EventConditionsEx;

	Game_EventConditionsEx.prototype.clear = function () {
		Game_Interpreter.prototype.clear.call(this);
		this._result = false;
	};

	Game_EventConditionsEx.prototype.return = function (value) {
		this._result = value;
		return this.command115();
	};

	Game_EventConditionsEx.prototype.updateWaitCount = function () {
		return false;
	};

	Game_EventConditionsEx.prototype.updateWaitMode = function () {
		return false;
	};

	Game_EventConditionsEx.prototype.command108 = function (params = this._params) {
		const bool = params[0];
		if (bool === "true" || bool === "false") {
			return this.return(bool === "true");
		}
		return Game_Interpreter.prototype.command108.call(this, params);
	};

	//-----------------------------------------------------------------------------
	// Game_Event

	const _Game_Event_meetsConditions = Game_Event.prototype.meetsConditions;
	Game_Event.prototype.meetsConditions = function (page) {
		const c = page.conditions;
		if ((c.switch1Valid && c.switch1Id === switchId) || (c.switch2Valid && c.switch2Id === switchId)) {
			meetsConditionsEx.call(this, page);
		}
		return _Game_Event_meetsConditions.call(this, page);
	};

	//-----------------------------------------------------------------------------
	// Game_Troop

	const _Game_Troop_meetsConditions = Game_Troop.prototype.meetsConditions;
	Game_Troop.prototype.meetsConditions = function (page) {
		const c = page.conditions;
		if (c.switchValid && c.switchId) {
			meetsConditionsEx.call(this, page);
		}
		return _Game_Troop_meetsConditions.call(this, page);
	};

	//-----------------------------------------------------------------------------
	// MeetsConditionsEx

	const interpreter = new Game_EventConditionsEx();
	function meetsConditionsEx(page) {
		if (!page.conditionsEx) {
			createConditionsEx.call(this, page);
		}
		const value = analyzesConditionsEx.call(this, page);
		$gameSwitches.setValue(switchId, value);
	}

	function createConditionsEx(page) {
		const list = page.list;
		const startIndex = findListIndex(list, 119);
		const endIndex = findListIndex(list, 118, startIndex);
		if (startIndex < endIndex) {
			page.conditionsEx = list.slice(startIndex + 1, endIndex);
		} else {
			page.conditionsEx = [];
		}
	}
	function analyzesConditionsEx(page) {
		const list = page.conditionsEx;
		interpreter.setup(list, this._eventId);
		while (interpreter.isRunning()) {
			interpreter.update();
		}
		return interpreter._result;
	}

	function findListIndex(list, code, startIndex = 0) {
		if (startIndex === -1) return -1;
		for (let i = startIndex; i < list.length; i++) {
			const command = list[i];
			if (command.code === code && command.parameters[0] === labelOfConditions) {
				return i;
			}
		}
		return -1
	}

	//-----------------------------------------------------------------------------
	// Game_Timer

	if (enableTimerRefresh) {

		const _Game_Timer_initialize = Game_Timer.prototype.initialize;
		Game_Timer.prototype.initialize = function () {
			_Game_Timer_initialize.call(this);
			this._lastSeconds = 0;
		};

		const _Game_Timer_start = Game_Timer.prototype.start;
		Game_Timer.prototype.start = function (count) {
			_Game_Timer_start.call(this, count);
			$gameMap.requestRefresh();
		};

		const _Game_Timer_stop = Game_Timer.prototype.stop;
		Game_Timer.prototype.stop = function () {
			_Game_Timer_stop.call(this);
			$gameMap.requestRefresh();
		};

		const _Game_Timer_update = Game_Timer.prototype.update;
		Game_Timer.prototype.update = function (sceneActive) {
			const lastFrames = this._frames;
			_Game_Timer_update.call(this, sceneActive);
			if (sceneActive && this._working) {
				const sec = $gameTimer.seconds();
				if (sec !== this._lastSeconds || lastFrames !== this._frames && this._frames === 0) {
					$gameMap.requestRefresh();
				}
				this._lastSeconds = sec;
			}
		};
	}

}


code:
//=============================================================================
// EventItemCondition.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015-2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.0.1 2017/01/12 メモ欄の値が空で設定された場合にエラーが発生するかもしれない問題を修正
// 1.0.0 2016/09/16 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc EventItemConditionPlugin
 * @author triacontane
 *
 * @param DefaultVisible
 * @desc メモ欄が指定されていないアイテムの表示可否です。OFFにするとメモ欄に指定がないアイテムは表示されません。
 * @default ON
 *
 * @help イベントコマンド「アイテム選択の処理」において
 * 表示可否の条件をアイテムごとに設定できます。
 * 対象アイテムのメモ欄に以下の通り設定してください。
 *
 * <EICSwitch:1>     # スイッチ[1]がONのときのみ表示対象
 * <EICScript:s>     # 評価結果がtrueのときのみ表示
 * スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → <
 * > → >
 * 例：<EICスクリプト:\v[1] > 10> // 変数[1]が10より大きい場合
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc アイテム選択の表示条件プラグイン
 * @author トリアコンタン
 *
 * @param デフォルト表示可否
 * @desc メモ欄が指定されていないアイテムの表示可否です。OFFにするとメモ欄に指定がないアイテムは表示されません。
 * @default ON
 *
 * @help イベントコマンド「アイテム選択の処理」において
 * 表示可否の条件をアイテムごとに設定できます。
 * 対象アイテムのメモ欄に以下の通り設定してください。
 *
 * <EICスイッチ:1>   # スイッチ[1]がONのときのみ表示対象
 * <EICSwitch:1>     # 同上
 * <EICスクリプト:s> # 評価結果がtrueのときのみ表示
 * <EICScript:s>     # 同上
 * スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → <
 * > → >
 * 例：<EICスクリプト:\v[1] > 10> // 変数[1]が10より大きい場合
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    var pluginName = 'EventItemCondition';
    var metaTagPrefix = 'EIC';

    var getParamOther = function (paramNames) {
        if (!Array.isArray(paramNames)) paramNames = [paramNames];
        for (var i = 0; i < paramNames.length; i++) {
            var name = PluginManager.parameters(pluginName)[paramNames[i]];
            if (name) return name;
        }
        return null;
    };

    var getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON';
    };

    var getArgString = function (arg, upperFlg) {
        arg = convertEscapeCharacters(arg);
        return upperFlg ? arg.toUpperCase() : arg;
    };

    var getArgNumber = function (arg, min, max) {
        if (arguments.length < 2) min = -Infinity;
        if (arguments.length < 3) max = Infinity;
        return (parseInt(convertEscapeCharacters(arg), 10) || 0).clamp(min, max);
    };

    var getMetaValue = function (object, name) {
        var metaTagName = metaTagPrefix + (name ? name : '');
        return object.meta.hasOwnProperty(metaTagName) ? object.meta[metaTagName] : undefined;
    };

    var getMetaValues = function (object, names) {
        if (!Array.isArray(names)) return getMetaValue(object, names);
        for (var i = 0, n = names.length; i < n; i++) {
            var value = getMetaValue(object, names[i]);
            if (value !== undefined) return value;
        }
        return undefined;
    };

    var convertEscapeCharacters = function (text) {
        if (text == null || text === true) text = '';
        text = text.replace(/>?/gi, '>');
        text = text.replace(/<?/gi, '<');
        var windowLayer = SceneManager._scene._windowLayer;
        return windowLayer ? windowLayer.children[0].convertEscapeCharacters(text) : text;
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramDefaultVisible = getParamBoolean(['DefaultVisible', 'デフォルト表示可否']);

    //=============================================================================
    // Window_EventItem
    //  アイテム選択ウィンドウに条件を設定します。
    //=============================================================================
    var _Window_EventItem_includes = Window_EventItem.prototype.includes;
    Window_EventItem.prototype.includes = function (item) {
        var result = _Window_EventItem_includes.apply(this, arguments);
        if (result) {
            this._existCondition = false;
            result = this.isOkEventItemSwitch(item) && this.isOkEventItemScript(item);
            if (!this._existCondition) result = paramDefaultVisible;
        }
        return result;
    };

    Window_EventItem.prototype.isOkEventItemSwitch = function (item) {
        var metaValue = getMetaValues(item, ['スイッチ', 'Switch']);
        if (metaValue) {
            this._existCondition = true;
            return $gameSwitches.value(getArgNumber(metaValue, 1));
        }
        return true;
    };

    Window_EventItem.prototype.isOkEventItemScript = function (item) {
        var metaValue = getMetaValues(item, ['スクリプト', 'Script']);
        if (metaValue) {
            this._existCondition = true;
            return eval(getArgString(metaValue));
        }
        return true;
    };
})();