code:
//=============================================================================
// ParallelBgs.js
// ----------------------------------------------------------------------------
// Copyright (c) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.0.3 2020/02/02 ヘルプのプラグインコマンド「PB_BGSライン変更」が間違っていたので「PB_BGS_ライン変更」に修正(コード修正なし)
// 1.0.2 2017/01/05 BGSの演奏状態によっては、セーブ＆ロードした際に一部のBGSが演奏されなくなる現象の修正(byくらむぼん氏)
// 1.0.1 2016/11/16 BGSをプレーしていない状態でセーブ＆ロードするとエラーになる現象の修正
// 1.0.0 2016/11/12 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc ParallelBgsPlugin
 * @author triacontane
 *
 * @help 複数のBGSを並行して演奏できます。プラグインコマンドからBGSの演奏ラインを
 * 変更すると元のBGSを演奏したまま、新しくBGSを演奏することができます。
 * 並行演奏しているBGSはそれぞれ個別に、音量やピッチ、左右バランスを調節できます。
 * 演奏ラインのデフォルトは[1]です。
 *
 * ラインの数に制限はありませんが、あまりに大量のBGSを
 * 同時に演奏しようとすると動作に影響がでる恐れがあります。
 *
 * なお、マップで指定するオート演奏のBGSはラインが[1]で固定になります。
 *
 * 追加機能として、BGS演奏中にSEを演奏すると自動でBGSを一時フェードアウトする
 * プラグインコマンドを提供します。SEがより明瞭に聴き取れるようになります。
 * フェードアウト時間やSEの演奏タイミングを設定することもできます。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * PB_BGS_ライン変更 2              # BGSの演奏ラインを[2]に変更します。
 * PB_BGS_CHANGE_LINE 2            # 同上
 * PB_BGS_全停止                   # 全ての演奏中のBGSを停止します。
 * PB_BGS_ALL_STOP                 # 同上
 * PB_BGS_SE演奏時フェードアウト 1 # SE演奏時にBGSを自動フェードアウトします
 * PB_BGS_FADEOUT_FOR_SE 1         # 同上(※1)
 * PB_BGS_フェードアウト時間 3     # 自動フェードアウトに掛かる時間を指定します。
 * PB_BGS_FADEOUT_TIME 3           # 同上
 *
 * ※1 フェードアウト方法を指定できます。
 *  0 : フェードアウトせずに通常通りSEを演奏します。
 *  1 : SE演奏と同時にフェードアウトを開始します。
 *  2 : フェードアウトが完了してからSE演奏します。
 *
 * 2の設定はSEの演奏を実行してから、実際に演奏されるまで時間が掛かります。
 * 使いどころにご注意ください。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc BGS並行演奏プラグイン
 * @author トリアコンタン
 *
 * @help 複数のBGSを並行して演奏できます。プラグインコマンドからBGSの演奏ラインを
 * 変更すると元のBGSを演奏したまま、新しくBGSを演奏することができます。
 * 並行演奏しているBGSはそれぞれ個別に、音量やピッチ、左右バランスを調節できます。
 * 演奏ラインのデフォルトは[1]です。
 *
 * ラインの数に制限はありませんが、あまりに大量のBGSを
 * 同時に演奏しようとすると動作に影響がでる恐れがあります。
 *
 * なお、マップで指定するオート演奏のBGSはラインが[1]で固定になります。
 *
 * 追加機能として、BGS演奏中にSEを演奏すると自動でBGSを一時フェードアウトする
 * プラグインコマンドを提供します。SEがより明瞭に聴き取れるようになります。
 * フェードアウト時間やSEの演奏タイミングを設定することもできます。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * PB_BGS_ライン変更 2              # BGSの演奏ラインを[2]に変更します。
 * PB_BGS_CHANGE_LINE 2            # 同上
 * PB_BGS_全停止                   # 全ての演奏中のBGSを停止します。
 * PB_BGS_ALL_STOP                 # 同上
 * PB_BGS_SE演奏時フェードアウト 1 # SE演奏時にBGSを自動フェードアウトします
 * PB_BGS_FADEOUT_FOR_SE 1         # 同上(※1)
 * PB_BGS_フェードアウト時間 3     # 自動フェードアウトに掛かる時間を指定します。
 * PB_BGS_FADEOUT_TIME 3           # 同上
 *
 * ※1 フェードアウト方法を指定できます。
 *  0 : フェードアウトせずに通常通りSEを演奏します。
 *  1 : SE演奏と同時にフェードアウトを開始します。
 *  2 : フェードアウトが完了してからSE演奏します。
 *
 * 2の設定はSEの演奏を実行してから、実際に演奏されるまで時間が掛かります。
 * 使いどころにご注意ください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    var metaTagPrefix = 'PB_';

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

    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 convertEscapeCharacters = function (text) {
        if (text == null) text = '';
        var windowLayer = SceneManager._scene._windowLayer;
        return windowLayer ? windowLayer.children[0].convertEscapeCharacters(text) : text;
    };

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        if (!command.match(new RegExp('^' + metaTagPrefix))) return;
        this.pluginCommandParallelBgs(command.replace(metaTagPrefix, ''), args);
    };

    Game_Interpreter.prototype.pluginCommandParallelBgs = function (command, args) {
        switch (getCommandName(command)) {
            case 'BGS_CHANGE_LINE':
            case 'BGS_ライン変更':
                $gameSystem.setBgsLine(getArgNumber(args[0], 1));
                break;
            case 'BGS_ALL_STOP':
            case 'BGS_全停止':
                AudioManager.stopAllBgs();
                break;
            case 'BGS_FADEOUT_FOR_SE':
            case 'BGS_SE演奏時フェードアウト':
                $gameSystem.setBgsFadeForSe(getArgNumber(args[0], 0));
                break;
            case 'BGS_FADEOUT_TIME':
            case 'BGS_フェードアウト時間':
                $gameSystem.setBgsFadeTime(getArgNumber(args[0], 1));
                break;
        }
    };

    //=============================================================================
    // Game_System
    //  BGS演奏ラインを変更します。
    //=============================================================================
    var _Game_System_initialize = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function () {
        _Game_System_initialize.apply(this, arguments);
        this.initBgsMember();
    };

    Game_System.prototype.initBgsMember = function () {
        this.setBgsLine(this.getBgsLine());
        this.setBgsFadeForSe(this.getBgsFadeForSe());
        this.setBgsFadeTime(this.getBgsFadeTime());
    };

    Game_System.prototype.getBgsLine = function () {
        return this._bgsLine || 1;
    };

    Game_System.prototype.setBgsLine = function (value) {
        this._bgsLine = value;
        AudioManager.setBgsLineIndex(value);
    };

    Game_System.prototype.getBgsFadeForSe = function () {
        return this._bgsFadeForPlayingSe || 0;
    };

    Game_System.prototype.setBgsFadeForSe = function (value) {
        this._bgsFadeForPlayingSe = value;
        AudioManager.setBgsFadeForSe(value);
    };

    Game_System.prototype.getBgsFadeTime = function () {
        return this._bgsFadeTime || 1;
    };

    Game_System.prototype.setBgsFadeTime = function (value) {
        this._bgsFadeTime = value;
        AudioManager.setBgsFadeTime(value);
    };

    var _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
    Game_System.prototype.onAfterLoad = function () {
        _Game_System_onAfterLoad.apply(this, arguments);
        this.initBgsMember();
    };

    var _Game_Map_autoplay = Game_Map.prototype.autoplay;
    Game_Map.prototype.autoplay = function () {
        AudioManager.multiLineDisable = true;
        _Game_Map_autoplay.apply(this, arguments);
        AudioManager.multiLineDisable = false;
    };

    //=============================================================================
    // AudioManager
    //  複数のBGS演奏ラインを管理します。
    //=============================================================================
    AudioManager.multiLineDisable = false;
    AudioManager._bgsLineIndex = 1;
    AudioManager._bgsFadeForSe = 0;
    AudioManager._bgsFadeTime = 1;
    AudioManager._allBgsBuffer = [];
    AudioManager._currentAllBgs = [];
    AudioManager._delaySeStack = [];
    AudioManager._allStop = false;
    AudioManager._stopAllBgs = true;
    AudioManager._bgsFading = false;
    AudioManager._bgsFadeCounter = 0;

    var _AudioManager_bgsVolume = Object.getOwnPropertyDescriptor(AudioManager, 'bgsVolume');
    Object.defineProperty(AudioManager, 'bgsVolume', {
        get: function () {
            return _AudioManager_bgsVolume.get.call(this);
        },
        set: function (value) {
            _AudioManager_bgsVolume.set.call(this, value);
            var nowBgs = this._currentBgs;
            this.iterateAllBgs(function () {
                if (nowBgs !== this._currentBgs) this.updateBgsParameters(this._currentBgs);
            }.bind(this));
        },
        configurable: true
    });

    Object.defineProperty(AudioManager, '_bgsBuffer', {
        get: function () {
            return this._allBgsBuffer[this.getBgsLineIndex()];
        },
        set: function (value) {
            this._allBgsBuffer[this.getBgsLineIndex()] = value;
        }
    });

    Object.defineProperty(AudioManager, '_currentBgs', {
        get: function () {
            return this._currentAllBgs[this.getBgsLineIndex()];
        },
        set: function (value) {
            this._currentAllBgs[this.getBgsLineIndex()] = value;
        }
    });

    AudioManager.getBgsLineIndex = function () {
        return this.multiLineDisable ? 1 : this._bgsLineIndex;
    };

    AudioManager.setBgsLineIndex = function (index) {
        this._bgsLineIndex = index;
    };

    AudioManager.setBgsFadeForSe = function (value) {
        this._bgsFadeForSe = value;
    };

    AudioManager.setBgsFadeTime = function (value) {
        this._bgsFadeTime = value;
    };

    var _AudioManager_playBgs = AudioManager.playBgs;
    AudioManager.playBgs = function (bgs, pos) {
        if (!bgs) return;
        this._stopAllBgs = false;
        if (Array.isArray(bgs)) {
            this.playAllBgs(bgs);
        } else {
            _AudioManager_playBgs.apply(this, arguments);
        }
        this._stopAllBgs = true;
    };

    AudioManager.playAllBgs = function (bgsArray) {
        this.stopAllBgs();
        var prevIndex = this._bgsLineIndex;
        this._bgsLineIndex = 1;
        bgsArray.forEach(function (bgs, index) {
            this._bgsLineIndex = index;
            this.playBgs(bgs, null);
        }, this);
        this._bgsLineIndex = prevIndex;
    };

    var _AudioManager_replayBgs = AudioManager.replayBgs;
    AudioManager.replayBgs = function (bgs) {
        if (!bgs) return;
        if (Array.isArray(bgs)) {
            this.replayAllBgs(bgs);
        } else {
            _AudioManager_replayBgs.apply(this, arguments);
        }
    };

    AudioManager.replayAllBgs = function (bgsArray) {
        this.stopAllBgs();
        var prevIndex = this._bgsLineIndex;
        this._bgsLineIndex = 1;
        bgsArray.forEach(function (bgs, index) {
            this._bgsLineIndex = index;
            this.replayBgs(bgs);
        }, this);
        this._bgsLineIndex = prevIndex;
    };

    var _AudioManager_saveBgs = AudioManager.saveBgs;
    AudioManager.saveBgs = function () {
        var bgsArray = [];
        this.iterateAllBgs(function () {
            bgsArray[this._bgsLineIndex] = _AudioManager_saveBgs.apply(this, arguments);
        }.bind(this));
        return bgsArray.length > 1 ? bgsArray : bgsArray[0];
    };

    var _AudioManager_stopBgs = AudioManager.stopBgs;
    AudioManager.stopBgs = function () {
        if (!this._stopAllBgs) {
            _AudioManager_stopBgs.apply(this, arguments);
        } else {
            this.stopAllBgs();
        }
    };

    AudioManager.stopAllBgs = function () {
        this.iterateAllBgs(function () {
            _AudioManager_stopBgs.apply(this, arguments);
        }.bind(this));
    };

    var _AudioManager_fadeOutBgs = AudioManager.fadeOutBgs;
    AudioManager.fadeOutBgs = function (time) {
        this.iterateAllBgs(function () {
            _AudioManager_fadeOutBgs.call(this, time);
        }.bind(this));
    };

    AudioManager.iterateAllBgs = function (callBack) {
        var prevIndex = this._bgsLineIndex;
        Object.keys(this._allBgsBuffer).forEach(function (index) {
            this._bgsLineIndex = index;
            callBack(this._bgsBuffer);
        }, this);
        this._bgsLineIndex = prevIndex;
    };

    var _AudioManager_playSe = AudioManager.playSe;
    AudioManager.playSe = function (se) {
        if (this.isNeedFadeOut()) {
            this.fadeOutBgsForSe();
        }
        if (this._bgsFadeForSe === 2 && this._currentBgs && this._bgsFadeCounter > 0) {
            this._delaySeStack.push(se);
        } else {
            _AudioManager_playSe.apply(this, arguments);
        }
    };

    AudioManager.updateBgsFade = function () {
        if (this.isNeedFadeIn()) {
            this.fadeInBgsForSe();
        }
        if (this._bgsFadeCounter > 0) {
            this._bgsFadeCounter--;
            if (this._bgsFadeCounter === 0) {
                this.playDelayedSe();
            }
        }
    };

    AudioManager.fadeOutBgsForSe = function () {
        var prevCurrentBgs = this._currentBgs;
        this.fadeOutBgs(this._bgsFadeTime);
        this._currentBgs = prevCurrentBgs;
        this._bgsFading = true;
        this._bgsFadeCounter = this._bgsFadeTime * 60;
    };

    AudioManager.isNeedFadeOut = function () {
        return !this._bgsFading && this._bgsFadeForSe !== 0;
    };

    AudioManager.fadeInBgsForSe = function () {
        this.fadeInBgs(this._bgsFadeTime);
        this._bgsFading = false;
        this._bgsFadeCounter = 0;
    };

    AudioManager.isNeedFadeIn = function () {
        return this._bgsFading && !this.isPlayingAnySe() && this._bgsFadeCounter === 0;
    };

    AudioManager.playDelayedSe = function () {
        while (this._delaySeStack.length > 0) {
            _AudioManager_playSe.call(this, this._delaySeStack.pop());
        }
    };

    AudioManager.isPlayingAnySe = function () {
        return this._seBuffers.some(function (audio) {
            return audio.isExist();
        });
    };

    //=============================================================================
    // WebAudio
    //  演奏が要求済みかどうかを返します。
    //=============================================================================
    WebAudio.prototype.isExist = function () {
        return this._autoPlay;
    };

    //=============================================================================
    // SceneManager
    //  AudioManagerの更新処理を呼び出します。
    //=============================================================================
    var _SceneManager_updateScene = SceneManager.updateScene;
    SceneManager.updateScene = function () {
        _SceneManager_updateScene.apply(this, arguments);
        if (this._scene) {
            AudioManager.updateBgsFade();
        }
    };
})();


code:
//=============================================================================
// ParallelParty.js
// ----------------------------------------------------------------------------
// (C) 2017 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.3.0 2019/01/02 用語辞典プラグイン使用時に用語履歴を常に継承できるよう修正
// 1.2.1 2017/12/08 SceneGlossary.jsとの間で発生する可能性のある競合を解消
// 1.2.0 2017/05/15 パーティを切り替えた際にリソースを統合できる機能を追加
// 1.1.0 2017/05/13 パーティ間でリソースを共有する設定を追加、各パーティのマップ座標を記憶して自働で場所移動する機能を追加
// 1.0.0 2017/05/09 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc ParallelPartyPlugin
 * @author triacontane
 *
 * @param ShareResource
 * @desc 異なるパーティでもリソース(アイテム、武器、防具、お金、歩数)を共有します。(ON/OFF)
 * @default OFF
 *
 * @param SavePosition
 * @desc パーティを切り替えたときに元の位置を保存し、元のパーティに戻したときに自働で場所移動します。
 * @default OFF
 *
 * @help 複数のパーティを同時に管理できます。
 * 各パーティは「パーティID」で管理され、初期状態のパーティIDは「0」です。
 * それぞれ所持金やアイテムが別々に管理され、プラグインコマンドで
 * 別のパーティに交代できます。
 *
 * 新しいパーティに移った直後はメンバーが0人の状態なので
 * イベント「メンバーの入れ替え」でアクターを追加してください。
 *
 * アクターの情報は共有しているので、他のパーティに加入しているアクターを
 * 別のパーティに入れた場合、状態を引き継ぎます。
 *
 * 戦闘中のパーティの入れ替えはできません。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * PP_パーティ変更 1 OFF # パーティを[1]に変更します。
 * PP_CHANGE_PARTY 1 OFF # 同上
 * PP_パーティ変更 1 ON  # パーティを[1]に変更してリソースを統合します。
 * PP_CHANGE_PARTY 1 ON  # 同上
 *
 * リソース統合をONにすると、所持アイテムやお金を合流先のパーティと統合します。
 * 別々に行動していた複数のパーティがひとつに合流する際などに使用します。
 * リソース共有のパラメータが有効な場合、統合は行われません。
 *
 * This plugin is released under the MIT License.
 */

/*:ja
 * @plugindesc 並列パーティプラグイン
 * @author トリアコンタン
 *
 * @param リソース共有
 * @desc 異なるパーティでもリソース(アイテム、武器、防具、お金、歩数)を共有します。(ON/OFF)
 * @default OFF
 *
 * @param パーティ位置を保持
 * @desc パーティを切り替えたときに元の位置を保存し、元のパーティに戻したときに自働で場所移動します。
 * @default OFF
 *
 * @help 複数のパーティを同時に管理できます。
 * 各パーティは「パーティID」で管理され、初期状態のパーティIDは「0」です。
 * それぞれ所持金やアイテムが別々に管理され、プラグインコマンドで
 * 別のパーティに交代できます。
 *
 * 新しいパーティに移った直後はメンバーが0人の状態なので
 * イベント「メンバーの入れ替え」でアクターを追加してください。
 *
 * アクターの情報は共有しているので、他のパーティに加入しているアクターを
 * 別のパーティに入れた場合、状態を引き継ぎます。
 *
 * 戦闘中のパーティの入れ替えはできません。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * PP_パーティ変更 1 OFF # パーティを[1]に変更します。
 * PP_CHANGE_PARTY 1 OFF # 同上
 * PP_パーティ変更 1 ON  # パーティを[1]に変更してリソースを統合します。
 * PP_CHANGE_PARTY 1 ON  # 同上
 *
 * リソース統合をONにすると、所持アイテムやお金を合流先のパーティと統合します。
 * 別々に行動していた複数のパーティがひとつに合流する際などに使用します。
 * リソース共有のパラメータが有効な場合、統合は行われません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

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

(function () {
    'use strict';
    var pluginName = 'ParallelParty';
    var metaTagPrefix = 'PP_';

    //=============================================================================
    // ローカル関数
    //  プラグインパラメータやプラグインコマンドパラメータの整形やチェックをします
    //=============================================================================
    var getParamString = 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 '';
    };

    var getParamBoolean = function (paramNames) {
        var value = getParamString(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(arg) || 0).clamp(min, max);
    };

    var getArgBoolean = function (arg) {
        return arg.toUpperCase() === 'ON';
    };

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

    var isNotAString = function (args) {
        return String(args) !== args;
    };

    var convertAllArguments = function (args) {
        for (var i = 0; i < args.length; i++) {
            args[i] = convertEscapeCharacters(args[i]);
        }
        return args;
    };

    var setPluginCommand = function (commandName, methodName) {
        pluginCommandMap.set(metaTagPrefix + commandName, methodName);
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var pluginCommandMap = new Map();
    setPluginCommand('パーティ変更', 'execChangeParty');
    setPluginCommand('CHANGE_PARTY', 'execChangeParty');

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var param = {};
    param.shareResource = getParamBoolean(['ShareResource', 'リソース共有']);
    param.savePosition = getParamBoolean(['SavePosition', 'パーティ位置を保持']);

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

    Game_Interpreter.prototype.execChangeParty = function (args) {
        if ($gameParty.inBattle()) return;
        $gameSystem.changeParty(getArgNumber(args[0], 0), getArgBoolean(args[1] || ''));
        if (!$gamePlayer.isTransferring()) {
            $gamePlayer.refresh();
            $gameMap.requestRefresh();
        } else {
            this.setWaitMode('transfer');
        }
    };

    //=============================================================================
    // Game_System
    //  Game_Partiesを生成します。
    //=============================================================================
    Game_System.prototype.changeParty = function (partyId, resourceCombine) {
        if (!this._parties) {
            this._parties = new Game_Parties();
        }
        this._parties.change(partyId, resourceCombine);
    };

    //=============================================================================
    // Game_Party
    //  リソースの引き継ぎと位置の保存を追加定義します。
    //=============================================================================
    Game_Party.prototype.getAllResources = function () {
        return {
            items: this._items,
            weapons: this._weapons,
            armors: this._armors,
            gold: this._gold,
            steps: this._steps,
            itemHistory: this._itemHistory,
            weaponHistory: this._weaponHistory,
            armorHistory: this._armorHistory
        };
    };

    Game_Party.prototype.inheritAllResources = function (prevParty) {
        var resources = prevParty.getAllResources();
        this._items = resources.items;
        this._weapons = resources.weapons;
        this._armors = resources.armors;
        this._gold = resources.gold;
        this._steps = resources.steps;
        this.inheritItemHistory(prevParty);
    };

    Game_Party.prototype.combineAllResources = function (targetParty) {
        var resources = targetParty.getAllResources();
        Object.keys(resources.items).forEach(function (id) {
            this.gainItem($dataItems[id], resources.items[id], false);
        }, this);
        Object.keys(resources.weapons).forEach(function (id) {
            this.gainItem($dataWeapons[id], resources.weapons[id], false);
        }, this);
        Object.keys(resources.armors).forEach(function (id) {
            this.gainItem($dataArmors[id], resources.armors[id], false);
        }, this);
        this.gainGold(resources.gold);
        this._steps += resources.steps;
        $gameParty.initAllItems();
        $gameParty.loseGold($gameParty.maxGold());
        $gameParty._steps = 0;
    };

    // for SceneGlossary.js
    Game_Party.prototype.inheritItemHistory = function (prevParty) {
        var resources = prevParty.getAllResources();
        this._itemHistory = resources.itemHistory;
        this._weaponHistory = resources.weaponHistory;
        this._armorHistory = resources.armorHistory;
    };

    Game_Party.prototype.moveSavedPosition = function () {
        if (!this._savedMapId) return;
        $gamePlayer.reserveTransfer(this._savedMapId, this._savedX, this._savedY, this._savedDirection, 2);
    };

    Game_Party.prototype.savePosition = function () {
        this._savedMapId = $gameMap.mapId();
        this._savedX = $gamePlayer.x;
        this._savedY = $gamePlayer.y;
        this._savedDirection = $gamePlayer.direction();
    };

    //=============================================================================
    // Game_Parties
    //  複数のパーティを管理します。
    //=============================================================================
    Game_Parties.prototype.initialize = function () {
        this._data = [$gameParty];
        this._partyId = 0;
    };

    Game_Parties.prototype.createPartyIfNeed = function () {
        if (!this.isExistParty()) {
            this._data[this._partyId] = new Game_Party();
        }
    };

    Game_Parties.prototype.isExistParty = function () {
        return !!this.getCurrentParty();
    };

    Game_Parties.prototype.getCurrentParty = function () {
        return this._data[this._partyId];
    };

    Game_Parties.prototype.change = function (partyId, resourceCombine) {
        if (this._partyId === partyId) return;
        this._partyId = partyId;
        this.createPartyIfNeed();
        var currentParty = this.getCurrentParty();
        if (param.shareResource) {
            currentParty.inheritAllResources($gameParty);
        } else if (resourceCombine) {
            currentParty.combineAllResources($gameParty);
        } else {
            currentParty.inheritItemHistory($gameParty);
        }
        if (param.savePosition) {
            this.moveSavedPosition();
        }
        $gameParty = currentParty;
    };

    Game_Parties.prototype.moveSavedPosition = function () {
        $gameParty.savePosition();
        var currentParty = this.getCurrentParty();
        currentParty.moveSavedPosition();
    };
})();

repo_name: dazed/translations

license: unknown


code:
//
//  パッシブスキル ver1.061
//
// author yana
//

var Imported = Imported || {};
Imported['yPassiveSkill'] = 1.061;

/*:
 * @plugindesc ver1.061/スキルに特徴を設定できるようにします。
 * @author Yana
 *
 * @param Passive Skill Type ID
 * @desc パッシブスキルとして扱うスキルタイプID。
 * ここで設定されたIDのスキルタイプは、戦闘時に表示されません。
 * @default 3
 *
 * @param Add Multi Order
 * @desc パラメータの加算と乗算の順番。
 * trueだと加算→乗算、falseだと乗算→加算になります。
 * @default true
 *
 * @help------------------------------------------------------
 *  プラグインコマンドはありません。
 * ------------------------------------------------------
 * ------------------------------------------------------
 * 設定方法
 * ------------------------------------------------------
 * ・攻撃力や最大HP等のパラメータが1つのパッシブスキルの設定
 * <パッシブスキル:xxx+y>
 * <パッシブスキル:xxx-y>
 * <パッシブスキル:xxx+y%>
 * <パッシブスキル:xxx-y%>
 * <パッシブスキル:xxxy>
 * xxxのステータスをyポイント(%)増加(減少)させます。
 * ※最大HP、最大MP、攻撃力、防御力、魔法力、魔法防御、敏捷性、運の通常のパラメータのいずれかの場合、
 * %が付いていない時はその数値通りの値が適用されます。
 * %が付いている時は、その数値に100を加算し、算出した数値を通常の特徴で設定した時と同じように適用します。
 *
 * ※命中率、回避率、会心率、会心回避、魔法回避、魔法反射、反撃率、HP再生率、MP再生率、
 * 	TP再生率の等のExパラメータのいずれかの場合、
 * %が付いている時と%がついてない時の動作は同じになります。
 *
 * ※狙われ率、防御効果率、回復効果率、薬の知識、MP消費率、TPチャージ率、物理ダメージ率、
 * 	 魔法ダメージ率、床ダメージ率、経験値獲得率等ののSPパラメータのいずれかの場合、
 * %が付いていない時はその数値通りの値が適用されます。
 * %が付いている時は、その数値に100を加算し、算出した数値を通常の特徴で設定した時と同じように適用します。
 *
 * ※ステート無効化、攻撃時属性、攻撃速度補正、攻撃追加回数、スキルタイプ追加、スキルタイプ封印、スキル追加、
 * スキル封印、武器タイプ装備、防具タイプ装備、装備固定、装備封印、行動回数追加　のいずれかの場合も、これで設定します。
 * これらは%が付いていても付いていなくても同じです。
 *
 * 例：
 * <パッシブスキル:最大HP+50>
 * 最大HPが50ポイント増加します。
 *
 * <パッシブスキル:攻撃力+20%>
 * 特徴、攻撃力120%と同じ意味です。
 *
 * <パッシブスキル:命中率+20%>
 * <パッシブスキル:命中率+20>
 * 特徴、命中率+20%と同じ意味です。
 *
 * <パッシブスキル:狙われ率+30>
 * 狙われ率が30%増加します。
 *
 * <パッシブスキル:狙われ率+30%>
 * 特徴、狙われ率130%と同じ意味です。
 *
 * <パッシブスキル:ステート無効化5>
 * 特徴、ステート無効化5番のステートと同じ意味です。
 *
 * <パッシブスキル:行動回数追加+20%>
 * 特徴、行動回数追加20%と同じ意味です。
 *
 * ・属性有効度やステート有効度などのパラメータが2つのパッシブスキルの設定
 * <パッシブスキル:xxxy+z>
 * <パッシブスキル:xxxy―z>
 * <パッシブスキル:xxxy+z%>
 * <パッシブスキル:xxxy―z%>
 * xxxのy番のレートをz(%)増加(減少)します。
 * ※属性有効度、弱体有効度、ステート有効度のいずれかの場合、
 * %が付いていない時は、その数値の値を直接加算(減算)します。
 * %が付いている時は、その数値に100を加算し、算出した数値を通常の特徴で設定した時と同じように適用します。
 *
 * ※攻撃時ステートの場合、%が付いていても付いていなくても同じです。
 *
 * 例:
 * <パッシブスキル:属性有効度4-30%>
 * 特徴、属性有効度4番の属性70%と同じ意味です。
 *
 * <パッシブスキル:属性有効度4-30>
 * 4番の属性の属性有効度を30%減少させます。
 *
 * ・二刀流や自動戦闘など、パラメータを持たないパッシブスキルの設定
 * <パッシブスキル:xxx>
 * xxxの特徴を付与します。
 *
 * 例:
 * <パッシブスキル:二刀流>
 * 特徴、スロットタイプ二刀流と同じ意味です。
 *
 * <パッシブスキル:自動戦闘>
 * 特徴、特殊フラグ自動戦闘と同じ意味です。
 *
 * ------------------------------------------------------
 * 仕様と解説
 * ------------------------------------------------------
 * ・特徴で追加されたスキルはパッシブスキルとして機能しません。
 * ・AddMultiOrderがtrueだと、加算の計算→乗算の計算となるので、攻撃力100で攻撃力+50と攻撃力+50%の特徴を持っていた場合、
 * (100+50)x1.5=225となります。
 * falseの場合は、乗算→加算と計算されるので、
 * 100x1.5+50=200となります。
 * ・対応するスキルタイプが封印されたり、パッシブスキル自体が封印された場合、そのスキルは効果がなくなります。
 * ・必要武器タイプが設定されていた場合、それらの条件を満たしていないとそのスキルは効果がなくなります。
 * ・PassiveSkillTypeIDで指定したスキルタイプでないとパッシブスキルとして機能しない、という事はありません。
 * ・PassiveSkillTypeIDはあくまで、戦闘中に表示しないスキルタイプのIDというのみです。
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.061:
 * ステータスクラス+クラスチェンジシーンと併用時、レベルアップ時に無限ループに入ってしまうバグを修正。
 * ver1.06:
 * イベントコマンドでスキルを習得した際、パッシブスキルが反映されないバグを修正。
 * ver1.051:
 * console.logを削除。
 * ver1.05:
 * いくつかの記述ミスを修正。
 * 機能していなかったプラグインパラメータを削除。
 * ver1.04:
 * 最大MPのキーワードが間違っていたバグを修正。
 * システムで設定した用語でのパッシブスキル化が正常に機能していなかったバグを修正。
 * ver1.03:
 * 特徴を持っていないスキルもパッシブスキルとして判定されていたバグを修正。
 * sparamの数値が100%基準になっていなかったバグを修正。
 * ver1.02:
 * PassiveSkillManagerをfunctionの外に移動
 * ver1.01:
 * パッシブスキルのスキルタイプが一番上に追加されていると、正常に非表示にできないバグを修正。
 * ver1.00:
 * 公開
 */

function PassiveSkillManager() {
	throw new Error('This is a static class');
};

(function () {

	var parameters = PluginManager.parameters('PassiveSkill');
	var passiveSkillTypeId = Number(parameters['Passive Skill Type ID']);
	var addMultiOrder = String(parameters['Add Multi Order']) === 'true';

	PassiveSkillManager.checkPassive = function (text) {
		if (text.match(/<(?:パッシブスキル|パッシブ|passive|PS):(.+)>/)) {
			var reg = RegExp.$1;
			var trait = this.makePassive('<' + reg + '>');
			if (trait) { return trait }
		}
		return false;
	};

	PassiveSkillManager.makePassive = function (reg) {
		if (reg.match(/<(.+?)(\d+),?([+-]\d+)(%)?>/)) {
			return this.makeNumTrait([RegExp.$1, RegExp.$2, RegExp.$3, RegExp.$4]);
		} else if (reg.match(/<(.+?),?([+-]?\d+)(%)?>/)) {
			return this.makeParamTrait([RegExp.$1, RegExp.$2, RegExp.$3]);
		} else if (reg.match(/<(.+)>/)) {
			return this.makeExTrait(RegExp.$1);
		}

		return false;
	};

	PassiveSkillManager.makeNumTrait = function (ary) {
		var code = null;
		var id = parseInt(ary[1]);
		var value = parseInt(ary[2]);
		var parc = ary[3];
		switch (ary[0]) {
			case '属性有効度':
			case 'ElementRate':
				code = parc == '' ? 111 : 11;
				break;
			case '弱体有効度':
			case 'DebuffRate':
				code = parc == '' ? 112 : 12;
				break;
			case 'ステート有効度':
			case 'StateRate':
				code = parc == '' ? 113 : 13;
				break;
			case '攻撃時ステート':
			case 'AttackState':
				code = 32;
				break;
		}
		if (code === null) { return false }
		value = (value / 100);
		if (code < 100) { value += 1 }
		return { 'code': code, 'dataId': id, 'value': value };
	};

	PassiveSkillManager.makeParamTrait = function (ary) {
		var code = null;
		var id = null;
		var value = parseInt(ary[1]);
		var parc = ary[2];
		switch (ary[0]) {
			// param
			case '最大HP':
			case '最大ＨＰ':
			case TextManager.basic(2):
			case TextManager.basic(3):
			case TextManager.param(0):
				id = 0;
				code = parc == '' ? 121 : 21;
				break;
			case '最大MP':
			case '最大ＭＰ':
			case TextManager.basic(4):
			case TextManager.basic(5):
			case TextManager.param(1):
				id = 1;
				code = parc == '' ? 121 : 21;
				break;
			case 'ATK':
			case 'ＡＴＫ':
			case '攻撃力':
			case TextManager.param(2):
				id = 2;
				code = parc == '' ? 121 : 21;
				break;
			case 'DEF':
			case 'ＤＥＦ':
			case '防御力':
			case TextManager.param(3):
				id = 3;
				code = parc == '' ? 121 : 21;
				break;
			case 'MAT':
			case 'ＭＡＴ':
			case '魔法力':
			case TextManager.param(4):
				id = 4;
				code = parc == '' ? 121 : 21;
				break;
			case 'MDF':
			case 'ＭＤＦ':
			case '魔法防御':
			case TextManager.param(5):
				id = 5;
				code = parc == '' ? 121 : 21;
				break;
			case 'AGI':
			case 'ＡＧＩ':
			case '敏捷性':
			case TextManager.param(6):
				id = 6;
				code = parc == '' ? 121 : 21;
				break;
			case 'LUK':
			case 'ＬＵＫ':
			case '運':
			case TextManager.param(7):
				id = 7;
				code = parc == '' ? 121 : 21;
				break;
			// xparams
			case 'HIT':
			case 'ＨＩＴ':
			case '命中率':
			case TextManager.param(8):
				id = 0;
				code = 22;
				break;
			case 'EVA':
			case 'ＥＶＡ':
			case '回避率':
				id = 1;
				code = 22;
				break;
			case TextManager.param(9):
			case 'CRI':
			case 'ＣＲＩ':
			case '会心率':
				id = 2;
				code = 22;
				break;
			case 'CEV':
			case 'ＣＥＶ':
			case '会心回避率':
				id = 3;
				code = 22;
				break;
			case 'MEV':
			case 'ＭＥＶ':
			case '魔法回避率':
				id = 4;
				code = 22;
				break;
			case 'MRF':
			case 'ＭＲＦ':
			case '魔法反射率':
				id = 5;
				code = 22;
				break;
			case 'CNT':
			case 'ＣＮＴ':
			case '反撃率':
				id = 6;
				code = 22;
				break;
			case 'HRG':
			case 'ＨＲＧ':
			case 'HP再生率':
			case 'ＨＰ再生率':
				id = 7;
				code = 22;
				break;
			case 'MRG':
			case 'ＭＲＧ':
			case 'MP再生率':
			case 'ＭＰ再生率':
				id = 8;
				code = 22;
				break;
			case 'TRG':
			case 'ＴＲＧ':
			case 'TP再生率':
			case 'ＴＰ再生率':
				id = 9;
				code = 22;
				break;
			//sparams
			case 'TGR':
			case 'ＴＧＲ':
			case '狙われ率':
				id = 0;
				code = parc == '' ? 123 : 23;
				break;
			case 'GRD':
			case 'ＧＲＤ':
			case '防御効果率':
				id = 1;
				code = parc == '' ? 123 : 23;
				break;
			case 'REC':
			case 'ＲＥＣ':
			case '回復効果率':
				id = 2;
				code = parc == '' ? 123 : 23;
				break;
			case 'PHA':
			case 'ＰＨＡ':
			case '薬の知識':
				id = 3;
				code = parc == '' ? 123 : 23;
				break;
			case 'MCR':
			case 'ＭＣＲ':
			case 'MP消費率':
			case 'ＭＰ消費率':
				id = 4;
				code = parc == '' ? 123 : 23;
				break;
			case 'TCR':
			case 'ＴＣＲ':
			case 'TPチャージ率':
			case 'ＴＰチャージ率':
				id = 5;
				code = parc == '' ? 123 : 23;
				break;
			case 'PDR':
			case 'ＰＤＲ':
			case '物理ダメージ率':
				id = 6;
				code = parc == '' ? 123 : 23;
				break;
			case 'MDR':
			case 'ＭＤＲ':
			case '魔法ダメージ率':
				id = 7;
				code = parc == '' ? 123 : 23;
				break;
			case 'FDR':
			case 'ＦＤＲ':
			case '床ダメージ率':
				id = 8;
				code = parc == '' ? 123 : 23;
				break;
			case 'EXR':
			case 'ＥＸＲ':
			case '経験値獲得率':
				id = 9;
				code = parc == '' ? 123 : 23;
				break;
			//その他
			case 'ステート無効化':
			case 'StateResist':
				id = value;
				code = 14;
				break;
			case '攻撃時属性':
			case 'AttackElement':
				id = value;
				code = 31;
				break;
			case '攻撃速度補正':
			case 'AttackSpeed':
				id = value;
				code = 33;
				break;
			case '攻撃追加回数':
			case 'AttackTimes+':
				id = value;
				code = 34;
				break;
			case 'スキルタイプ追加':
			case 'AddSkillType':
				id = value;
				code = 41;
				break;
			case 'スキルタイプ封印':
			case 'SealSkillType':
				id = value;
				code = 42;
				break;
			case 'スキル追加':
			case 'AddSkill':
				id = value;
				code = 43;
				break;
			case 'スキル封印':
			case 'SealSkill':
				id = value;
				code = 44;
				break;
			case '武器タイプ装備':
			case 'EquipWeapon':
				id = value;
				code = 51;
				break;
			case '防具タイプ装備':
			case 'EquipArmor':
				id = value;
				code = 52;
				break;
			case '装備固定':
			case 'LockEquip':
				id = value;
				code = 53;
				break;
			case '装備封印':
			case 'SealEquip':
				id = value;
				code = 54;
				break;
			case '行動回数追加':
			case 'ActionTime+':
				id = value;
				code = 61;
				break;
			default:
		}
		if (code === null) { return false }
		if ((code > 20 && code < 30) || (code === 123)) { value = (value / 100) }
		if (code === 21) { value += 1 }
		if (code === 23) { value += 1 }
		return { 'code': code, 'dataId': id, 'value': value };
	};

	PassiveSkillManager.makeExTrait = function (reg) {
		var code = null;
		var id = null;
		var value = 1;
		switch (reg) {
			case '二刀流':
			case 'DualWield':
				code = 55;
				id = 1;
				break;
			case '自動戦闘':
			case 'AutoBattle':
				code = 62;
				id = 0;
				break;
			case '防御':
			case 'Guard':
				code = 62;
				id = 1;
				break;
			case '身代わり':
			case 'Substitute':
				code = 62;
				id = 2;
				break;
			case 'TP持ち越し':
			case 'PreserveTP':
				code = 62;
				id = 3;
				break;
			case 'エンカウント半減':
			case 'EncounterHalf':
				code = 64;
				id = 0;
				break;
			case 'エンカウント無効':
			case 'EncounterNone':
				code = 64;
				id = 1;
				break;
			case '不意打ち無効':
			case 'CancelSurprise':
				code = 64;
				id = 2;
				break;
			case '先制攻撃率アップ':
			case 'RaisePreemptive':
				code = 64;
				id = 3;
				break;
			case '獲得金額二倍':
			case '獲得金額2倍':
			case '獲得金額２倍':
			case 'GoldDouble':
				code = 64;
				id = 4;
				break;
			case 'アイテム入手率二倍':
			case 'アイテム入手率2倍':
			case 'アイテム入手率２倍':
			case 'ItemDropDouble':
				code = 64;
				id = 5;
				break;
			default:
		}
		if (code === null) { return false }
		return { 'code': code, 'dataId': id, 'value': value };
	};

	PassiveSkillManager.initPassiveSkill = function (skill) {
		if (skill.traits) { return }
		skill.traits = [];
		var texts = skill.note.split('\n');
		for (var i = 0; i < texts.length; i++) {
			var trait = this.checkPassive(texts[i]);
			if (trait) { skill.traits.push(trait) }
		}
	};

	var _pS_GActor_traitObjects = Game_Actor.prototype.traitObjects;
	Game_Actor.prototype.traitObjects = function () {
		var objects = _pS_GActor_traitObjects.call(this);
		if (this.traitNest) { return objects }
		this.traitNest = true;
		this.enableSkills().forEach(function (skill) {
			PassiveSkillManager.initPassiveSkill(skill);
			if (skill.traits.length > 0) { objects.push(skill) }
		}, this);
		this.traitNest = false;
		return objects;
	};

	var _pS_GBBase_addedSkillTypes = Game_BattlerBase.prototype.addedSkillTypes;
	Game_BattlerBase.prototype.addedSkillTypes = function () {
		var types = _pS_GBBase_addedSkillTypes.call(this);
		if (!$gameParty.inBattle()) { return types }
		var id = types.indexOf(passiveSkillTypeId);
		if (id >= 0) { types.splice(id, 1) }
		return types;
	};

	Game_Actor.prototype.enableSkills = function () {
		if (this._enableSkills && !this._passiveRefresh) {
			return this._enableSkills.reduce(function (r, id) { return r.concat([$dataSkills[id]]) }, []);
		}
		this._enableSkills = [];
		this._skills.forEach(function (skillId) {
			var skill = $dataSkills[skillId];
			if (this.isUsableSkill(skill)) { this._enableSkills.push(skill.id) }
		}, this);
		this._passiveRefresh = false;
		return this._enableSkills.reduce(function (r, id) { return r.concat([$dataSkills[id]]) }, []);
	};

	var _pS_GActor_refresh = Game_Actor.prototype.refresh;
	Game_Actor.prototype.refresh = function () {
		this._passiveRefresh = true;
		_pS_GActor_refresh.call(this);
	};

	var _pS_GActor_learnSkill = Game_Actor.prototype.learnSkill;
	Game_Actor.prototype.learnSkill = function (skillId) {
		_pS_GActor_learnSkill.call(this, skillId);
		if (!Imported['VXandAceHybridClass']) this.refresh();
	};

	Game_Actor.prototype.isUsableSkill = function (skill) {
		return (this.isSkillWtypeOk(skill) && !this.isSkillSealed(skill.id) &&
			!this.isSkillTypeSealed(skill.stypeId));
	};

	Game_Party.prototype.refreshSkills = function () {
		this.members().forEach(function (actor) {
			actor._passiveRefresh = true;
		})
	};

	var _pS_BManager_startInput = BattleManager.startInput;
	BattleManager.startInput = function () {
		$gameParty.refreshSkills();
		_pS_BManager_startInput.call(this);
	};

	if (addMultiOrder) {
		var _pS_GBBase_paramPlus = Game_BattlerBase.prototype.paramPlus;
		Game_BattlerBase.prototype.paramPlus = function (paramId) {
			var pr = _pS_GBBase_paramPlus.call(this, paramId);
			pr += this.traitsSum(121, paramId);
			return pr;
		};

		var _pS_GBBase_sparam = Game_BattlerBase.prototype.sparam;
		Game_BattlerBase.prototype.sparam = function (paramId) {
			var pr = this.traitsSum(123, paramId) + 1.0;
			pr *= _pS_GBBase_sparam.call(this, paramId);
			return pr;
		}

		var _pS_GBBase_elementRate = Game_BattlerBase.prototype.elementRate;
		Game_BattlerBase.prototype.elementRate = function (elementId) {
			var rate = this.traitsSum(111, elementId) + 1.0;
			rate *= _pS_GBBase_elementRate.call(this, elementId);
			return rate;
		}

		var _pS_GBBase_debuffRate = Game_BattlerBase.prototype.debuffRate;
		Game_BattlerBase.prototype.debuffRate = function (debuffId) {
			var rate = this.traitsSum(112, debuffId) + 1.0;
			rate *= _pS_GBBase_debuffRate.call(this, debuffId);
			return rate;
		}

		var _pS_GBBase_stateRate = Game_BattlerBase.prototype.stateRate;
		Game_BattlerBase.prototype.stateRate = function (stateId) {
			var rate = this.traitsSum(113, stateId) + 1.0;
			rate *= _pS_GBBase_stateRate.call(this, stateId);
			return rate;
		}

	} else {
		var _pS_GBBase_param = Game_BattlerBase.prototype.param;
		Game_BattlerBase.prototype.param = function (paramId) {
			var pr = _pS_GBBase_param.call(this, paramId);
			pr += this.traitsSum(121, paramId);
			var maxValue = this.paramMax(paramId);
			var minValue = this.paramMin(paramId);
			return Math.round(pr.clamp(minValue, maxValue));
		};

		var _pS_GBBase_sparam = Game_BattlerBase.prototype.sparam;
		Game_BattlerBase.prototype.sparam = function (paramId) {
			var pr = _pS_GBBase_sparam.call(this, paramId);
			pr += this.traitsSum(123, paramId) + 1.0;
			return pr;
		}

		var _pS_GBBase_elementRate = Game_BattlerBase.prototype.elementRate;
		Game_BattlerBase.prototype.elementRate = function (elementId) {
			var rate = _pS_GBBase_elementRate.call(this, elementId);
			rate += this.traitsSum(111, elementId) + 1.0;
			return rate;
		}

		var _pS_GBBase_debuffRate = Game_BattlerBase.prototype.debuffRate;
		Game_BattlerBase.prototype.debuffRate = function (debuffId) {
			var rate = _pS_GBBase_debuffRate.call(this, debuffId);
			rate += this.traitsSum(112, debuffId) + 1.0;
			return rate;
		}

		var _pS_GBBase_stateRate = Game_BattlerBase.prototype.stateRate;
		Game_BattlerBase.prototype.stateRate = function (stateId) {
			var rate = _pS_GBBase_stateRate.call(this, stateId);
			rate += this.traitsSum(113, stateId) + 1.0;
			return rate;
		}
	}
}());


code:
//=============================================================================
// PictureVariableSetting.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.5.0 2016/08/06 ピクチャを画面のシェイクと連動しないようにするコマンドを追加
// 1.4.0 2016/06/23 ピクチャをシェイクさせるコマンドを追加
// 1.3.0 2016/04/29 ピクチャを指定した角度まで回転させるコマンドを追加
// 1.2.1 2016/04/14 処理を適用するピクチャを範囲指定もしくは複数指定する機能を追加
// 1.2.0 2016/03/19 表示中のすべてのピクチャに処理を適用するコマンドを追加
// 1.1.2 2016/01/24 ピクチャの最大表示数を設定できる機能を追加
// 1.1.1 2015/12/20 番号の変数指定の初期値を有効/無効で設定できるよう修正
// 1.1.0 2015/11/27 ピクチャのファイル名に変数を組み込むことが出来る機能を追加
// 1.0.0 2015/11/24 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc ピクチャ関連のイベント機能拡張プラグイン
 * @author トリアコンタン
 *
 * @param 初期値
 * @desc 初期状態での有効/無効の設定値(ON/OFF)
 * @default OFF
 *
 * @param ピクチャ表示最大数
 * @desc ピクチャ表示最大数（デフォルト100個）を設定します。
 * 変えない場合は何も入力しないでください。
 * @default
 *
 * @help ピクチャ関連のイベント命令の機能を拡張します。
 * プラグインコマンドから機能を有効にしてください。
 *
 * １．ピクチャ関連のイベント命令で番号が「指定された変数の値」になるよう
 * 仕様を変更します。
 * 例えば番号に「1」を設定すると「1」番の変数の値をピクチャ番号として設定します。
 * プラグインコマンドから「P_VARIABLE_VALID」「P_VARIABLE_INVALID」で
 * 有効/無効を切り替えてください。（初期状態では無効です）
 *
 * ２．ピクチャのファイル名に変数を組み込むことが出来るようになります。
 * 連番を含むファイル名などの柔軟な指定に有効です。
 * プラグインコマンド「P_D_FILENAME」を実行してから
 * 「画像」を指定せず「ピクチャの表示」を行ってください。
 *
 * 要注意！　ピクチャのファイル名を動的指定した場合、デプロイメント時に
 * 未使用ファイルとして除外される可能性があります。
 * その場合、削除されたファイルを入れ直す等の対応が必要です。
 *
 * ３．以下のイベントコマンドの対象が「複数のピクチャ」になります。
 * 　　詳細は各プラグインコマンドの説明を確認してください。
 *  ・ピクチャの移動
 *  ・ピクチャの色調変更
 *  ・ピクチャの回転
 *  ・ピクチャの消去
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （引数の間は半角スペースで区切る）
 *
 *  P_VARIABLE_VALID : ピクチャ番号の変数設定が有効になります。
 *  P_VARIABLE_INVALID : ピクチャ番号の変数設定が無効になります。
 *  ※ 一度有効に設定したら、無効にするまでずっとそのままです。
 *  例 P_VARIABLE_VALID
 *
 *  P_D_FILENAME [ファイル名]
 *  次に表示するピクチャのファイル名に変数を含めることができます。
 *  変数は「文章の表示」と同様の書式\V[n]で組み込んでください。
 *  拡張子は指定しないでください。
 *  例 P_D_FILENAME file\V[1]
 *
 *  P_TARGET_ALL
 *  ピクチャ関連のイベントコマンドの対象を
 *  「表示している全てのピクチャ」に変更します。
 *  1回実行すると設定はもとに戻ります。
 *  例 P_TARGET_ALL
 *
 *  P_TARGET_RANGE [開始番号] [終了番号]
 *  ピクチャ関連のイベントコマンドの対象を
 *  「開始番号から終了番号までのピクチャ」に変更します。
 *  1回実行すると設定はもとに戻ります。
 *  例 P_TARGET_RANGE 3 5 // 3番から5番までの表示しているピクチャが対象
 *
 *  P_TARGET_MULTI [ピクチャ番号]
 *  ピクチャ関連のイベントコマンドの対象を
 *  「指定したすべてのピクチャ」に変更します。カンマで区切ってください。
 *  1回実行すると設定はもとに戻ります。
 *  例 P_TARGET_MULTI 3,5,6,\v[1] // 3番、5番、6番、変数「1」番のピクチャが対象
 *
 *  P_SPIN [ピクチャ番号] [角度] [時間(フレーム)] [完了までウェイト]
 *  対象のピクチャを指定した角度(degree)まで回転させます。正の値が時計回りです。
 *  時間を0にすると即座に指定した角度に設定されます。
 *  このコマンドには「P_TARGET_ALL」等が適用されます。
 *  一番後ろに「WAIT」と付けると、回転が完了するまでウェイトします。
 *  例 P_SPIN 1 90 60 WAIT
 *  -> ピクチャ番号「1」を60フレーム掛けて90度回転させる。
 *
 *  P_SPIN_RELATIVE [ピクチャ番号] [角度] [時間(フレーム)] [完了までウェイト]
 *  対象のピクチャを現在の角度を基準に、指定した角度のぶんだけ回転させます。
 *  それ以外は「P_SPIN」と同様です。
 *  例 P_SPIN_RELATIVE \v[1] -90 0
 *  -> 変数「1」の値のピクチャを、現在の角度から-90度まで即座に回転させる。
 *
 *  P_SHAKE [ピクチャ番号] [強さ] [速さ] [角度] [時間(フレーム)] [完了までウェイト]
 *  対象のピクチャをシェイクさせます。強さと速さはイベント「画面のシェイク」と
 *  同様の9段階の数値で指定します。角度(degree)はシェイク方向を0から360までの
 *  値で指定します。(90で縦方向にシェイクします)
 *  時間を指定しないと、停止するまでシェイクし続けます。
 *  一番後ろに「WAIT」と付けると、回転が完了するまでウェイトします。
 *  このコマンドには「P_TARGET_ALL」等が適用されます。
 *  例 P_SHAKE 1 3 9 0 60 WAIT
 *  -> ピクチャ番号「1」を60フレームのあいだ、強さ3、速さ9で横方向にシェイクします。
 *
 *  P_STOP_SHAKE [ピクチャ番号]
 *  対象のピクチャをシェイクを止めます。P_SHAKEで時間を指定しないと
 *  ずっとシェイクし続けるので当コマンドで無効にします。
 *  このコマンドには「P_TARGET_ALL」等が適用されます。
 *　例 P_STOP_SHAKE \v[1]
 *  -> 変数「1」の値のピクチャのシェイクを止めます。
 *
 *  P_OUT_OF_SCREEN_SHAKE_ON [ピクチャ番号]
 *  対象のピクチャが画面のシェイクと連動しないようになります。
 *  メッセージウィンドウ等と同じ扱いになります。
 *  例 P_OUT_OF_SCREEN_SHAKE_ON 1
 *  -> ピクチャ番号「1」が画面のシェイクと連動しないようになります。
 *
 *  P_OUT_OF_SCREEN_SHAKE_OFF [ピクチャ番号]
 *  対象のピクチャが画面のシェイクと再度、連動するようになります。
 *  例 P_OUT_OF_SCREEN_SHAKE_OFF 1
 *  -> ピクチャ番号「1」が画面のシェイクと再度、連動するようになります。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function () {
    'use strict';
    var pluginName = 'PictureVariableSetting';

    //=============================================================================
    // ローカル関数
    //  プラグインパラメータやプラグインコマンドパラメータの整形やチェックをします
    //=============================================================================
    var getParamBoolean = function (paramNames) {
        var value = getParamOther(paramNames);
        return (value || '').toUpperCase() === 'ON';
    };

    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 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 getCommandName = function (command) {
        return (command || '').toUpperCase();
    };

    var getArgString = function (arg, upperFlg) {
        arg = convertEscapeCharactersAndEval(arg, false);
        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(convertEscapeCharactersAndEval(arg, true), 10) || 0).clamp(min, max);
    };

    var getArgArrayString = function (args, upperFlg) {
        var values = getArgString(args, upperFlg).split(',');
        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 convertEscapeCharactersAndEval = function (text, evalFlg) {
        if (text === null || text === undefined) text = '';
        var window = SceneManager._scene._windowLayer.children[0];
        if (window) {
            var result = window.convertEscapeCharacters(text);
            return evalFlg ? eval(result) : result;
        } else {
            return text;
        }
    };

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンド[P_VARIABLE_VALID]などを追加定義します。
    //  ピクチャ番号を変数で指定するよう変更します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        switch (getCommandName(command)) {
            case 'P_VARIABLE_VALID':
                $gameSystem.pictureNumVariable = true;
                break;
            case 'P_VARIABLE_INVALID':
                $gameSystem.pictureNumVariable = false;
                break;
            case 'P_D_FILENAME':
                $gameScreen.dPictureFileName = getArgString(args[0]);
                break;
            case 'P_TARGET_ALL':
                $gameScreen.setPictureTargetAll();
                break;
            case 'P_TARGET_RANGE':
                $gameScreen.setPictureTargetRange(getArgNumber(args[0], 1), getArgNumber(args[1], 1));
                break;
            case 'P_TARGET_MULTI':
                $gameScreen.setPictureTargetMulti(getArgArrayNumber(args[0], 1));
                break;
            case 'P_SPIN':
                var spinDuration = getArgNumber(args[2], 0);
                $gameScreen.spinPicture(getArgNumber(args[0], 1), getArgNumber(args[1]), spinDuration);
                if (args[3]) this.wait(spinDuration);
                break;
            case 'P_SPIN_RELATIVE':
                var spinRelativeDuration = getArgNumber(args[2], 0);
                $gameScreen.spinPictureRelative(getArgNumber(args[0], 1), getArgNumber(args[1]), spinRelativeDuration);
                if (args[3]) this.wait(spinRelativeDuration);
                break;
            case 'P_SHAKE':
                var shakeDuration = getArgNumber(args[4], 0) || Infinity;
                var power = getArgNumber(args[1], 1, 9);
                var speed = getArgNumber(args[2], 1, 9);
                var rotation = getArgNumber(args[3], 0, 360);
                $gameScreen.shakePicture(getArgNumber(args[0], 1), power, speed, rotation, shakeDuration);
                if (args[5] && shakeDuration !== Infinity) this.wait(shakeDuration);
                break;
            case 'P_STOP_SHAKE':
                $gameScreen.shakePicture(getArgNumber(args[0], 1), 0, 0, 0, 0);
                break;
            case 'P_OUT_OF_SCREEN_SHAKE_ON':
                $gameScreen.setOutOfScreenShakePicture(getArgNumber(args[0], 1), true);
                break;
            case 'P_OUT_OF_SCREEN_SHAKE_OFF':
                $gameScreen.setOutOfScreenShakePicture(getArgNumber(args[0], 1), false);
                break;
        }
    };

    var _Game_Interpreter_command231 = Game_Interpreter.prototype.command231;
    Game_Interpreter.prototype.command231 = function () {
        return this.transPictureNumber(_Game_Interpreter_command231.bind(this));
    };

    var _Game_Interpreter_command232 = Game_Interpreter.prototype.command232;
    Game_Interpreter.prototype.command232 = function () {
        return this.transPictureNumber(_Game_Interpreter_command232.bind(this));
    };

    var _Game_Interpreter_command233 = Game_Interpreter.prototype.command233;
    Game_Interpreter.prototype.command233 = function () {
        return this.transPictureNumber(_Game_Interpreter_command233.bind(this));
    };

    var _Game_Interpreter_command234 = Game_Interpreter.prototype.command234;
    Game_Interpreter.prototype.command234 = function () {
        return this.transPictureNumber(_Game_Interpreter_command234.bind(this));
    };

    var _Game_Interpreter_command235 = Game_Interpreter.prototype.command235;
    Game_Interpreter.prototype.command235 = function () {
        return this.transPictureNumber(_Game_Interpreter_command235.bind(this));
    };

    Game_Interpreter.prototype.transPictureNumber = function (handler) {
        var result;
        if ($gameSystem.pictureNumVariable) {
            var oldValue = this._params[0];
            this._params[0] = $gameVariables.value(this._params[0]).clamp(1, $gameScreen.maxPictures());
            result = handler();
            this._params[0] = oldValue;
        } else {
            result = handler();
        }
        return result;
    };

    //=============================================================================
    // Game_System
    //  ピクチャ番号の変数指定フラグを追加定義します。
    //=============================================================================
    var _Game_System_initialize = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function () {
        _Game_System_initialize.call(this);
        this.pictureNumVariable = getParamBoolean('初期値');
    };

    //=============================================================================
    // Game_Screen
    //  動的ファイル名指定用のプロパティを追加定義します。
    //=============================================================================
    var _Game_Screen_clear = Game_Screen.prototype.clear;
    Game_Screen.prototype.clear = function () {
        _Game_Screen_clear.call(this);
        this.dPictureFileName = null;
        this._pictureTargetStart = null;
        this._pictureTargetEnd = null;
        this._pictureTargetNumbers = null;
    };

    Game_Screen.prototype.setPictureTargetAll = function () {
        this._pictureTargetAll = 1;
    };

    Game_Screen.prototype.setPictureTargetRange = function (start, end) {
        this._pictureTargetAll = 2;
        this._pictureTargetStart = start;
        this._pictureTargetEnd = end;
    };

    Game_Screen.prototype.setPictureTargetMulti = function (args) {
        this._pictureTargetAll = 3;
        this._pictureTargetNumbers = args;
    };

    var _Game_Screen_movePicture = Game_Screen.prototype.movePicture;
    Game_Screen.prototype.movePicture = function (pictureId, origin, x, y, scaleX,
        scaleY, opacity, blendMode, duration) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.move(origin, x, y, scaleX, scaleY, opacity, blendMode, duration);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            _Game_Screen_movePicture.apply(this, arguments);
        }
    };

    var _Game_Screen_rotatePicture = Game_Screen.prototype.rotatePicture;
    Game_Screen.prototype.rotatePicture = function (pictureId, speed) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.rotate(speed);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            _Game_Screen_rotatePicture.apply(this, arguments);
        }
    };

    var _Game_Screen_tintPicture = Game_Screen.prototype.tintPicture;
    Game_Screen.prototype.tintPicture = function (pictureId, tone, duration) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.tint(tone, duration);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            _Game_Screen_tintPicture.apply(this, arguments);
        }
    };

    var _Game_Screen_erasePicture = Game_Screen.prototype.erasePicture;
    Game_Screen.prototype.erasePicture = function (pictureId) {
        if (this._pictureTargetAll) {
            this.iteratePictures(function (picture, pictureId) {
                var realPictureId = this.realPictureId(pictureId);
                this._pictures[realPictureId] = null;
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            _Game_Screen_erasePicture.apply(this, arguments);
        }
    };

    Game_Screen.prototype.spinPicture = function (pictureId, rotation, duration) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.spin(rotation, duration);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            var picture = this.picture(pictureId);
            if (picture) {
                picture.spin(rotation, duration);
            }
        }
    };

    Game_Screen.prototype.spinPictureRelative = function (pictureId, relativeRotation, duration) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.spinRelative(relativeRotation, duration);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            var picture = this.picture(pictureId);
            if (picture) {
                picture.spinRelative(relativeRotation, duration);
            }
        }
    };

    Game_Screen.prototype.shakePicture = function (pictureId, power, speed, rotation, duration) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.shake(power, speed, rotation, duration);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            var picture = this.picture(pictureId);
            if (picture) {
                picture.shake(power, speed, rotation, duration);
            }
        }
    };

    Game_Screen.prototype.setOutOfScreenShakePicture = function (pictureId, value) {
        if (this._pictureTargetAll > 0) {
            this.iteratePictures(function (picture) {
                picture.setOutOfScreenShake(value);
            }.bind(this));
            this._pictureTargetAll = 0;
        } else {
            var picture = this.picture(pictureId);
            if (picture) {
                picture.setOutOfScreenShake(value);
            }
        }
    };

    Game_Screen.prototype.iteratePictures = function (callBack) {
        for (var i = 1, n = this.maxPictures(); i <= n; i++) {
            var picture = this.picture(i);
            if (picture && this.isTargetPicture(i)) {
                callBack.call(this, picture, i);
            }
        }
    };

    Game_Screen.prototype.isTargetPicture = function (number) {
        switch (this._pictureTargetAll) {
            case 2:
                return this._pictureTargetStart <= number && this._pictureTargetEnd >= number;
            case 3:
                return this._pictureTargetNumbers.contains(number);
            default:
                return true;
        }
    };

    var _Game_Screen_maxPictures = Game_Screen.prototype.maxPictures;
    Game_Screen.prototype.maxPictures = function () {
        var max = getParamNumber('ピクチャ表示最大数', 0);
        return max > 0 ? max : _Game_Screen_maxPictures.apply(this, arguments);
    };

    //=============================================================================
    // Game_Picture
    //  ファイル名の動的生成処理を追加定義します。
    //=============================================================================
    var _Game_Picture_show = Game_Picture.prototype.show;
    Game_Picture.prototype.show = function (name, origin, x, y, scaleX,
        scaleY, opacity, blendMode) {
        if ($gameScreen.dPictureFileName != null) {
            arguments[0] = $gameScreen.dPictureFileName;
            $gameScreen.dPictureFileName = null;
        }
        _Game_Picture_show.apply(this, arguments);
    };

    var _Game_Picture_x = Game_Picture.prototype.x;
    Game_Picture.prototype.x = function () {
        return _Game_Picture_x.apply(this, arguments) + this.getShakeX() -
            (this._outOfScreenShake ? $gameScreen.shake() : 0);
    };

    var _Game_Picture_y = Game_Picture.prototype.y;
    Game_Picture.prototype.y = function () {
        return _Game_Picture_y.apply(this, arguments) + this.getShakeY();
    };

    Game_Picture.prototype.setOutOfScreenShake = function (value) {
        this._outOfScreenShake = !!value;
    };

    Game_Picture.prototype.spin = function (targetRotation, duration) {
        this._targetRotation = targetRotation;
        this._angle = (this._angle % 360);
        if (duration === 0) {
            this._angle = this._targetRotation;
        } else {
            this._spinDuration = duration;
        }
    };

    Game_Picture.prototype.spinRelative = function (targetRelativeRotation, duration) {
        this._angle = (this._angle % 360);
        this.spin(this._angle + targetRelativeRotation, duration);
    };

    Game_Picture.prototype.shake = function (power, speed, rotation, duration) {
        this.stopShake();
        this._shakePower = power;
        this._shakeSpeed = speed;
        this._shakeDuration = duration;
        this._shakeRotation = rotation * Math.PI / 180;
    };

    Game_Picture.prototype.stopShake = function () {
        this._shakeDirection = 1;
        this._shake = 0;
    };

    var _Game_Picture_update = Game_Picture.prototype.update;
    Game_Picture.prototype.update = function () {
        _Game_Picture_update.apply(this, arguments);
        this.updateSpin();
        this.updateShake();
    };

    Game_Picture.prototype.updateSpin = function () {
        if (this._spinDuration > 0) {
            var d = this._spinDuration;
            this._angle = (this._angle * (d - 1) + this._targetRotation) / d;
            this._spinDuration--;
        }
    };

    Game_Picture.prototype.updateShake = function () {
        if (this._shakeDuration > 0) {
            var delta = (this._shakePower * this._shakeSpeed * this._shakeDirection) / 10;
            if (this._shakeDuration <= 1 && this._shake * (this._shake + delta) < 0) {
                this._shake = 0;
            } else {
                this._shake += delta;
            }
            if (this._shake > this._shakePower * 2) {
                this._shakeDirection = -1;
            }
            if (this._shake < -this._shakePower * 2) {
                this._shakeDirection = 1;
            }
            this._shakeDuration--;
        }
    };

    Game_Picture.prototype.getShakeX = function () {
        return this._shake ? this._shake * Math.cos(this._shakeRotation) : 0;
    };

    Game_Picture.prototype.getShakeY = function () {
        return this._shake ? this._shake * Math.sin(this._shakeRotation) : 0;
    };
})();


code:
//=============================================================================
// PlayerGraphicChange.js
// ----------------------------------------------------------------------------
// Copyright (c) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.0.0 2016/11/09 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc PlayerGraphicChangePlugin
 * @author triacontane
 *
 * @help プレイヤー画像をアクターとは無関係に設定できるようになります。
 *
 * プレイヤーに対して一度でも「移動ルートの指定」から「画像の変更」を
 * 行うと、その変更が場所移動やセーブなどを行った後も継続するようになります。
 *
 * 変更したグラフィックを元に戻す場合は、イベントコマンドの「スクリプト」から
 * 以下のスクリプトを実行してください。
 *
 * $gamePlayer.resetCustomizeGraphic();
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc プレイヤーの画像変更プラグイン
 * @author トリアコンタン
 *
 * @help プレイヤー画像をアクターとは無関係に設定できるようになります。
 *
 * プレイヤーに対して一度でも「移動ルートの指定」から「画像の変更」を
 * 行うと、その変更が場所移動やセーブなどを行った後も継続するようになります。
 *
 * 変更したグラフィックを元に戻す場合は、イベントコマンドの「スクリプト」から
 * 以下のスクリプトを実行してください。
 *
 * $gamePlayer.resetCustomizeGraphic();
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';

    //=============================================================================
    // Game_Player
    //  プレイヤーに対するグラフィック変更処理を永続化します。
    //=============================================================================
    var _Game_Player_refresh = Game_Player.prototype.refresh;
    Game_Player.prototype.refresh = function () {
        this._refreshing = true;
        _Game_Player_refresh.apply(this, arguments);
        this._refreshing = false;
    };

    Game_Player.prototype.setImage = function (characterName, characterIndex) {
        if (!this._refreshing) {
            this._customized = true;
        }
        if (this._refreshing && this._customized) return;
        Game_CharacterBase.prototype.setImage.apply(this, arguments);
    };

    Game_Player.prototype.resetCustomizeGraphic = function () {
        this._customized = false;
        this.refresh();
    };
})();


code:
//=============================================================================
// RestrictionTargetSkill.js
// ----------------------------------------------------------------------------
// Copyright (c) 2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.1.10 2018/06/04 DeadOrAliveItem.jsとの競合を解消
// 1.1.9 2018/02/28 選択可能対象が存在しないスキルは、敵キャラの使用スキルから除外するよう修正
// 1.1.8 2018/02/27 スクリプトに関するヘルプの記述が間違っていたので修正
// 1.1.7 2017/07/26 ステート全体化プラグイン（StateTotalization.js）との競合を解消
// 1.1.6 2017/06/28 混乱ステート拡張プラグイン（ConfusionExtend.js）との競合を解消
// 1.1.5 2017/06/12 敵が制約付きスキルを使用した際にエラーが発生する場合がある問題を修正
// 1.1.4 2017/06/04 1.1.3で戦闘行動のキャラクターに対するスキルが実行できなくなっていた問題を修正
// 1.1.3 2017/06/04 単体を対象にした制限スキルを実行したときに、選択した対象と実行対象がズレてしまう場合がある問題を修正
// 1.1.2 2017/01/12 メモ欄の値が空で設定された場合にエラーが発生するかもしれない問題を修正
// 1.1.1 2016/11/13 戦闘中に強制終了する場合がある不具合を修正
// 1.1.0 2016/09/29 使用者に対して無効なスキルを設定できる機能を追加
//                  アクター用と敵キャラ用とでメモ欄を分岐
// 1.0.0 2016/09/29 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc RestrictionTargetSkillPlugin
 * @author triacontane
 *
 * @help RestrictionTargetSkill.js
 *
 * 特定のバトラー（敵および味方）に対して使用できない、もしくは
 * 特定のバトラーに対してのみ使用できるスキルを作成できます。
 * 敵がスキルを使う場合や、自動戦闘、混乱、複数対象の場合なども含めて
 * 常に対象スキルのターゲットから外れます。
 *
 * 制約：敵キャラの選択制限については「YEP_BattleEngineCore.js」の
 * 適用環境では使用できません。
 *
 * スキルのメモ欄に以下の通り指定してください。
 * <RTS_有効アクターID:2,3> # ID[2][3]のアクターにのみ使用できます。
 * <RTS_ValidActorID:2,3>   # 同上
 * <RTS_無効アクターID:5>   # ID[5]のアクターに使用できません。
 * <RTS_InvalidActorID:5>   # 同上
 * <RTS_有効敵キャラID:2,3> # ID[2][3]の敵キャラにのみ使用できます。
 * <RTS_ValidEnemyID:2,3>   # 同上
 * <RTS_無効敵キャラID:5>   # ID[5]の敵キャラに使用できません。
 * <RTS_InvalidEnemyID:5>   # 同上
 * <RTS_使用者無効>         # スキルの使用者には使用できません。
 * <RTS_UserInvalid>        # 同上
 * <RTS_スクリプト:s>       # スクリプト[s]を実行結果が[true]だと使用できません。
 * <RTS_Script:s>           # 同上
 *
 * スクリプト中では以下のローカル変数が使用できます。
 * this : 対象バトラーオブジェクト
 * item : 対象スキル(アイテム)オブジェクト
 * スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → <
 * > → >
 *
 * さらに全てのスキルを受け付けなくなる特徴を作成する機能もあります。
 * 特徴を有するデータベースもメモ欄に以下の通り指定してください。
 * <RTS_無敵>       # この特徴が有効な限り全てのスキルの対象から外れます。
 * <RTS_Invincible> # 同上
 *
 * 主にスキルによる一時的な無敵状態の演出に利用できます。
 *
 * 競合情報
 * DeadOrAliveItem.jsと併用する場合は当プラグインを下に配置してください。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 対象限定スキルプラグイン
 * @author トリアコンタン
 *
 * @help RestrictionTargetSkill.js
 *
 * 特定のバトラー（敵および味方）に対して使用できない、もしくは
 * 特定のバトラーに対してのみ使用できるスキルを作成できます。
 * 敵がスキルを使う場合や、自動戦闘、混乱、複数対象の場合なども含めて
 * 常に対象スキルのターゲットから外れます。
 *
 * 制約：敵キャラの選択制限については「YEP_BattleEngineCore.js」の
 * 適用環境では使用できません。
 *
 * スキルのメモ欄に以下の通り指定してください。
 * <RTS_有効アクターID:2,3> # ID[2][3]のアクターにのみ使用できます。
 * <RTS_ValidActorID:2,3>   # 同上
 * <RTS_無効アクターID:5>   # ID[5]のアクターに使用できません。
 * <RTS_InvalidActorID:5>   # 同上
 * <RTS_有効敵キャラID:2,3> # ID[2][3]の敵キャラにのみ使用できます。
 * <RTS_ValidEnemyID:2,3>   # 同上
 * <RTS_無効敵キャラID:5>   # ID[5]の敵キャラに使用できません。
 * <RTS_InvalidEnemyID:5>   # 同上
 * <RTS_使用者無効>         # スキルの使用者には使用できません。
 * <RTS_UserInvalid>        # 同上
 * <RTS_スクリプト:s>       # スクリプト[s]を実行結果が[true]だと使用できません。
 * <RTS_Script:s>           # 同上
 *
 * スクリプト中では以下のローカル変数が使用できます。
 * this : 対象バトラーオブジェクト
 * item : 対象スキル(アイテム)オブジェクト
 * スクリプト中で不等号を使いたい場合、以下のように記述してください。
 * < → <
 * > → >
 *
 * さらに全てのスキルを受け付けなくなる特徴を作成する機能もあります。
 * 特徴を有するデータベースもメモ欄に以下の通り指定してください。
 * <RTS_無敵>       # この特徴が有効な限り全てのスキルの対象から外れます。
 * <RTS_Invincible> # 同上
 *
 * 主にスキルによる一時的な無敵状態の演出に利用できます。
 *
 * 競合情報
 * DeadOrAliveItem.jsと併用する場合は当プラグインを下に配置してください。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    var metaTagPrefix = 'RTS_';

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

    var getArgArrayString = function (args, upperFlg) {
        var values = getArgString(args, upperFlg).split(',');
        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 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;
    };

    //=============================================================================
    // Game_BattlerBase
    //  スキルやアイテムの対象として選択可能かどうかを返します。
    //=============================================================================
    Game_Battler.prototype.isExistValidTarget = function (item) {
        var trialAction = new Game_Action(this, false);
        trialAction.setItemObject(item);
        return trialAction.isExistTarget();
    };

    Game_BattlerBase.prototype.canSelectTarget = function (item, user) {
        if (getMetaValues(item, ['使用者無効', 'UserInvalid']) && user === this) {
            return false;
        }
        var scriptValue = getMetaValues(item, ['スクリプト', 'Script']);
        if (scriptValue && eval(getArgString(scriptValue))) {
            return false;
        }
        this.friendsUnit().setNeedOriginalMember(true);
        var result = !this.traitObjects().some(function (data) {
            return !!getMetaValues(data, ['無敵', 'Invincible']);
        });
        this.friendsUnit().setNeedOriginalMember(false);
        return result;
    };

    Game_Actor.prototype.canSelectTarget = function (item, user) {
        var result = Game_BattlerBase.prototype.canSelectTarget.apply(this, arguments);
        if (result) {
            var actorId = this.actorId();
            var validId = getMetaValues(item, ['有効アクターID', 'ValidActorID']);
            if (validId && !getArgArrayNumber(validId).contains(actorId)) {
                return false;
            }
            var invalidId = getMetaValues(item, ['無効アクターID', 'InvalidActorID']);
            if (invalidId && getArgArrayNumber(invalidId).contains(actorId)) {
                return false;
            }
        }
        return result;
    };

    Game_Enemy.prototype.canSelectTarget = function (item, user) {
        var result = Game_BattlerBase.prototype.canSelectTarget.apply(this, arguments);
        if (result) {
            var enemyId = this.enemyId();
            var validId = getMetaValues(item, ['有効敵キャラID', 'ValidEnemyID']);
            if (validId && !getArgArrayNumber(validId).contains(enemyId)) {
                return false;
            }
            var invalidId = getMetaValues(item, ['無効敵キャラID', 'InvalidEnemyID']);
            if (invalidId && getArgArrayNumber(invalidId).contains(enemyId)) {
                return false;
            }
        }
        return result;
    };

    var _Game_Enemy_isActionValid = Game_Enemy.prototype.isActionValid;
    Game_Enemy.prototype.isActionValid = function (action) {
        return _Game_Enemy_isActionValid.apply(this, arguments) && this.isExistValidTarget($dataSkills[action.skillId]);
    };

    //=============================================================================
    // Game_Action
    //  スキルやアイテムの対象として選択不可能な対象に選択しないようにします。
    //=============================================================================
    Game_Action.prototype.isExistTarget = function () {
        BattleManager.setTargetAction(this);
        var targets = [];
        if (this.isForOpponent()) {
            targets = this.targetsForOpponents();
        } else if (this.isForFriend()) {
            targets = this.targetsForFriends();
        }
        BattleManager.setTargetAction(null);
        return targets.length > 0 && targets[0] !== null;
    };

    var _Game_Action_subject = Game_Action.prototype.subject;
    Game_Action.prototype.subject = function () {
        $gameTroop.setNeedOriginalMember(true);
        var subject = _Game_Action_subject.apply(this, arguments);
        $gameTroop.setNeedOriginalMember(false);
        return subject;
    };

    var _Game_Action_makeTargets = Game_Action.prototype.makeTargets;
    Game_Action.prototype.makeTargets = function () {
        BattleManager.setTargetAction(this);
        var targets = _Game_Action_makeTargets.apply(this, arguments);
        BattleManager.setTargetAction(null);
        return targets;
    };

    var _Game_Action_decideRandomTarget = Game_Action.prototype.decideRandomTarget;
    Game_Action.prototype.decideRandomTarget = function () {
        BattleManager.setTargetAction(this);
        _Game_Action_decideRandomTarget.apply(this, arguments);
        BattleManager.setTargetAction(null);
    };

    //=============================================================================
    // Game_Unit
    //  スキルやアイテムの対象として選択不可能な対象に選択しないようにします。
    //=============================================================================
    var _Game_Unit_smoothTarget = Game_Unit.prototype.smoothTarget;
    Game_Unit.prototype.smoothTarget = function (index) {
        arguments[0] = this.shiftIndexForRestrictionTarget(index);
        return _Game_Unit_smoothTarget.apply(this, arguments);
    };

    var _Game_Unit_smoothDeadTarget = Game_Unit.prototype.smoothDeadTarget;
    Game_Unit.prototype.smoothDeadTarget = function (index) {
        arguments[0] = this.shiftIndexForRestrictionTarget(index);
        return _Game_Unit_smoothDeadTarget.apply(this, arguments);
    };

    Game_Unit.prototype.filterSelectableMembers = function (members) {
        var action = BattleManager.getTargetAction();
        if (action) {
            this._needOriginalMember = true;
            members = members.filter(function (member) {
                return member.canSelectTarget(action.item(), action.subject());
            });
            this._needOriginalMember = false;
        }
        return members;
    };

    Game_Unit.prototype.shiftIndexForRestrictionTarget = function (index) {
        this._needOriginalMember = true;
        var allMember = this.members();
        this._needOriginalMember = false;
        return this.members().indexOf(allMember[index]);
    };

    Game_Unit.prototype.setNeedOriginalMember = function (value) {
        this._needOriginalMember = value;
    };

    // for DeadOrAliveItem.js
    var _Game_Unit_smoothTargetDeadOrAlive = Game_Unit.prototype.smoothTargetDeadOrAlive;
    Game_Unit.prototype.smoothTargetDeadOrAlive = function (index) {
        this._needOriginalMember = true;
        var member = _Game_Unit_smoothTargetDeadOrAlive.apply(this, arguments);
        this._needOriginalMember = false;
        return member;
    };

    //=============================================================================
    // Game_Party
    //  スキルやアイテムの対象として選択不可能な対象に選択しないようにします。
    //=============================================================================
    var _Game_Party_members = Game_Party.prototype.members;
    Game_Party.prototype.members = function () {
        var members = _Game_Party_members.apply(this, arguments);
        return this._needOriginalMember ? members : this.filterSelectableMembers(members);
    };

    Game_Party.prototype.getSkillUser = function () {
        return SceneManager.isCurrentSceneItem() ? null : this.menuActor();
    };

    //=============================================================================
    // Game_Troop
    //  スキルやアイテムの対象として選択不可能な対象に選択しないようにします。
    //=============================================================================
    var _Game_Troop_members = Game_Troop.prototype.members;
    Game_Troop.prototype.members = function () {
        var members = _Game_Troop_members.apply(this, arguments);
        return this._needOriginalMember ? members : this.filterSelectableMembers(members);
    };

    //=============================================================================
    // BattleManager
    //  対象決定中のアクションを設定します。
    //=============================================================================
    BattleManager.setTargetAction = function (action) {
        this._targetAction = action;
    };

    BattleManager.getTargetAction = function () {
        return this._targetAction;
    };

    //=============================================================================
    // SceneManager
    //  アイテム画面かどうかを判定します。
    //=============================================================================
    SceneManager.isCurrentSceneItem = function () {
        return this._scene instanceof Scene_Item;
    };

    //=============================================================================
    // Scene_ItemBase
    //  アイテム効果の対象から無効なアクターを除外します。
    //=============================================================================
    var _Scene_ItemBase_itemTargetActors = Scene_ItemBase.prototype.itemTargetActors;
    Scene_ItemBase.prototype.itemTargetActors = function () {
        var members = _Scene_ItemBase_itemTargetActors.apply(this, arguments);
        return members.filter(function (member) {
            return member.canSelectTarget(this.item(), $gameParty.getSkillUser());
        }, this);
    };

    //=============================================================================
    // Window_Selectable
    //  対象アクターに対してスキルを使用可能か判定します。
    //=============================================================================
    Window_Selectable.prototype.canSelectSkillTarget = function (item, index, user) {
        return this.getMember(index).canSelectTarget(item, user);
    };

    //=============================================================================
    // Window_BattleActor
    //  無効な対象は選択不可能にします。
    //=============================================================================
    Window_BattleActor.prototype.drawItem = function (index) {
        if (!this.canSelectSkillTarget(index)) {
            this.changePaintOpacity(false);
        }
        Window_BattleStatus.prototype.drawItem.apply(this, arguments);
        this.changePaintOpacity(true);
    };

    Window_BattleActor.prototype.isCurrentItemEnabled = function () {
        return this.canSelectSkillTarget(this.index());
    };

    Window_BattleActor.prototype.canSelectSkillTarget = function (index) {
        var action = BattleManager.inputtingAction();
        return !action || Window_Selectable.prototype.canSelectSkillTarget.call(this,
            action.item(), index, action.subject());
    };

    Window_BattleActor.prototype.getMember = function (index) {
        return $gameParty.members()[index];
    };

    //=============================================================================
    // Window_BattleEnemy
    //  無効な対象は選択不可能にします。
    //=============================================================================
    var _Window_BattleEnemy_drawItem = Window_BattleEnemy.prototype.drawItem;
    Window_BattleEnemy.prototype.drawItem = function (index) {
        if (!this.canSelectSkillTarget(index)) {
            this.changePaintOpacity(false);
        }
        _Window_BattleEnemy_drawItem.apply(this, arguments);
        this.changePaintOpacity(true);
    };

    Window_BattleEnemy.prototype.isCurrentItemEnabled = Window_BattleActor.prototype.isCurrentItemEnabled;
    Window_BattleEnemy.prototype.canSelectSkillTarget = Window_BattleActor.prototype.canSelectSkillTarget;

    Window_BattleEnemy.prototype.getMember = function (index) {
        return this._enemies[index];
    };

    //=============================================================================
    // Window_MenuActor
    //  無効な対象は選択不可能にします。
    //=============================================================================
    Window_MenuActor.prototype.drawItemStatus = function (index) {
        if (!this.canSelectSkillTarget(index)) {
            this.changePaintOpacity(false);
        }
        Window_MenuStatus.prototype.drawItemStatus.apply(this, arguments);
        this.changePaintOpacity(true);
    };

    var _Window_MenuActor_processOk = Window_MenuActor.prototype.processOk;
    Window_MenuActor.prototype.processOk = function () {
        if (this.isCurrentItemEnabled() || this.cursorAll()) {
            _Window_MenuActor_processOk.apply(this, arguments);
        } else {
            SoundManager.playBuzzer();
        }
    };

    var _Window_MenuActor_selectForItem = Window_MenuActor.prototype.selectForItem;
    Window_MenuActor.prototype.selectForItem = function (item) {
        this._targetItem = item;
        _Window_MenuActor_selectForItem.apply(this, arguments);
        this.refresh();
    };

    Window_MenuActor.prototype.canSelectSkillTarget = function (index) {
        var item = this._targetItem;
        return !item || Window_Selectable.prototype.canSelectSkillTarget.call(this,
            item, index, $gameParty.getSkillUser());
    };

    Window_MenuActor.prototype.isCurrentItemEnabled = Window_BattleActor.prototype.isCurrentItemEnabled;
    Window_MenuActor.prototype.getMember = Window_BattleActor.prototype.getMember;
})();


code:
/*:ja
 * @plugindesc 経路探索の距離を変更します。
 * @author mijiishi
 *
 * @help このプラグインには、プラグインコマンドはありません。
 */

(function () {

    Game_Character.prototype.searchLimit = function () {
        return 50;
    };

})();