code:
//
//  汎用ポップアップコア ver1.05
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

var Imported = Imported || {};
Imported['CommonPopupCore'] = 1.05;

/*:
 * @plugindesc ver1.05/汎用的なポップアップの仕組みを提供するためのベースプラグインです。
 * @author Yana
 *
 * @param Text Back Color
 * @desc ポップアップの背景カラーです。
 * rgba(red,green,blue,alpha)で設定してください。
 * @default rgba(0,0,0,0.6)
 *
 * @param Text Back FileName
 * @desc ポップアップの背景画像名です。
 * %dがインデックスに変換されます。
 * @default popup_back%d
 *
 * @help プラグインコマンド
 * CommonPopup add param1 param2 param3 ・・・
 *
 * 必要なパラメータのみを指定できます。
 *  例:プレイヤーの上にテストと240フレームポップアップさせる
 * CommonPopup add text:テスト count:240 eventId:-1
 *
 * パラメータ詳細:
 * text:表示テキスト
 * eventId:表示するイベントのID
 * count:表示時間
 * delay:表示遅延
 * moveX:目標地点X(相対座標)
 * moveY:目標地点Y(相対座標)
 * sx:表示位置補正X
 * sy:表示位置補正Y
 * pattern:表示パターン　0がフェード、-1が横ストレッチ、-2が縦ストレッチ
 * back:-1:透明背景,0:背景カラーで塗りつぶし,1以上:画像インデックス
 * bx:内容の表示位置補正X
 * by:内容の表示位置補正Y
 * extend:表示タイミングの調整用配列で指定。 例:extend:[20,50] 20フレーム掛けて出現し、50フレーム目から消え始める。
 * fixed:画面に固定するか？ true/falseで指定。
 * anchorX:
 * anchorY:
 * slideCount:新しいポップアップが発生した際、上にスライドさせる速度。
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 当プラグインはMITライセンスで公開されています。
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * このプラグインは、汎用的なポップアップの仕組みを提供するプラグインです。
 * このプラグイン単体ではプラグインコマンドを追加する以外の機能はありません。
 * 追加機能として、
 * ・\I[x]で描画されるアイコンのサイズが文字サイズに追従する。
 * ・文字サイズ変更の制御文字、\FS[x]が追加される。
 * の2点が追加されます。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.05:170525
 * ポップアップ発生時にSEを再生する機能を追加。
 * ver1.04
 * YEP_MessageCoreとの競合回避処理を追加。
 * 動作パターンに縦ストレッチと横ストレッチを追加。
 * ポップアップ用のプラグインパラメータが正常に動作していなかったバグを修正。
 * ver1.03:
 * backのパラメータにpicturesフォルダのファイル名を指定できるように変更。
 * ver1.02:
 * スライドに上から下に動作するようにする機能を追加。
 * ver1.01:
 * containerが作成されていない状態で、ポップアップが登録される可能性のあるバグを修正しました。
 * ver1.00:
 * 公開
 */

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

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

(function(){
    var parameters = PluginManager.parameters('CommonPopupCore');
    var commonPopupTextBackColor = String(parameters['Text Back Color'] || 'rgba(0, 0, 0, 0.6)');
    var commonPopupTextBackFileName = String(parameters['Text Back FileName'] || 'popup_back%d');

    var _cPU_GInterpreter_pluginCommand =
            Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _cPU_GInterpreter_pluginCommand.call(this, command, args);
        if (command === 'CommonPopup' || command === 'ポップアップ') {
            switch (args[0]) {
                case 'add':
                case '表示':
                    this.addPopup(args);
                    break;
                case 'clear':
                case '消去':
                    CommonPopupManager.clearPopup();
                    break;
            }
        }
    };

    Array.prototype.setNullPos = function(object){
        for(var i=0; i < this.length; i++){
            if (this[i] === null || this[i] === undefined){
                this[i] = object;
                return i;
            }
        }
        this.push(object);
    };

    Array.prototype.compact = function() {
        var result = [];
        for (var i = 0; i < this.length; i++) {
            if (this[i] !== null && this[i] !== undefined) {
                result.push(this[i]);
            }
        }
        return result;
    };

    CommonPopupManager.initTempSprites = function(){
        this._tempCommonSprites = new Array(50);
        this._setedPopups = [];
        this._readyPopup = [];
    };

    CommonPopupManager.window = function(){
        if (this._window){return this._window }
        this._window = new Window_Base(0,0,Graphics.boxWidth,Graphics.boxHeight);
        return this._window;
    };

    CommonPopupManager.testBitmap = function(){
        if (this._testBitmap){return this._testBitmap }
        this._testBitmap = new Bitmap(1,1);
        return this._testBitmap;
    };

    Sprite_Popup.prototype = Object.create(Sprite.prototype);
    Sprite_Popup.prototype.constructor = Sprite_Popup;

    Sprite_Popup.prototype.initialize = function(index){
        Sprite.prototype.initialize.call(this);
        this._index = index;
        this._count = 0;
        this._enable = false;
        this.update();
    };

    Sprite_Popup.prototype.setMembers = function(arg){
        this._count = arg.count;
        this._arg = arg;
        this.anchor.x = arg.anchorX;
        this.anchor.y = arg.anchorY;
        this.x = arg.x;
        this.y = arg.y;
        this.z = 6;
        this.visible = true;
        this._enable = true;
        this.createBitmap();
        if (arg.slideCount){
            CommonPopupManager._setedPopups.push([this._index, this.height, this._arg.slideCount]);
        }
    };

    Sprite_Popup.prototype.createBitmap = function(){
        if (this._arg.bitmap){
            this.bitmap = this._arg.bitmap;
        }else{
            CommonPopupManager.window().resetFontSettings();
            var text = this._arg.text;
            var width = CommonPopupManager.window().textWidth(text);
            var height = CommonPopupManager.window().contents.fontSize + 8;
            var sh = 8;
            if (this._arg.back === 0){ sh = 2 }
            CommonPopupManager.window().createContents();
            this.bitmap = new Bitmap(width+24,height+sh);
            this.drawBackRect(width+24,height+sh);
            CommonPopupManager.window().drawTextEx(this._arg.text,12,4);
            this.bitmap.blt(CommonPopupManager.window().contents,0,0,width+24,height+sh,this._arg.bx,this._arg.by+2);
        }
    };

    Sprite_Popup.prototype.drawBackRect = function(width,height){
        switch (this._arg.back){
            case 0:
                var color1 = commonPopupTextBackColor;
                var color2 = 'rgba(0,0,0,0)';
                var dSize = width / 4;
                this.bitmap.gradientFillRect(0,0,dSize,height,color2,color1);
                this.bitmap.fillRect(dSize,0,dSize*2,height,color1);
                this.bitmap.gradientFillRect(dSize*3,0,dSize,height,color1,color2);
                break;
            case -1:
                break;
            default:
                var bitmap = CommonPopupManager.makeBitmap(this._arg);
                var w = this._bitmap.width;
                var h = this._bitmap.height;
                if (typeof this._arg.back === 'string') {
                    w = bitmap.width > this._bitmap.width ? bitmap.width : w;
                    h = bitmap.height > this._bitmap.height ? bitmap.height : h;
                    if (w > this._bitmap.width || h > this._bitmap.height){
                        this.bitmap = new Bitmap(w,h);
                    }
                }
                this.bitmap.blt(bitmap,0,0,bitmap.width,bitmap.height,0,0,w,h);
                bitmap.clear();
                bitmap = null;
        }
    };

    Sprite_Popup.prototype.update = function(){
        Sprite.prototype.update.call(this);
        if (CommonPopupManager._tempCommonSprites[this._index] && !this._enable){
            if (CommonPopupManager._tempCommonSprites[this._index].delay === 0){
                this.setMembers(CommonPopupManager._tempCommonSprites[this._index]);
                if (this._arg && this._arg.se.name) AudioManager.playSe(this._arg.se);
            }else{
                CommonPopupManager._tempCommonSprites[this._index].delay--;
            }
        }
        if (this._count > 0){
            this._count--;
            if (!this._arg){
                this.terminate;
                return;
            }
            switch(this._arg.pattern){
                case 0:
                case '0':
                case 'Normal':
                    this.updateSlide();
                    break;
                case -1:
                case '-1':
                case 'Stretch':
                    this.updateTurn();
                    break;
                case -2:
                case '-2':
                case 'GrowUp':
                    this.updateGrowUp();
                    break;
                default:
                    this.updateAnime();
            }
            if (this._count === 0){ this.terminate() }
        }
        if (this._arg && this._arg.slideCount){ this.updateMoveSlide() }
    };

    Sprite_Popup.prototype.updateMoveSlide = function(){
        if (CommonPopupManager._setedPopups) {
            var array = CommonPopupManager._setedPopups.clone().reverse();
            var n = 0;
            for (var i = 0; i < array.length; i++) {
                if (this._index === array[i][0]) {
                    if (this._arg.slideAction === 'Down'){
                        this.y = this.y + n;
                    } else {
                        this.y = this.y - n;
                    }
                }
                var sprite = CommonPopupManager._tempCommonSprites[array[i][0]];
                if (sprite.pattern === -2 || sprite.pattern === 'GrowUp'){
                    n += (array[i][1] * sprite.rate);
                } else {
                    n += (array[i][1] * ((this._arg.slideCount - array[i][2]) / this._arg.slideCount));
                }
            }
            for (var i = 0; i < CommonPopupManager._setedPopups.length; i++) {
                CommonPopupManager._setedPopups[i][2]--;
                if (CommonPopupManager._setedPopups[i][2] < 0) {
                    CommonPopupManager._setedPopups[i][2] = 0
                }
            }
            array = null;
        }
    };

    Sprite_Popup.prototype.updateSlide = function(){
        var originalWait = this._arg.count;
        var cnt = originalWait - this._count;
        this.opacity = 255;
        var act = [originalWait / 4, (originalWait * 3) / 4];
        if (this._arg.extend !== ''){ act = this._arg.extend }
        var oa = Math.max(originalWait - act[1],1);
        var n1 = Math.max(originalWait / oa,0.1);
        var up = (this._arg.moveY / (originalWait / n1));
        var slide = (this._arg.moveX / (originalWait / n1));
        var opTime1 =  originalWait / 3.0;
        var moveX = 0;
        var moveY = 0;
        if (act[2]){ opTime1 = originalWait - act[2] }
        var opTime2 = originalWait / 3.0;
        if (act[3]){ opTime2 = act[3] }
        if (this._count >= act[1]){
            this.opacity = Math.floor(255 * (cnt / opTime1));
            moveY = Math.floor(up * cnt);
            moveX = Math.floor(slide * cnt);
        }else if (this._count < act[0]){
            this.opacity = Math.floor(255 * (this._count / opTime2));
            moveY = Math.floor((originalWait / n1) * up);
            moveX = Math.floor((originalWait / n1) * slide);
        }else{
            moveY = Math.floor((originalWait / n1) * up);
            moveX = Math.floor((originalWait / n1) * slide);
        }
        this._times = cnt;
        this.setPosition(moveX,moveY);
    };

    Sprite_Popup.prototype.updateTurn = function() {
        var originalWait = this._arg.count;
        var cnt = originalWait - this._count;
        var act = [originalWait * 0.25, originalWait * 0.75];
        if (this._arg.extend) act = this._arg.extend;
        if (this._count === 0) this.scale.x = 0;
        var oa = Math.max(originalWait - act[1],1);
        var n1 = Math.max(originalWait / oa,0.1);
        var up = (this._arg.moveY / (originalWait / n1));
        var slide = (this._arg.moveX / (originalWait / n1));
        var moveX = 0;
        var moveY = 0;
        if (this._count >= act[1]){
            var rate  = cnt / (originalWait - act[1]);
            this.scale.x = rate;
            moveY = Math.floor(up * cnt);
            moveX = Math.floor(slide * cnt);
        } else if (this._count < act[0]) {
            var rate = this._count / act[0];
            this.scale.x = rate;
            moveY = Math.floor((originalWait / n1) * up);
            moveX = Math.floor((originalWait / n1) * slide);
        } else {
            moveY = Math.floor((originalWait / n1) * up);
            moveX = Math.floor((originalWait / n1) * slide);
        }
        this._times = cnt;
        this.setPosition(moveX,moveY);
    };

    Sprite_Popup.prototype.updateGrowUp = function() {
        var originalWait = this._arg.count;
        var cnt = originalWait - this._count;
        var act = [originalWait * 0.25, originalWait * 0.75];
        if (this._arg.extend) act = this._arg.extend;
        if (this._count === 0) this.scale.y = 0;
        var oa = Math.max(originalWait - act[1],1);
        var n1 = Math.max(originalWait / oa,0.1);
        var up = (this._arg.moveY / (originalWait / n1));
        var slide = (this._arg.moveX / (originalWait / n1));
        var moveX = 0;
        var moveY = 0;
        if (this._count >= act[1]){
            var rate  = cnt / (originalWait - act[1]);
            this.scale.y = rate;
            moveY = Math.floor(up * cnt);
            moveX = Math.floor(slide * cnt);
            this._arg.rate = rate;
        } else if (this._count < act[0]) {
            var rate = this._count / act[0];
            this.scale.y = rate;
            moveY = Math.floor((originalWait / n1) * up);
            moveX = Math.floor((originalWait / n1) * slide);
            this._arg.rate = rate;
        } else {
            moveY = Math.floor((originalWait / n1) * up);
            moveX = Math.floor((originalWait / n1) * slide);
        }
        this._times = cnt;
        this.setPosition(moveX,moveY);
    };

    Sprite_Popup.prototype.setPosition = function(x,y) {
        this.x = this._arg.x + x + this._arg.sx;
        this.y = this._arg.y + y + this._arg.sy;
        if (this._arg.battler){
            if ($gameParty.inBattle()) {
                this.x += this._arg.battler.x;
                this.y += this._arg.battler.y;
            } else {
                this.x += this._arg.battler._realX * $gameMap.tileWidth();
                this.y += this._arg.battler._realY * $gameMap.tileHeight();
            }
        }
        var xx = this.x;
        var yy = this.y;
        if (this._arg.fixed){
            var dx = $gameMap._displayX;
            var dy = $gameMap._displayY;
            xx = this.x - dx * $gameMap.tileWidth();
            yy = this.y - dy * $gameMap.tileHeight();
            if (xx < 0 || yy < 0){
                if (xx < 0 && $gameMap.isLoopHorizontal()) dx -= $dataMap.width;
                if (yy < 0 && $gameMap.isLoopVertical()) dy -= $dataMap.height;
                xx = this.x - dx * $gameMap.tileWidth();
                yy = this.y - dy * $gameMap.tileHeight();
            }
        }
        this.x = xx;
        this.y = yy;
    };

    Sprite_Popup.prototype.updateAnime = function(){
        var anime = $dataAnimations[Number(this._arg.pattern)];
        var frameId = Math.floor((anime.frames.length * (this._arg.count - this._count)) / this._arg.count);
        if (frameId !== anime.frames.length ){
            var array = anime.frames[frameId][0];
            var x = array[1];
            var y = array[2];
            this.x = this._arg.x + x + this._arg.sx;
            this.y = this._arg.y + y + this._arg.sy;
            this.scale = new Point(array[3]/100,array[3]/100);
            this.rotation = array[4];
            this.opacity = array[6];
            this.blendMode = array[7];
        }
    };

    Sprite_Popup.prototype.terminate = function(){
        this.bitmap = null;
        this.visible = false;
        this._enable = false;
        this._count = 0;
        this._arg = null;

        if (CommonPopupManager._tempCommonSprites[this._index]) {
            CommonPopupManager._tempCommonSprites[this._index].terminate = true;
        }
        if (CommonPopupManager._setedPopups) {
            for (var i = 0; i < CommonPopupManager._setedPopups.length; i++) {
                if (CommonPopupManager._setedPopups[i][0] === this._index) {
                    delete CommonPopupManager._setedPopups[i];
                }
            }
            CommonPopupManager._setedPopups = CommonPopupManager._setedPopups.compact();
        }
    };

    Game_Interpreter.prototype.addPopup = function(argParam){
        var eventId = 0;
        for (var i=0;i<argParam.length;i++){
            if (argParam[i].match(/^eventId:(.+)/g)){
                eventId = Number(RegExp.$1);
                break;
            }
        }
        var character = this.character(eventId);
        var arg = CommonPopupManager.setPopup(argParam,character);
        if (arg.back > 0 || typeof arg.back === 'string'){
            CommonPopupManager.bltCheck(CommonPopupManager.makeBitmap(arg));
            CommonPopupManager._readyPopup.push(arg);
        }else{
            CommonPopupManager._tempCommonSprites.setNullPos(arg);
        }
    };

    CommonPopupManager.setPopup = function(argParam,character){
        var arg = {
            x:null,
            y:null,
            text:'',                // 表示テキスト
            eventId:-1,             // 表示するイベントのID
            count:60,               // 表示時間
            delay:0,                // 表示遅延
            moveX:0,                // 目標地点X(相対座標)
            moveY:-48,              // 目標地点Y(相対座標)
            sx:0,                   // 表示位置補正X
            sy:0,                   // 表示位置補正Y
            pattern:0,              // 表示パターン
            back:-1,                // 背景に使う画像インデックス
            bx:0,                   // 内容の表示位置補正X
            by:0,                   // 内容の表示位置補正Y
            extend:'',              //
            fixed:true,             //
            anchorX:0.5,
            anchorY:0.5,
            battler:null,
            se:{name:'',volume:90,pitch:100,pan:0}
        };
        var array = ['x','y','text','eventId','count','delay','moveX','moveY',
                     'sx','sy','pattern','back','bx','by','extend','fixed',
                     'anchorX','anchorY', 'slideCount'];
        for (var i=0;i < argParam.length;i++){
            if (i > 0){
                for (var j=0;j < array.length;j++){
                    var r = new RegExp('^(' + array[j] + ')' + ':(.+)');
                    if (argParam[i].match(r)){
                        var code = RegExp.$1;
                        var value = RegExp.$2;
                        if (code === 'text' || code === 'extend'){
                            arg[code] = value;
                        }else if (code === 'fixed'){
                            arg[code] = value === 'true';
                        }else if (code === 'back'){
                            arg[code] = (Number(value) !== NaN) ? value : Number(value);
                        } else {
                            arg[code] = Number(value);
                        }
                    }
                }
            }
        }
        if (arg.x === null){
            if (character){
                var screenX = $gameParty.inBattle() ? 0 : character.screenX();
                var displayX = $gameParty.inBattle() ? 0 : $gameMap._displayX * 48;
                arg.x = screenX + displayX;
            } else {
                arg.x = 0;
            }
        }
        if (arg.y === null) {
            if (character) {
                var screenY = $gameParty.inBattle() ? 0 : character.screenY();
                var displayY = $gameParty.inBattle() ? 0 : $gameMap._displayY * 48;
                arg.y = screenY + displayY;
            } else {
                arg.y = 0;
            }
        }
        if (arg.extend) {
            arg.extend = eval(arg.extend);
        }

        arg.terminate = false;
        return arg;
    };

    CommonPopupManager.setPopUpdate = function(){
        if (this._readyPopup){
            for (var i=0;i<this._readyPopup.length;i++){
                if (this._readyPopup[i]){
                    var arg = this._readyPopup[i];
                    if(ImageManager.isReady()){
                        this.startPopup(arg);
                        delete this._readyPopup[i];
                        this._readyPopup.compact();
                        return;
                    }else{
                        this.bltCheck(this.makeBitmap(arg));
                    }
                }
            }
        }
    };

    CommonPopupManager.makeBitmap = function(arg){
        if (typeof arg.back === 'number'){
            var fileName = commonPopupTextBackFileName;
            fileName = fileName.replace(/%d/g,arg.back);
            return ImageManager.loadSystem(fileName);
        } else {
            var fileName = arg.back;
            return ImageManager.loadPicture(fileName);
        }
    };

    CommonPopupManager.bltCheck = function(bitmap){
        this.testBitmap().blt(bitmap,0,0,bitmap.width,bitmap.height,0,0);
        //this.testBitmap().clear();
        //bitmap.clear();
        bitmap = null;
    };

    CommonPopupManager.startPopup = function(arg){
        CommonPopupManager._tempCommonSprites.setNullPos(arg);
    };

    CommonPopupManager.clearPopup = function(tag) {
        if (!CommonPopupManager._tempCommonSprites){
            CommonPopupManager.initTempSprites();
        }

        for(var i=0;i<CommonPopupManager._tempCommonSprites.length;i++){
            if (CommonPopupManager._tempCommonSprites[i]){
                if (!tag || tag === CommonPopupManager._tempCommonSprites[i].tag) {
                    CommonPopupManager._tempCommonSprites[i].delay = 0;
                    CommonPopupManager._tempCommonSprites[i].count = 1;
                    var sprite = CommonPopupManager._tempCommonSprites[i].sprite;
                    if (sprite) sprite._count = 1;
                }
            }
        }
    };

    var _cPU_SsBase_initialize = Spriteset_Base.prototype.initialize;
    Spriteset_Base.prototype.initialize = function(){
        _cPU_SsBase_initialize.call(this);
        this.createSpritePopup();
    };

    var _cPU_SsBase_update = Spriteset_Base.prototype.update;
    Spriteset_Base.prototype.update = function(){
        _cPU_SsBase_update.call(this);
        if (this._popupContainer === undefined){ return }
        if(CommonPopupManager._tempCommonSprites){
            for(var i=0;i<CommonPopupManager._tempCommonSprites.length;i++){
                if (CommonPopupManager._tempCommonSprites[i]){
                    if (CommonPopupManager._tempCommonSprites[i].terminate){
                        var sprite = CommonPopupManager._tempCommonSprites[i].sprite;
                        this._popupContainer.removeChild(sprite);
                        delete CommonPopupManager._tempCommonSprites[i]
                    }else if (!CommonPopupManager._tempCommonSprites[i].sprite){
                        var sprite = new Sprite_Popup(i);
                        this._popupContainer.addChild(sprite);
                        CommonPopupManager._tempCommonSprites[i].sprite = sprite;
                    }
                }
            }
        }
    };

    var _cPU_SBase_update = Scene_Base.prototype.update;
    Scene_Base.prototype.update = function(){
        _cPU_SBase_update.call(this);
        if(CommonPopupManager){ CommonPopupManager.setPopUpdate() };
    };

    Spriteset_Base.prototype.createSpritePopup = function() {
        var width = Graphics.boxWidth;
        var height = Graphics.boxHeight;
        var x = (Graphics.width - width) / 2;
        var y = (Graphics.height - height) / 2;
        this._popupContainer = new Sprite();
        this._popupContainer.setFrame(x, y, width, height);
        this.addChild(this._popupContainer);
    };

    var _cPU_SBase_terminate = Scene_Base.prototype.terminate;
    Scene_Base.prototype.terminate = function(){
        _cPU_SBase_terminate.call(this);
        this.terminatePopup();
    };

    Scene_Base.prototype.terminatePopup = function(){
        if (!CommonPopupManager._tempCommonSprites){
            CommonPopupManager.initTempSprites();
        }
        for(var i=0;i<CommonPopupManager._tempCommonSprites.length;i++){
            if (CommonPopupManager._tempCommonSprites[i]){
                var sprite = CommonPopupManager._tempCommonSprites[i].sprite;
                if (sprite) sprite.terminate();
                delete CommonPopupManager._tempCommonSprites[i];
            }
        }
        CommonPopupManager._setedPopupss = [];
        CommonPopupManager._readyPopup = [];
    };

    var _cPU_SMap_launchBattle = Scene_Map.prototype.launchBattle;
    Scene_Map.prototype.launchBattle = function(){
        _cPU_SMap_launchBattle.call(this);
        this.terminatePopup();
    };

    // 再定義　文字サイズに合わせてアイコンのサイズを調整する
    Window_Base.prototype.drawIcon = function(iconIndex, x, y) {
        var bitmap = ImageManager.loadSystem('IconSet');
        var pw = Window_Base._iconWidth;
        var ph = Window_Base._iconHeight;
        var sx = iconIndex % 16 * pw;
        var sy = Math.floor(iconIndex / 16) * ph;
        var n = Math.floor((this.contents.fontSize / this.standardFontSize()) * Window_Base._iconWidth);
        var nn = (32 - n) / 2;
        this.contents.blt(bitmap, sx, sy, pw, ph, x, y, n, n);
    };

    // 再定義 processDrawIconをストレッチされた文字サイズに合わせたズレに調整する
    Window_Base.prototype.processDrawIcon = function(iconIndex, textState) {
        this.drawIcon(iconIndex, textState.x + 2, textState.y + 2);
        var n = Math.floor((this.contents.fontSize / this.standardFontSize()) * Window_Base._iconWidth);
        textState.x += n + 4;
    };

    if (!Imported.YEP_MessageCore) {
        // \FS[FontSize]の制御文字を追加する部分です。
        var _cPU_Window_Base_processEscapeCharacter = Window_Base.prototype.processEscapeCharacter;
        Window_Base.prototype.processEscapeCharacter = function (code, textState) {
            if (code === 'FS') {
                var param = this.obtainEscapeParam(textState);
                if (param != '') {
                    this.makeFontSize(param)
                }
            } else {
                _cPU_Window_Base_processEscapeCharacter.call(this, code, textState);
            }
        };
    }
    Window_Base.prototype.makeFontSize = function(fontSize) {
        this.contents.fontSize = fontSize;
    };
})();


code:
/*:
 * @plugindesc Plugin used to set basic parameters.
 * @author RM CoreScript team
 *
 * @help This plugin does not provide plugin commands.
 *
* @param cacheLimit
 * @desc For setting the upper limit of image memory cache. (MPix)
 * @default 10
 *
 * @param screenWidth
* @desc For setting the screen width.
 * @default 816
 *
 * @param screenHeight
 * @desc For setting the screen height.
 * @default 624
 *
 * @param changeWindowWidthTo
 * @desc If set, change window width to this value
 *
 * @param changeWindowHeightTo
 * @desc If set, change window height to this value
 *
 * @param renderingMode
 * @desc Rendering mode (canvas/webgl/auto)
 * @default auto
 *
 * @param alwaysDash
 * @desc To set initial value as to whether the player always dashes. (on/off)
 * @default off
 */

/*:ja
 * @plugindesc 基本的なパラメーターを設定するプラグインです。
 * @author RM CoreScript team
 *
 * @help このプラグインにはプラグインコマンドはありません。
 *
 * @param cacheLimit
 * @desc 画像のメモリへのキャッシュの上限値 (MPix)
 * @default 10
 *
 * @param screenWidth
 * @desc 画面サイズの幅
 * @default 816
 *
 * @param screenHeight
 * @desc 画面サイズの高さ
 * @default 624
 *
 * @param changeWindowWidthTo
 * @desc 値が設定された場合、ウインドウの幅を指定した値に変更
 *
 * @param changeWindowHeightTo
 * @desc 値が設定された場合、ウインドウの高さを指定した値に変更
 *
 * @param renderingMode
 * @desc レンダリングモード (canvas/webgl/auto)
 * @default auto
 *
 * @param alwaysDash
 * @desc プレイヤーが常時ダッシュするかどうかの初期値 (on/off)
 * @default off
 */

(function() {
    function toNumber(str, def) {
        return isNaN(str) ? def : +(str || def);
    }

    var parameters = PluginManager.parameters('Community_Basic');
    var cacheLimit = toNumber(parameters['cacheLimit'], 10);
    var screenWidth = toNumber(parameters['screenWidth'], 816);
    var screenHeight = toNumber(parameters['screenHeight'], 624);
    var renderingMode = parameters['renderingMode'].toLowerCase();
    var alwaysDash = parameters['alwaysDash'].toLowerCase() === 'on';
    var windowWidthTo = toNumber(parameters['changeWindowWidthTo'], 0);
    var windowHeightTo = toNumber(parameters['changeWindowHeightTo'], 0);

    var windowWidth;
    var windowHeight;

    if(windowWidthTo){
        windowWidth = windowWidthTo;
    }else if(screenWidth !== SceneManager._screenWidth){
        windowWidth = screenWidth;
    }

    if(windowHeightTo){
        windowHeight = windowHeightTo;
    }else if(screenHeight !== SceneManager._screenHeight){
        windowHeight = screenHeight;
    }

    ImageCache.limit = cacheLimit * 1000 * 1000;
    SceneManager._screenWidth = screenWidth;
    SceneManager._screenHeight = screenHeight;
    SceneManager._boxWidth = screenWidth;
    SceneManager._boxHeight = screenHeight;

    SceneManager.preferableRendererType = function() {
        if (Utils.isOptionValid('canvas')) {
            return 'canvas';
        } else if (Utils.isOptionValid('webgl')) {
            return 'webgl';
        } else if (renderingMode === 'canvas') {
            return 'canvas';
        } else if (renderingMode === 'webgl') {
            return 'webgl';
        } else {
            return 'auto';
        }
    };

    var _ConfigManager_applyData = ConfigManager.applyData;
    ConfigManager.applyData = function(config) {
        _ConfigManager_applyData.apply(this, arguments);
        if (config['alwaysDash'] === undefined) {
            this.alwaysDash = alwaysDash;
        }
    };

    var _SceneManager_initNwjs = SceneManager.initNwjs;
    SceneManager.initNwjs = function() {
        _SceneManager_initNwjs.apply(this, arguments);

        if (Utils.isNwjs() && windowWidth && windowHeight) {
            var dw = windowWidth - window.innerWidth;
            var dh = windowHeight - window.innerHeight;
            window.moveBy(-dw / 2, -dh / 2);
            window.resizeBy(dw, dh);
        }
    };
})();

repo_name: dazed/translations

license: unknown


code:
//
//  条件付き○○用ベース ver1.07
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

var Imported = Imported || {};
Imported['ConditionallyCore'] = 1.07;

/*:
 * @plugindesc ver1.07/条件付き○○のプラグインを使用するのに、必要となる条件をまとめたベースプラグインです。
 * @author Yana
 *
 * @help プラグインコマンドはありません。
 *
 * このプラグインは、条件ドロップ、条件変化スキル、条件付き追加効果を使用するときに必要となります。
 *
 * 条件の設定方法
 *
 * ○○××
 *
 * というように組み合わせて設定します。
 *
 * ○○=対象
 * ××=基本条件
 * ◇◇=条件設定
 *
 * となります。
 *
 * ======================================================
 * ○○で設定可能な対象
 * 対象
 * 味方
 * 敵
 * 討伐者
 * (何もなし)
 * ・対象=行動の対象が条件を満たすか判定します。
 * ・味方=仲間全体のうちいずれかが条件を満たすか判定します。
 * ・敵=敵全体のうちいずれかが条件を満たすか判定します。
 * ・討伐者=トドメを刺した者が条件を満たすか判定します。(条件ドロップ用)
 * ・(何もなし)=使用者または倒された対象が条件を満たすか判定します。
 * ------------------------------------------------------
 * ××で設定可能な条件
 * ターン条件:○以上
 * ターン条件:○以下
 * ・現在(または倒した時)のターン数が○以上(以下)の時、条件を満たします。
 * ターン条件:○-○以内
 * ターン条件:○-○以外
 * ・現在(または倒した時)のターン数が○-○以内(以外)の時、条件を満たします。
 * ターン条件:○,○,○,○・・・・
 * ・現在(または倒した時)のターン数が○,○,○,○・・・のいずれかの時、条件を満たします。
 *
 * 例:
 * ターン条件:5以上
 * ターン条件:5以下
 * ターン条件:5-7以内
 * ターン条件:5-8以外
 * ターン条件:5,6,7,8,9,10
 * ------------------------------------------------------
 * ステート条件:×:○,○,○,○・・・・
 * ・現在(または倒した時)にステート○,○,○,○・・・のうち×個にかかっている時、条件を満たします。
 *
 * 例:
 * ステート条件:×:○,○,○,○・・・・
 * 対象ステート条件:×:○,○,○,○・・・・
 * 討伐者ステート条件:×:○,○,○,○・・・・
 * 敵ステート条件:×:○,○,○,○・・・・
 * 味方ステート条件:×:○,○,○,○・・・・
 * -----------------------------------------------------
 * ID条件
 * ID条件:○,○,○,○・・・
 * ・対象のIDが○のいずれかの時に条件を満たします。
 *
 * 例:
 * ID条件:4,5,6,7,8
 * 対象ID条件:4,5,6,7,8
 * 討伐者ID条件:4,5,6,7,8
 * 敵ID条件:4,5,6,7,8
 * 味方ID条件:4,5,6,7,8
 * ------------------------------------------------------
 * ステータス条件:××○以上
 * ステータス条件:××○%以上
 * ステータス条件:××○以下
 * ステータス条件:××○%以下
 * ・現在(または倒した時)に××のステータスが○(%)以上(以下)の時、条件を満たします。
 * ステータス条件:××○-○以内
 * ステータス条件:××○%-○%以内
 * ステータス条件:××○-以外
 * ステータス条件:××○%-○%以外
 * ・現在(または倒した時)に××のステータスが○(%)-○(%)以内(以外)の時、条件を満たします。
 * ステータス条件:××○の倍数
 * ・現在(または倒した時)に××のステータスが○の倍数の時、条件を満たします。
 *
 * 例:
 * ステータス条件:HP40%以上
 * ステータス条件:HP40%-80%以内
 * 対象ステータス条件:攻撃力30以上
 * 敵ステータス条件:運4の倍数
 * 味方ステータス条件:回避率100%以上
 * 討伐者ステータス条件:HP再生率10%以下
 * ------------------------------------------------------
 * 属性有効度条件:×,○：◇%以上,○：◇%以下,○：◇%以上・・・
 * ・現在(または倒した時)に○の属性の有効度が◇%以上(以下)のうちx個を満たす時、条件を満たします。
 *
 * 例：
 * 属性有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 対象属性有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 討伐者属性有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 敵属性有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 味方属性有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * ------------------------------------------------------
 * ステート有効度条件:×,○：◇%以上,○：◇%以下,○：◇%以上・・・
 * ・現在(または倒した時)に○番のステートの有効度が◇%以上(以下)のうちx個を満たす時、条件を満たします。
 *
 * 例：
 * ステート有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 対象ステート有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 討伐者ステート有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 敵ステート有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * 味方ステート有効度条件：2,1:40%以上,2:60%以上,3:70%以下
 * ------------------------------------------------------
 * 人数条件:○以上
 * 人数条件:○以下
 * ・現在(または倒した時)の戦闘参加人数が○以上(以下)の時、条件を満たします。
 * 人数条件:○-○以内
 * 人数条件:○-○以外
 * ・現在(または倒した時)の戦闘参加人数が○-○以内(以外)の時、条件を満たします。
 * 人数条件:○,○,○,○・・・・
 * ・現在(または倒した時)の戦闘参加人数が○,○,○,○・・・のいずれかの時、条件を満たします。
 *
 * 例:
 * 人数条件:5以上
 * 人数条件:5以下
 * 人数条件:5-7以内
 * 人数条件:5-8以外
 * 人数条件:5,6,7,8,9,10
 * 対象人数条件:5以上
 * 対象人数条件:5以下
 * 対象人数条件:5-7以内
 * 対象人数条件:5-8以外
 * 対象人数条件:5,6,7,8,9,10
 * ------------------------------------------------------
 * ××で設定可能な条件
 * 生存人数条件:○以上
 * 生存人数条件:○以下
 * ・現在の生存人数が○以上(以下)の時、条件を満たします。
 * 生存人数条件:○-○以内
 * 生存人数条件:○-○以外
 * ・現在の生存人数が○-○以内(以外)の時、条件を満たします。
 * 生存人数条件:○,○,○,○・・・・
 * ・現在の生存人数が○,○,○,○・・・のいずれかの時、条件を満たします。
 *
 * 例:
 * 生存人数条件:5以上
 * 生存人数条件:5以下
 * 生存人数条件:5-7以内
 * 生存人数条件:5-8以外
 * 生存人数条件:5,6,7,8,9,10
 * 対象生存人数条件:5以上
 * 対象生存人数条件:5以下
 * 対象生存人数条件:5-7以内
 * 対象生存人数条件:5-8以外
 * 対象生存人数条件:5,6,7,8,9,10
 * ------------------------------------------------------
 * 変数条件:×が○以上
 * 変数条件:×が○以下
 * ・変数×の値が○以上(以下)の時、条件を満たします。
 *
 * 例:
 * 変数条件:5が10以上
 * 変数条件:5が10以下
 * ------------------------------------------------------
 * スイッチ条件:×がON
 * スイッチ条件:×がOFF
 * ・スイッチ×の値がON(OFF)の時、条件を満たします。
 *
 * 例:
 * スイッチ条件:5がON
 * スイッチ条件:5がOFF
 * ------------------------------------------------------
 * 装備条件:×:○◇,○◇,○◇・・・
 * ・対象がW(A)◇番の装備を×個装備している時、条件を満たします。
 *
 * 例:
 * 装備条件:2:W1,A2,W3,A1
 * ------------------------------------------------------
 * 装備タイプ条件:×:○◇,○◇,○◇・・・
 * ・対象がW(A)◇番の装備タイプの装備をぞれぞれ×個装備している時、条件を満たします。
 *
 * 例:
 * 装備タイプ条件:2:W1,A2,W3,A1
 * ------------------------------------------------------
 * クラス条件:○,○,○,○・・・
 * ・対象のクラスが○,○,○,○・・・のいずれかの時、条件を満たします。対象がエネミーの場合条件を満たしません。
 *
 * 例:
 * クラス条件:1,2,3,4,5
 * ------------------------------------------------------
 * 特徴メモ条件:○○
 * ・対象の持っている特徴に○○をメモに含むものがある時、条件を満たします。
 *
 * 例:
 * 特徴メモ条件:<テスト>
 * ------------------------------------------------------
 * メンバー条件:×:○,○,○・・・
 * ・待機メンバーを含むパーティメンバーの中にIDが○のメンバーがx人以上いる場合、条件を満たします。
 * 敵を対象とした場合、隠れているエネミーを含む敵メンバーで判定されます。
 *
 * 例:
 * メンバー条件:2:1,2,3,4
 * ------------------------------------------------------
 * 戦闘メンバー条件:x:○,○,○・・・
 * ・戦闘メンバーの中にIDが○のメンバーがx人以上いる場合、条件を満たします。
 * 敵を対象とした場合、隠れているエネミーを含まない敵メンバーで判定されます。
 *
 * 例:
 * 戦闘メンバー条件:2:1,2,3,4
 * ------------------------------------------------------
 * スクリプト条件:○
 * ・○をevalで判定します。
 * スクリプト条件は、複数行にわたって記述することができます。
 *
 * 例:
 * スクリプト条件:$gameVairbales.value[10] === 10
 * ------------------------------------------------------
 * 以下は基本的に条件ドロップ専用です
 * ------------------------------------------------------
 * 属性条件:○,○,○,○・・・
 * ・トドメに使用した属性が○,○,○,○のうちいずれかの時、条件を満たします。
 *
 * 例:
 * 属性条件:1,2,3,4,5
 * ------------------------------------------------------
 * ダメージ条件:○以上
 * ダメージ条件:○以下
 * ・トドメを刺した時に与えたダメージが、○以上(以下)の時、条件を満たします。
 * ダメージ条件:○-○以内
 * ダメージ条件:○-○以外
 * ・トドメを刺した時に与えたダメージが、○-○以内(以外)の時、条件を満たします。
 *
 * 例:
 * ダメージ条件:120以上
 * ダメージ条件:120-240以内
 * ------------------------------------------------------
 * レベル条件:最大○以上
 * レベル条件:最低○以上
 * レベル条件:平均○以下
 * レベル条件:討伐者○以上
 * ・(パーティの)レベルが最大(最低、平均または討伐者)○以上(以下)の時、条件を満たします。
 * レベル条件:最大○-○以内
 * レベル条件:最低○-○以外
 * レベル条件:平均○-○以内
 * レベル条件:討伐者○-○以外
 * ・(パーティの)レベルが最大(最低、平均または討伐者)○-○以内(以外)の時、条件を満たします。
 *
 * 例:
 * レベル条件:最大5以上
 * レベル条件:最低3以下
 * レベル条件:平均4-8以内
 * レベル条件:討伐者5-10以外
 * ------------------------------------------------------
 * 通常攻撃
 * スキル攻撃
 * アイテム攻撃
 * 通常攻撃以外
 * スキル攻撃以外
 * アイテム攻撃以外
 * ・トドメを刺した攻撃が上記いずれかの時、条件を満たします。
 *
 * 例:
 * 通常攻撃
 * 通常攻撃以外
 * スキル攻撃
 * スキル攻撃以外
 * アイテム攻撃
 * アイテム攻撃以外
 * ------------------------------------------------------
 * スキル条件:○,○,○,○・・・
 * アイテム条件:○,○,○,○・・・
 * ・トドメを刺した攻撃が○,○,○,○番のいずれかのスキル(アイテム)の時、条件を満たします。
 *
 * 例:
 * スキル条件:1,2,3,4,5
 * アイテム条件:1,2,3,4,5
 *
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 当プラグインはMITライセンスで公開されています。
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.07:
 * dieStatus周りの処理を修正。
 * ver1.06:
 * 利用規約をMITライセンスに変更。
 * スクリプト条件で、v=変数,s=スイッチが使えるように変更。
 * 装備条件、装備タイプ条件が正常に機能していなかったバグを修正。
 * ver1.05:
 * スクリプト条件が正常に機能していないバグを修正。
 * ver1.04:
 * 生存人数条件を使用した際、エラーが発生するバグを修正。
 * ver1.03:
 * メンバー条件を追加。
 * 戦闘メンバー条件を追加。
 * スクリプト条件を追加。
 * ver1.02:
 * スイッチ条件が正常に機能していないバグを修正。
 * ver1.01:
 * ステータス条件に最大HPと最大MPの条件を追加。
 * ver1.00:
 * 公開
 */

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

(function(){

    'use strict';

    ConditionallyManager.initConditions = function(){
        this._targetCheck = ['^(?:t|対象)','^(?:p|味方)','^(?:tr|敵)','^(?:f|討伐者)','^'];

        this._preCheck = [
            ['(?:turn|ターン条件)','value1','value2','value3'],
            ['(?:state|ステート条件)','value3'],
            ['(?:id|ID条件)','value3'],
            ['(?:status|ステータス条件)','value4','value5','value6'],
            ['(?:eEfficacy|属性有効度条件)','value7'],
            ['(?:sEfficacy|ステート有効度条件)','value7'],
            ['(?:size|人数条件)','value1','value2','value3'],
            ['(?:aSize|生存人数条件)','value1','value2','value3'],
            ['(?:variable|変数条件)','value8'],
            ['(?:switch|スイッチ条件)','value9'],
            ['(?:equip|装備条件)','value10'],
            ['(?:eType|装備タイプ条件)','value10'],
            ['(?:class|クラス条件)','value3'],
            ['(?:memo|特徴メモ条件)','value11'],
            ['(?:element|属性条件)','value3'],
            ['(?:damage|ダメージ条件)','value1','value2'],
            ['(?:level|レベル条件)','value12'],
            ['(?:normalA|通常攻撃)','value13'],
            ['(?:skillA|スキル攻撃)','value13'],
            ['(?:itemA|アイテム攻撃)','value13'],
            ['(?:skill|スキル条件)','value3'],
            ['(?:item|アイテム条件)','value3'],
            ['(?:member|メンバー条件)','value3'],
            ['(?:battleMember|戦闘メンバー条件)','value3'],
            ['(?:script|スクリプト条件)','value13']
        ];

        this._valueCheck = {
            'value1':/(\d+)以([上下])/,
            'value2':/(\d+)\-(\d+)以([内外])/,
            'value3':/(?:(\d+):)*(\d+(?:,\d+)*)/,
            'value4':/(.+?)(\d+)+([%％])?以([上下])/,
            'value5':/(.+?)(\d+)+([%％])?\-+(\d+)+([%％])?以([内外])/,
            'value6':/(.+?)(\d+)+の倍数/,
            'value7':/(?:(\d+),)*(\d+:\d+[%％]以[上下]?)(?:[,，]\d+:\d+[%％]以[上下]?)*/,
            'value8':/(\d+)が(\d+)以([上下])?/,
            'value9':/(\d+)が(O[NF])/,
            'value10':/(?:(\d+):)*([WAwa])(\d+)(?:[,，]([WAwa])(\d+))*/,
            'value11':/(.+)/,
            'value12':/(.+)(\d+)以([上下])/,
            'value13':/(.+)*/
        }
    };

    ConditionallyManager.makeCondition = function(text){
        if(!this._targetCheck){ this.initConditions() }

        for(var i=0;i<this._targetCheck.length;i++){
            for(var j=0;j<this._preCheck.length;j++){
                var reg1 = this._targetCheck[i] + this._preCheck[j][0] + '[:：]*';
                if (text.match(new RegExp(reg1+'(.+)*'))){
                    var reg = RegExp.$1;
                    var ary = this._preCheck[j].slice(1);
                    for(var t=0;t<ary.length;t++){
                        var result = null;
                        if(reg.match(this._valueCheck[ary[t]])){
                            switch (ary[t]){
                            case 'value1':
                                return [i,j,[parseInt(RegExp.$1),RegExp.$2]];
                            case 'value2':
                                return [i,j,[parseInt(RegExp.$1),parseInt(RegExp.$2),RegExp.$3]];
                            case 'value3':
                                result = RegExp.$2.split(',');
                                result.unshift(RegExp.$1);
                                for(var u=0;u<result.length;u++){
                                    result[u] = parseInt(result[u]);
                                }
                                return [i,j,result];
                            case 'value4':
                                result = [RegExp.$1,parseInt(RegExp.$2),RegExp.$3,RegExp.$4];
                                return [i,j,result];
                            case 'value5':
                                result = [RegExp.$1,parseInt(RegExp.$2),RegExp.$3,
                                          parseInt(RegExp.$4),RegExp.$5,RegExp.$6];
                                return [i,j,result];
                            case 'value6':
                                return [i,j,[RegExp.$1,parseInt(RegExp.$2)]];
                            case 'value7':
                                var num = null;
                                result = reg.split(',');
                                if (result[0].match(/(\d+):(\d+):(\d+)[%％]以([上下])/)){
                                    num = (parseInt(RegExp.$1));
                                }
                                for (var u=0;u<result.length;u++){
                                    result[u].match(/(\d+):(\d+)[%％]以([上下])/);
                                    result[u] = [parseInt(RegExp.$1),parseInt(RegExp.$2),RegExp.$3];
                                }
                                result.unshift(num);
                                return [i,j,result];
                            case 'value8':
                                return [i,j,[parseInt(RegExp.$1),parseInt(RegExp.$2)]];
                            case 'value9':
                                return [i,j,[parseInt(RegExp.$1),RegExp.$2]];
                            case 'value10':
                                var num = null;
                                result = reg.split(',');
                                if (result[0].match(/(\d+):([WAwa])(\d+)/)){
                                    num = parseInt(RegExp.$1);
                                }
                                for(var u=0;u<result.length;u++){
                                    result[u].match(/([WAwa])(\d+)/);
                                    result[u] = [RegExp.$1,parseInt(RegExp.$2)];
                                }
                                result.unshift(num);
                                return [i,j,result];
                            case 'value11':
                                result = reg.replace(/\r/,'');
                                result = result.replace(/\n/,'');
                                return [i,j,result];
                            case 'value12':
                                return [i,j,[RegExp.$1,parseInt(RegExp.$2),RegExp.$3]];
                            case 'value13':
                                return [i,j,[RegExp.$1]];
                            default:
                                break;
                            }
                        }
                    }
                }
            }
        }
        return [-1,-1,text];
    };

    ConditionallyManager.setTargets = function(user,target,type){
        switch(type){
        case 0:
        case 3:
            return [target];
        case 1:
            return user.isActor() ? $gameParty.members() : $gameTroop.members();
        case 2:
            return user.isActor() ? $gameTroop.members() : $gameParty.members();
        case 4:
            return [user];
        default:
        }
    };

    ConditionallyManager.checkConditions = function(user, target, conditions, dieStatus){
        this._dieStatus = dieStatus;
        var fcns = [
                    this.checkTurn,
                    this.checkState,
                    this.checkId,
                    this.checkStatus,
                    this.checkEleEff,
                    this.checkStaEff,
                    this.checkSize,
                    this.checkASize,
                    this.checkVariable,
                    this.checkSwitch,
                    this.checkEquip,
                    this.checkEType,
                    this.checkClass,
                    this.checkMemo,
                    this.checkElement,
                    this.checkDamage,
                    this.checkLevel,
                    this.checkNormalA,
                    this.checkSkillA,
                    this.checkItemA,
                    this.checkSkill,
                    this.checkItem,
                    this.checkMember,
                    this.checkBattleMember,
                    this.checkScript
                   ];
        for(var i=0;i<conditions.length;i++){
            if (conditions[i][1] === -1 && conditions[i-1][1] === 24) {
                for(var j=i;j<conditions.length;j++){
                    if (conditions[j][1] === -1 && conditions[i][2]){
                        conditions[i-1][2] += '\n' + conditions[j][2];
                        conditions[j][1] = -2;
                    } else {
                        i = j - 1;
                        break;
                    }
                }
            }
        }
        for(var i=0;i<conditions.length;i++){
            if (!conditions[i]){ continue }
            if (conditions[i][1] < 0){ continue }
            var targets = this.setTargets(user,target,conditions[i][0]);
            if (!fcns[conditions[i][1]].call(this,targets,conditions[i][2])){
                return false;
            }
        }
        return true;
    };

    ConditionallyManager.checkValues = function(code,num,value1,value2){
        switch (code){
        case '上':
            return num >= value1;
        case '下':
            return num <= value1;
        case '内':
            return num >= value1 && num <= value2;
        case '外':
            return num <= value1 && num >= value2;
        default:
            return (value1 % num) === 0;
        }
    };

    ConditionallyManager.checkTurn = function(targets,conditions){
        var turn = this._dieStatus ? this._dieStatus['turn'] : BattleManager.ccTurnCount();
        var code = conditions[conditions.length-1];
        switch (code){
        case '上':
        case '下':
        case '内':
        case '外':
            return this.checkValues(code,turn,conditions[0],conditions[1]);
        default:
            return conditions.indexOf(turn) !== -1;
        }
    };
    ConditionallyManager.checkState = function(targets,conditions){
        conditions = conditions.clone();
        var num = conditions.shift();
        num = isNaN(num) ? 1 : num;
        for(var i=0;i<targets.length;i++){
            var count = 0;
            for(var j=0;j<conditions.length;j++){
                if (targets[i].isStateAffected(conditions[j])){
                    count++;
                    if (count === num){ return true }
                }
            }
        }
        return false;
    };
    ConditionallyManager.checkId = function(targets,conditions){
        conditions = conditions.clone();
        conditions.shift();
        for(var i=0;i<targets.length;i++){
            var id = targets[i].isActor() ? targets[i]._actorId : targets[i]._enemyId;
            if (conditions.indexOf(id) >= 0){ return true }
        }
        return false;
    };
    ConditionallyManager.checkStatus = function(targets,conditions){
        var code = conditions[conditions.length-1];
        var value1 = conditions[1];
        var value2 = (conditions.length - 1) > 3 ? conditions[3] : null ;
        for(var i=0;i<targets.length;i++){
            var num = this.getStatusValue(targets[i],conditions);
            if (this.checkValues(code, num, value1, value2)){ return true }
        }
        return false;
    };
    ConditionallyManager.checkEleEff = function(targets,conditions){
        conditions = conditions.clone();
        var num = conditions.shift();
        num = num ? num : 1;
        for(var i=0;i<targets.length;i++){
            var count = 0;
            for(var j=0;j<conditions.length;j++){
                var code = conditions[j][2];
                var value = targets[i].elementRate(conditions[j][0]) * 100;
                var value1 = conditions[j][1];
                if (this.checkValues(code,value,value1)){
                    count++;
                    if (count === num){ return true }
                }
            }
        }
        return false;
    };
    ConditionallyManager.checkStaEff = function(targets,conditions){
        conditions = conditions.clone();
        var num = conditions.shift();
        num = num ? num : 1;
        for(var i=0;i<targets.length;i++){
            var count = 0;
            for(var j=0;j<conditions.length;j++){
                var code = conditions[j][2];
                var value = targets[i].stateRate(conditions[j][0]) * 100;
                var value1 = conditions[j][1];
                if (this.checkValues(code,value,value1)){
                    count++;
                    if (count === num){ return true }
                }
            }
        }
        return false;

    };
    ConditionallyManager.checkSize = function(targets,conditions){
        var code = conditions[conditions.length-1];
        var num = null;
        var value1 = conditions[0];
        var value2 = conditions[1];
        if (targets[0].isActor()){
            num = $gameParty.members().length;
        }else{
            num = $gameTroop.members().length;
        }
        switch (code){
        case '上':
        case '下':
        case '内':
        case '外':
            return this.checkValues(code,num,value1,value2);
        default:
            return conditions.indexOf(num) !== -1;
        }
    };
    ConditionallyManager.checkASize = function(targets,conditions){
        var code = conditions[conditions.length-1];
        var num = null;
        var value1 = conditions[0];
        var value2 = conditions[1];
        if (targets[0].isActor()){
            num = $gameParty.aliveMembers().length;
        }else{
            num = $gameTroop.aliveMembers().length;
        }
        switch (code){
        case '上':
        case '下':
        case '内':
        case '外':
            return this.checkValues(code,num,value1,value2);
        default:
            return conditions.indexOf(num) !== -1;
        }

    };
    ConditionallyManager.checkVariable = function(targets,conditions){
        var value = $gameVariables.value(conditions[0]);
        var code = conditions[2];
        return this.checkValues(code,value,conditions[1]);
    };
    ConditionallyManager.checkSwitch = function(targets,conditions){
        var flag = $gameSwitches.value(conditions[0]);
        return flag === (conditions[1] === 'ON');
    };
    ConditionallyManager.checkEquip = function(targets,conditions){
        if(!targets[0]){ return false }
        if(targets[0].isEnemy()){ return false }
        conditions = conditions.clone();
        var num = conditions.shift();
        num = num ? num : 1;
        for (var i=0;i<targets.length;i++){
            var count = 0;
            for (var j=0;j<conditions.length;j++){
                var eVar = conditions[j][0];
                var eId = conditions[j][1];
                switch(eVar){
                    case 'W':
                    case 'w':
                        if (targets[i].isEquipped($dataWeapons[eId])){ count++ }
                        break;
                    case 'A':
                    case 'a':
                        if (targets[i].isEquipped($dataArmors[eId])){ count++ }
                        break;
                }
                if (count >= num){ return true }
            }
        }
        return false;
    };
    ConditionallyManager.checkEType = function(targets,conditions){
        if(!targets[0]){ return false }
        if(targets[0].isEnemy()){ return false }
        var result = [];
        conditions = conditions.clone();
        var num = conditions.shift();
        num = num ? num : 1;
        for (var i=0;i<targets.length;i++){
            var count = 0;
            for (var j=0;j<conditions.length;j++){
                var eVar = conditions[j][0];
                var eId = conditions[j][1];
                switch(eVar){
                    case 'W':
                    case 'w':
                        result = targets[i].weapons().filter(function(equip){
                            return equip.wtypeId === eId;
                        });
                        break;
                    case 'A':
                    case 'a':
                        result = targets[i].armors().filter(function(equip){
                            return equip.atypeId === eId;
                        });
                }
                if (result.length > 0){ count++ }
                if (count >= num){ return true }
            }
        }
        return false;

    };
    ConditionallyManager.checkClass = function(targets,conditions){
        conditions = conditions.clone();
        var num = conditions.shift();
        num = num ? num : 1;
        var count = 0;
        for(var i=0;i<targets.length;i++){
            if (conditions.indexOf(targets[i]._classId) !== -1){ count++ }
            if (count >= num){ return true }
        }
        return false;
    };
    ConditionallyManager.checkMemo = function(targets,conditions){
        var result = [];
        for(var i=0;i<targets.length;i++){
            result = targets[i].traitObjects().filter(function(object){
                return object.note.match('^' + conditions);
            });
            if (result.length > 0){ return true }
        }
        return false;
    };
    ConditionallyManager.checkElement = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var finisher = this.decodeFinisher(this._dieStatus['finisher']);
        var item = this._dieStatus['item'];
        var elements = item.damage.elementId < 0 ? finisher.attackElements() : [item.damage.elementId];
        conditions = conditions.clone();
        var num = conditions.shift();
        var count = 0;
        num = isNaN(num) ? 1 : num;
        for(var i=0;i<conditions.length;i++){
            if (elements.indexOf(conditions[i]) >= 0){
                count++;
                if (num === count){ return true }
            }
        }
        return false;
    };
    ConditionallyManager.decodeFinisher = function(finisher) {
        if (finisher[0]) return $gameParty.members()[finisher[1]];
        return $gameTroop.members()[finisher[1]];
    };
    ConditionallyManager.checkDamage = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var code = conditions[1];
        var num = this._dieStatus['damage'];
        var value1 = conditions[0];
        return this.checkValues(code,num,value1);
    };
    ConditionallyManager.checkLevel = function(targets,conditions){
        var num = 0;
        var code = conditions[2];
        var value = conditions[1];
        switch(conditions[0]){
        case '平均':
            $gameParty.members().forEach(function(member){ num += member._level });
            num /= $gameParty.members().length;
            break;
        case '最大':
            $gameParty.members().forEach(function(member){ if (num < member._level){ num = member._level} });
            break;
        case '最低':
            num = 999999;
            $gameParty.members().forEach(function(member){ if (num > member._level){ num = member._level} });
            break;
        case '討伐者':
            if (!this._dieStatus){ return false }
            num = this._dieStatus['finisher']._level;
            break;
        default:
        }
        return this.checkValues(code,num,value);
    };
    ConditionallyManager.checkNormalA = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var item = this._dieStatus['item'];
        var finisher = this.decodeFinisher(this._dieStatus['finisher']);
        var attackSkill = $dataSkills[finisher.attackSkillId()];
        var result = item === attackSkill;
        return conditions[0] === '以外' ? !result : result;
    };
    ConditionallyManager.checkSKillA = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var item = this._dieStatus['item'];
        var result = DataManager.isSkill(item);
        return conditions[0] === '以外' ? !result : result;
    };
    ConditionallyManager.checkItemA = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var item = this._dieStatus['item'];
        var result = DataManager.isItem(item);
        return conditions[0] === '以外' ? !result : result;
    };
    ConditionallyManager.checkSkill = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var skill = this._dieStatus['item'];
        conditions = conditions.clone();
        conditions.shift();
        if (DataManager.isItem(skill)){ return false }
        return conditions.indexOf(skill.id) >= 0;
    };
    ConditionallyManager.checkItem = function(targets,conditions){
        if (!this._dieStatus){ return false }
        var item = this._dieStatus['item'];
        conditions = conditions.clone();
        conditions.shift();
        if (DataManager.isSkill(item)){ return false }
        return conditions.indexOf(item.id) >= 0;

    };
    ConditionallyManager.checkMember = function(targets,conditions){
        conditions = conditions.clone();
        var members = $gameParty.allMembers();
        if (targets[0].isEnemy()){ members = $gameTroop.members() }
        var num = conditions.shift();
        num = num ? num : 1;
        var count = 0;
        for(var i=0;i<members.length;i++){
            var id = members[i].isActor() ? members[i]._actorId : members[i]._enemyId;
            if (conditions.indexOf(id) !== -1){ count++ }
            if (count >= num){ return true }
        }
        return false;
    };
    ConditionallyManager.checkBattleMember = function(targets,conditions){
        conditions = conditions.clone();
        var members = $gameParty.battleMembers();
        if (targets[0].isEnemy()){ members = $gameTroop.members().filter(function(enemy){ return enemy.isAppeared()}) }
        var num = conditions.shift();
        num = num ? num : 1;
        var count = 0;
        for(var i=0;i<members.length;i++){
            var id = members[i].isActor() ? members[i]._actorId : members[i]._enemyId;
            if (conditions.indexOf(id) !== -1){ count++ }
            if (count >= num){ return true }
        }
        return false;
    };
    ConditionallyManager.checkScript = function(targets,conditions){
        conditions = [conditions].clone();
        var a = targets;
        var v = $gameVariables._data;
        var s = $gameSwitches._data;
        return !!eval(conditions[0][0]);
    };
    ConditionallyManager.getStatusValue = function(subject, conditions){
        switch(conditions[0]){
        case 'Level':
        case 'Lv':
        case TextManager.basic(0):
        case TextManager.basic(1):
            return subject.isActor() ? subject._level : 0;
        case 'HP':
        case 'ＨＰ':
        case TextManager.basic(2):
        case TextManager.basic(3):
            if (conditions[2] === ''){
                return subject.hp;
            }else{
                return Math.floor((subject.hp / subject.mhp) * 100);
            }
        case 'MP':
        case 'ＭＰ':
        case TextManager.basic(4):
        case TextManager.basic(5):
            if (conditions[2] === ''){
                return subject.mp;
            }else{
                return Math.floor((subject.mp / subject.mmp) * 100);
            }
        case 'TP':
        case 'ＴＰ':
        case TextManager.basic(6):
        case TextManager.basic(7):
            return subject.tp;
        case 'EXP':
        case 'ＥＸＰ':
        case '経験値':
        case TextManager.basic(8):
        case TextManager.basic(9):
            return subject.isActor() ? subject.currentExp() : 0;
        case '最大HP':
        case '最大ＨＰ':
        case TextManager.param[0]:
            return subject.mhp;
        case '最大MP':
        case '最大ＭＰ':
        case TextManager.param[1]:
            return subject.mmp;
        case 'ATK':
        case 'ＡＴＫ':
        case '攻撃力':
        case TextManager.param[2]:
            return subject.atk;
        case 'DEF':
        case 'ＤＥＦ':
        case '防御力':
        case TextManager.param[3]:
            return subject.def;
        case 'MAT':
        case 'ＭＡＴ':
        case '魔法力':
        case TextManager.param[4]:
            return subject.mat;
        case 'MDF':
        case 'ＭＤＦ':
        case '魔法防御':
        case TextManager.param[5]:
            return subject.mdf;
        case 'AGI':
        case 'ＡＧＩ':
        case '敏捷性':
        case TextManager.param[6]:
            return subject.agi;
        case 'LUK':
        case 'ＬＵＫ':
        case '運':
        case TextManager.param[7]:
            return subject.luk;
        case 'HIT':
        case 'ＨＩＴ':
        case '命中率':
        case TextManager.param[8]:
            return Math.floor(subject.hit * 100);
        case 'EVA':
        case 'ＥＶＡ':
        case '回避率':
        case TextManager.param[9]:
            return Math.floor(subject.eva * 100);
        case 'CRI':
        case 'ＣＲＩ':
        case '会心率':
            return Math.floor(subject.cri * 100);
        case 'CEV':
        case 'ＣＥＶ':
        case '会心回避率':
            return Math.floor(subject.cev * 100);
        case 'MEV':
        case 'ＭＥＶ':
        case '魔法回避率':
            return Math.floor(subject.mev * 100);
        case 'MRF':
        case 'ＭＲＦ':
        case '魔法反射率':
            return Math.floor(subject.mrf * 100);
        case 'CNT':
        case 'ＣＮＴ':
        case '反撃率':
            return Math.floor(subject.cnt * 100);
        case 'HRG':
        case 'ＨＲＧ':
        case 'HP再生率':
        case 'ＨＰ再生率':
            return Math.floor(subject.hrg * 100);
        case 'MRG':
        case 'ＭＲＧ':
        case 'MP再生率':
        case 'ＭＰ再生率':
            return Math.floor(subject.mrg * 100);
        case 'TRG':
        case 'ＴＲＧ':
        case 'TP再生率':
        case 'ＴＰ再生率':
            return Math.floor(subject.trg * 100);
        case 'TGR':
        case 'ＴＧＲ':
        case '狙われ率':
            return Math.floor(subject.tgr * 100);
        case 'GRD':
        case 'ＧＲＤ':
        case '防御効果率':
            return Math.floor(subject.grd * 100);
        case 'REC':
        case 'ＲＥＣ':
        case '回復効果率':
            return Math.floor(subject.rec * 100);
        case 'PHA':
        case 'ＰＨＡ':
        case '薬の知識':
            return Math.floor(subject.pha * 100);
        case 'MCR':
        case 'ＭＣＲ':
        case 'MP消費率':
        case 'ＭＰ消費率':
            return Math.floor(subject.mcr * 100);
        case 'TCR':
        case 'ＴＣＲ':
        case 'TPチャージ率':
        case 'ＴＰチャージ率':
            return Math.floor(subject.tcr * 100);
        case 'PDR':
        case 'ＰＤＲ':
        case '物理ダメージ率':
            return Math.floor(subject.pdr * 100);
        case 'MDR':
        case 'ＭＤＲ':
        case '魔法ダメージ率':
            return Math.floor(subject.mdr * 100);
        case 'FDR':
        case 'ＦＤＲ':
        case '床ダメージ率':
            return Math.floor(subject.fdr * 100);
        case 'EXR':
        case 'ＥＸＲ':
        case '経験値獲得率':
            return Math.floor(subject.exr * 100);
        default:
            return 0;
        }
    };

    BattleManager.ccTurnCount = function(turn){
        return this.isInputting() ? ($gameTroop._turnCount + 1) : $gameTroop._turnCount;
    };

    var _CnC_GAction_repeatTargets = Game_Action.prototype.repeatTargets;
    Game_Action.prototype.repeatTargets = function(targets){
        BattleManager._lastTargets = targets;
        return _CnC_GAction_repeatTargets.call(this,targets);
    };

    var _CnC_GAction_executeDamage = Game_Action.prototype.executeDamage;
    Game_Action.prototype.executeDamage = function(target, value){
        this.subject()._lastDamage += value;
        _CnC_GAction_executeDamage.call(this,target,value);
    };

    var _CnC_BManager_startAction = BattleManager.startAction;
    BattleManager.startAction = function(){
        _CnC_BManager_startAction.call(this);
        this._subject._lastDamage = 0;
        this._lastAction = this._subject.currentAction();
    };

}());


code:
//=============================================================================
// CustomizeConfigDefault.js
// ----------------------------------------------------------------------------
// (C)2015 Triacontane
// This plugin is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.1.1 2020/09/13 Mano_InputConfig.jsと併用したとき、Option項目を消していると表示不整合が発生する競合を修正
// 1.1.0 2016/08/01 項目自体を非表示にする機能を追加しました。
// 1.0.3 2016/06/22 多言語対応
// 1.0.2 2016/01/17 競合対策
// 1.0.1 2015/11/01 既存コードの再定義方法を修正（内容に変化なし）
// 1.0.0 2015/11/01 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc Setting default value for Options
 * @author triacontane
 *
 * @param AlwaysDash
 * @desc Always dash(ON/OFF)
 * @default OFF
 *
 * @param CommandRemember
 * @desc Command remember(ON/OFF)
 * @default OFF
 *
 * @param BgmVolume
 * @desc BGM Volume(0-100)
 * @default 100
 *
 * @param BgsVolume
 * @desc BGS Volume(0-100)
 * @default 100
 *
 * @param MeVolume
 * @desc ME Volume(0-100)
 * @default 100
 *
 * @param SeVolume
 * @desc SE Volume(0-100)
 * @default 100
 *
 * @param EraseAlwaysDash
 * @desc Erase AlwaysDash Option(ON/OFF)
 * @default OFF
 *
 * @param EraseCommandRemember
 * @desc Erase CommandRemember Option(ON/OFF)
 * @default OFF
 *
 * @param EraseBgmVolume
 * @desc Erase BgmVolume Option(ON/OFF)
 * @default OFF
 *
 * @param EraseBgsVolume
 * @desc Erase BgsVolume Option(ON/OFF)
 * @default OFF
 *
 * @param EraseMeVolume
 * @desc Erase MeVolume Option(ON/OFF)
 * @default OFF
 *
 * @param EraseSeVolume
 * @desc Erase SeVolume Option(ON/OFF)
 * @default OFF
 *
 * @help Setting default value for Options.
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc オプションデフォルト値設定プラグイン
 * @author トリアコンタン
 *
 * @param 常時ダッシュ
 * @desc 常にダッシュする。（Shiftキーを押している場合のみ歩行）(ON/OFF)
 * @default OFF
 *
 * @param コマンド記憶
 * @desc 選択したコマンドを記憶する。(ON/OFF)
 * @default OFF
 *
 * @param BGM音量
 * @desc BGMの音量。0-100
 * @default 100
 *
 * @param BGS音量
 * @desc BGSの音量。0-100
 * @default 100
 *
 * @param ME音量
 * @desc MEの音量。0-100
 * @default 100
 *
 * @param SE音量
 * @desc SEの音量。0-100
 * @default 100
 *
 * @param 常時ダッシュ消去
 * @desc 常時ダッシュの項目を非表示にする。(ON/OFF)
 * @default OFF
 *
 * @param コマンド記憶消去
 * @desc コマンド記憶の項目を非表示にする。(ON/OFF)
 * @default OFF
 *
 * @param BGM音量消去
 * @desc BGM音量の項目を非表示にする。(ON/OFF)
 * @default OFF
 *
 * @param BGS音量消去
 * @desc BGS音量の項目を非表示にする。(ON/OFF)
 * @default OFF
 *
 * @param ME音量消去
 * @desc ME音量の項目を非表示にする。(ON/OFF)
 * @default OFF
 *
 * @param SE音量消去
 * @desc SE音量の項目を非表示にする。(ON/OFF)
 * @default OFF
 *
 * @help オプション画面で設定可能な項目のデフォルト値を指定した値に変更します。
 * 例えば、初回から常時ダッシュをONにしておけば
 * プレイヤーが設定を変更する手間を省くことができます。
 * この処理はconfig.rpgsaveが未作成の場合にのみ実行されます。
 *
 * また、項目そのものを消去することもできます。
 * 例えば、戦闘がないゲームでは「コマンド記憶」等は不要なので消去できます。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
(function() {
    'use strict';
    var pluginName = 'CustomizeConfigDefault';

    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 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 paramAlwaysDash           = getParamBoolean(['AlwaysDash', '常時ダッシュ']);
    var paramCommandRemember      = getParamBoolean(['CommandRemember', 'コマンド記憶']);
    var paramBgmVolume            = getParamNumber(['BgmVolume', 'BGM音量'], 0, 100);
    var paramBgsVolume            = getParamNumber(['BgsVolume', 'BGS音量'], 0, 100);
    var paramMeVolume             = getParamNumber(['MeVolume', 'ME音量'], 0, 100);
    var paramSeVolume             = getParamNumber(['SeVolume', 'SE音量'], 0, 100);
    var paramEraseAlwaysDash      = getParamBoolean(['EraseAlwaysDash', '常時ダッシュ消去']);
    var paramEraseCommandRemember = getParamBoolean(['EraseCommandRemember', 'コマンド記憶消去']);
    var paramEraseBgmVolume       = getParamBoolean(['EraseBgmVolume', 'BGM音量消去']);
    var paramEraseBgsVolume       = getParamBoolean(['EraseBgsVolume', 'BGS音量消去']);
    var paramEraseMeVolume        = getParamBoolean(['EraseMeVolume', 'ME音量消去']);
    var paramEraseSeVolume        = getParamBoolean(['EraseSeVolume', 'SE音量消去']);

    //=============================================================================
    // ConfigManager
    //  それぞれの項目に初期値を与えます。
    //=============================================================================
    var _ConfigManagerApplyData = ConfigManager.applyData;
    ConfigManager.applyData     = function(config) {
        _ConfigManagerApplyData.apply(this, arguments);
        if (config.alwaysDash == null)      this.alwaysDash = paramAlwaysDash;
        if (config.commandRemember == null) this.commandRemember = paramCommandRemember;
        if (config.bgmVolume == null)       this.bgmVolume = paramBgmVolume;
        if (config.bgsVolume == null)       this.bgsVolume = paramBgsVolume;
        if (config.meVolume == null)        this.meVolume = paramMeVolume;
        if (config.seVolume == null)        this.seVolume = paramSeVolume;
    };

    //=============================================================================
    // Window_Options
    //  パラメータを空白にした項目を除去します。
    //=============================================================================
    var _Window_Options_makeCommandList = Window_Options.prototype.makeCommandList;
    Window_Options.prototype.makeCommandList = function() {
        _Window_Options_makeCommandList.apply(this, arguments);
        if (paramEraseAlwaysDash) this.eraseOption('alwaysDash');
        if (paramEraseCommandRemember) this.eraseOption('commandRemember');
        if (paramEraseBgmVolume) this.eraseOption('bgmVolume');
        if (paramEraseBgsVolume) this.eraseOption('bgsVolume');
        if (paramEraseMeVolume) this.eraseOption('meVolume');
        if (paramEraseSeVolume) this.eraseOption('seVolume');
    };

    Window_Options.prototype.eraseOption = function(symbol) {
        for (var i = 0; i < this._list.length; i++) {
            if (this._list[i].symbol === symbol) {
                this._list.splice(i, 1);
                // for Mano_InputConfig.js
                this.adjustIndexManoInputConfig(i);
                break;
            }
        }
    };

    Window_Options.prototype.adjustIndexManoInputConfig = function(index) {
        if (this._gamepadOptionIndex > index) {
            this._gamepadOptionIndex -= 1;
        }
        if (this._keyboardConfigIndex > index) {
            this._keyboardConfigIndex -= 1;
        }
    };
})();


code:
//=============================================================================
// CustomizeConfigItem.js
// ----------------------------------------------------------------------------
// (C) 2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 2.3.0 2021/12/21 項目に余白を設定できる機能を追加
// 2.2.1 2021/08/05 セーブがある状態で隠し項目を追加した時に上手く動作しない問題を修正(by柊菜緒さま)
// 2.2.0 2021/03/09 スクリプトが指定されているときに項目決定すると決定SEを演奏するよう修正
// 2.1.2 2020/10/13 Mano_InputConfig.jsと併用したとき、項目を末尾以外に追加すると表示不整合が発生する競合を修正
// 2.1.0 2017/12/15 追加項目のデフォルト項目を含めた並び順を自由に設定できる機能を追加
//                  項目名称を日本語化
// 2.0.1 2017/10/15 2.0.0の修正によりスイッチ項目を有効にしたときにゲーム開始するとエラーになる問題を修正
// 2.0.0 2017/09/10 ツクールの型指定機能に対応し、各オプション項目を任意の数だけ追加できる機能を追加
// 1.2.3 2017/06/08 1.2.2の修正により起動できなくなっていた問題を修正
// 1.2.2 2017/05/27 競合の可能性のある記述（Objectクラスへのプロパティ追加）をリファクタリング
// 1.2.1 2016/12/08 1.2.0の機能追加以降、デフォルト項目で決定ボタンを押すとエラーになっていた現象を修正
// 1.2.0 2016/12/02 各項目で決定ボタンを押したときに実行されるスクリプトを設定できる機能を追加
// 1.1.1 2016/08/14 スイッチ項目、音量項目の初期値が無効になっていた問題を修正
// 1.1.0 2016/04/29 項目をクリックしたときに項目値が循環するよう修正
// 1.0.0 2016/01/17 初版
// ----------------------------------------------------------------------------
// [Blog]   : http://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc オプション任意項目作成プラグイン
 * @author トリアコンタン
 *
 * @param 数値項目
 * @desc 追加する数値項目のオプション項目情報です。
 * @default
 * @type struct<NumberData>[]
 *
 * @param 文字項目
 * @desc 追加する文字項目のオプション項目情報です。
 * @default
 * @type struct<StringData>[]
 *
 * @param スイッチ項目
 * @desc 追加するスイッチ項目のオプション項目情報です。
 * @default
 * @type struct<BooleanData>[]
 *
 * @param 音量項目
 * @desc 追加する音量項目のオプション項目情報です。
 * @default
 * @type struct<VolumeData>[]
 *
 * @help オプション画面に任意の項目を追加します。
 * 項目の種類は、以下の四種類があります。
 * 不要な項目は値を空に設定してください。
 *
 * ・スイッチ項目：
 * ON/OFFを選択する項目です。指定した番号のスイッチと値が同期されます。
 * オプションから値を設定すれば、それがスイッチに反映され、
 * スイッチを変更すれば、オプションの値に反映されます。
 * さらに、値はセーブデータ間で共有されます。
 * 隠しフラグを設定すると、オプション画面に表示されなくなります。
 * ゲームを進めないと出現しない項目などに利用できます。
 * 隠しフラグはプラグインコマンドから解除できます。
 *
 * スクリプトは上級者向け項目です。対象にカーソルを合わせて決定ボタンを
 * 押下すると指定したJavaScriptを実行できます。
 * 主に専用の設定画面などの遷移に使用します。
 *
 * ・数値項目：
 * 数値を選択する項目です。指定した番号の変数と値が同期されます。
 * スイッチ項目で指定した内容に加えて、
 * 最小値と最大値および一回の入力で変化する値を指定します。
 *
 * ・音量項目：
 * 音量を選択する項目です。BGMボリュームなどと同じ仕様で
 * キャラクターごとのボイス音量等に使ってください。
 *
 * ・文字項目：
 * 文字を選択する項目です。指定した文字の配列から項目を選択します。
 * 選択した文字のインデックス(開始位置は0)が変数に設定されます。
 * 初期値に設定する値もインデックスです。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 *  CC_UNLOCK or
 *  オプション任意項目の隠し解除 [項目名]
 *  　指定した項目の隠しフラグを解除します。
 *  使用例：CC_UNLOCK 数値項目1
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~NumberData:
 * @param Name
 * @text 項目名称
 * @desc 項目の名称です。
 * @default 数値項目1
 *
 * @param DefaultValue
 * @text 初期値
 * @desc 項目の初期値です。
 * @default 0
 * @type number
 *
 * @param VariableID
 * @text 変数番号
 * @desc 項目の設定内容が格納される変数番号です。
 * @default 0
 * @type variable
 *
 * @param HiddenFlag
 * @text 隠しフラグ
 * @desc 項目がデフォルトで隠されるようになります。プラグインコマンドの実行で表示されます。
 * @default false
 * @type boolean
 *
 * @param Script
 * @text スクリプト
 * @desc 項目を決定したときに実行されるスクリプトです。
 * @default
 *
 * @param NumberMin
 * @text 最小値
 * @desc 項目の最小値です。
 * @default 0
 * @type number
 *
 * @param NumberMax
 * @text 最大値
 * @desc 項目の最大値です。
 * @default 100
 * @type number
 *
 * @param NumberStep
 * @text 変化値
 * @desc 項目を操作したときの数値の変化量です。
 * @default 20
 * @type number
 *
 * @param AddPosition
 * @text 追加位置
 * @desc 項目を追加する位置です。指定した項目の上に追加されます。
 * @default
 * @type select
 * @option 末尾に追加
 * @value
 * @option 常時ダッシュ
 * @value alwaysDash
 * @option コマンド記憶
 * @value commandRemember
 * @option BGM 音量
 * @value bgmVolume
 * @option BGS 音量
 * @value bgsVolume
 * @option ME 音量
 * @value meVolume
 * @option SE 音量
 * @value seVolume
 *
 * @param PaddingTop
 * @text 余白
 * @desc 項目の上の余白ピクセル数です。項目の間隔を開けたいときに指定します。
 * @default 0
 * @type number
 */
/*~struct~BooleanData:
 * @param Name
 * @text 項目名称
 * @desc 項目の名称です。
 * @default スイッチ項目1
 *
 * @param DefaultValue
 * @text 初期値
 * @desc 項目の初期値です。
 * @default false
 * @type boolean
 *
 * @param SwitchID
 * @text スイッチ番号
 * @desc 項目の設定内容が格納されるスイッチ番号です。
 * @default 0
 * @type switch
 *
 * @param HiddenFlag
 * @text 隠しフラグ
 * @desc 項目がデフォルトで隠されるようになります。プラグインコマンドの実行で表示されます。
 * @default false
 * @type boolean
 *
 * @param Script
 * @text スクリプト
 * @desc 項目を決定したときに実行されるスクリプトです。
 * @default
 *
 * @param AddPosition
 * @text 追加位置
 * @desc 項目を追加する位置です。指定した項目の上に追加されます。
 * @default
 * @type select
 * @option 末尾に追加
 * @value
 * @option 常時ダッシュ
 * @value alwaysDash
 * @option コマンド記憶
 * @value commandRemember
 * @option BGM 音量
 * @value bgmVolume
 * @option BGS 音量
 * @value bgsVolume
 * @option ME 音量
 * @value meVolume
 * @option SE 音量
 * @value seVolume
 *
 * @param PaddingTop
 * @text 余白
 * @desc 項目の上の余白ピクセル数です。項目の間隔を開けたいときに指定します。
 * @default 0
 * @type number
 */
/*~struct~StringData:
 * @param Name
 * @text 項目名称
 * @desc 項目の名称です。
 * @default 文字列項目1
 *
 * @param DefaultValue
 * @text 初期値
 * @desc 項目の初期値です。インデックスの数値を指定します。
 * @default 0
 * @type number
 *
 * @param VariableID
 * @text 変数番号
 * @desc 項目の設定内容が格納される変数番号です。
 * @default 0
 * @type variable
 *
 * @param HiddenFlag
 * @text 隠しフラグ
 * @desc 項目がデフォルトで隠されるようになります。プラグインコマンドの実行で表示されます。
 * @default false
 * @type boolean
 *
 * @param Script
 * @text スクリプト
 * @desc 項目を決定したときに実行されるスクリプトです。
 * @default
 *
 * @param StringItems
 * @text 内容の配列
 * @desc 項目の設定内容の配列です。
 * @default
 * @type string[]
 *
 * @param AddPosition
 * @text 追加位置
 * @desc 項目を追加する位置です。指定した項目の上に追加されます。
 * @default
 * @type select
 * @option 末尾に追加
 * @value
 * @option 常時ダッシュ
 * @value alwaysDash
 * @option コマンド記憶
 * @value commandRemember
 * @option BGM 音量
 * @value bgmVolume
 * @option BGS 音量
 * @value bgsVolume
 * @option ME 音量
 * @value meVolume
 * @option SE 音量
 * @value seVolume
 *
 * @param PaddingTop
 * @text 余白
 * @desc 項目の上の余白ピクセル数です。項目の間隔を開けたいときに指定します。
 * @default 0
 * @type number
 */
/*~struct~VolumeData:
 * @param Name
 * @text 項目名称
 * @desc 項目の名称です。
 * @default 音量項目1
 *
 * @param DefaultValue
 * @text 初期値
 * @desc 項目の初期値です。
 * @default 0
 * @type number
 *
 * @param VariableID
 * @text 変数番号
 * @desc 項目の設定内容が格納される変数番号です。
 * @default 0
 * @type variable
 *
 * @param HiddenFlag
 * @text 隠しフラグ
 * @desc 項目がデフォルトで隠されるようになります。プラグインコマンドの実行で表示されます。
 * @default false
 * @type boolean
 *
 * @param Script
 * @text スクリプト
 * @desc 項目を決定したときに実行されるスクリプトです。
 * @default
 *
 * @param AddPosition
 * @text 追加位置
 * @desc 項目を追加する位置です。指定した項目の上に追加されます。
 * @default
 * @type select
 * @option 末尾に追加
 * @value
 * @option 常時ダッシュ
 * @value alwaysDash
 * @option コマンド記憶
 * @value commandRemember
 * @option BGM 音量
 * @value bgmVolume
 * @option BGS 音量
 * @value bgsVolume
 * @option ME 音量
 * @value meVolume
 * @option SE 音量
 * @value seVolume
 *
 * @param PaddingTop
 * @text 余白
 * @desc 項目の上の余白ピクセル数です。項目の間隔を開けたいときに指定します。
 * @default 0
 * @type number
 */

(function() {
    'use strict';
    var pluginName = 'CustomizeConfigItem';

    var getParamString = function(paramNames) {
        var value = getParamOther(paramNames);
        return value == null ? '' : value;
    };

    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 getParamArrayJson = function(paramNames, defaultValue) {
        var value = getParamString(paramNames) || null;
        try {
            value = JSON.parse(value);
            if (value === null) {
                value = defaultValue;
            } else {
                value = value.map(function(valueData) {
                    return JSON.parse(valueData);
                });
            }
        } catch (e) {
            alert(`!!!Plugin param is wrong.!!!\nPlugin:${pluginName}.js\nName:[${paramNames}]\nValue:${value}`);
            value = defaultValue;
        }
        return value;
    };

    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(arg) || 0).clamp(min, max);
    };

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

    var getArgJson = function(arg, defaultValue) {
        try {
            arg = JSON.parse(arg || null);
            if (arg === null) {
                arg = defaultValue;
            }
        } catch (e) {
            alert(`!!!Plugin param is wrong.!!!\nPlugin:${pluginName}.js\nValue:${arg}`);
            arg = defaultValue;
        }
        return arg;
    };

    var iterate = function(that, handler) {
        Object.keys(that).forEach(function(key, index) {
            handler.call(that, key, that[key], index);
        });
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var param           = {};
    param.numberOptions = getParamArrayJson(['NumberOptions', '数値項目'], []);
    param.stringOptions = getParamArrayJson(['StringOptions', '文字項目'], []);
    param.switchOptions = getParamArrayJson(['SwitchOptions', 'スイッチ項目'], []);
    param.volumeOptions = getParamArrayJson(['VolumeOptions', '音量項目'], []);

    var localOptionWindowIndex = 0;

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

    Game_Interpreter.prototype.pluginCommandCustomizeConfigItem = function(command, args) {
        switch (getCommandName(command)) {
            case 'CC_UNLOCK' :
            case 'オプション任意項目の隠し解除' :
                ConfigManager.customParamUnlock(args[0]);
                break;
        }
    };

    //=============================================================================
    // ConfigManager
    //  追加項目の設定値や初期値を管理します。
    //=============================================================================
    ConfigManager.customParams   = null;
    ConfigManager.hiddenInfo     = {};
    ConfigManager._symbolNumber  = 'Number';
    ConfigManager._symbolBoolean = 'Boolean';
    ConfigManager._symbolString  = 'String';
    ConfigManager._symbolVolume  = 'Volume';

    ConfigManager.getCustomParams = function() {
        if (this.customParams) {
            return this.customParams;
        }
        this.customParams = {};
        param.numberOptions.forEach(function(optionItem, index) {
            this.makeNumberOption(optionItem, index);
        }, this);
        param.stringOptions.forEach(function(optionItem, index) {
            this.makeStringOption(optionItem, index);
        }, this);
        param.switchOptions.forEach(function(optionItem, index) {
            this.makeSwitchOption(optionItem, index);
        }, this);
        param.volumeOptions.forEach(function(optionItem, index) {
            this.makeVolumeOption(optionItem, index);
        }, this);
        return this.customParams;
    };

    ConfigManager.makeNumberOption = function(optionItem, index) {
        var data    = this.makeCommonOption(optionItem, index, this._symbolNumber);
        data.min    = getArgNumber(optionItem.NumberMin);
        data.max    = getArgNumber(optionItem.NumberMax);
        data.offset = getArgNumber(optionItem.NumberStep);
        this.pushOptionData(data);
    };

    ConfigManager.makeStringOption = function(optionItem, index) {
        var data    = this.makeCommonOption(optionItem, index, this._symbolString);
        data.values = getArgJson(optionItem.StringItems, ['no item']);
        data.min    = 0;
        data.max    = data.values.length - 1;
        this.pushOptionData(data);
    };

    ConfigManager.makeSwitchOption = function(optionItem, index) {
        var data       = this.makeCommonOption(optionItem, index, this._symbolBoolean);
        data.initValue = getArgBoolean(optionItem.DefaultValue);
        data.variable  = getArgNumber(optionItem.SwitchID);
        this.pushOptionData(data);
    };

    ConfigManager.makeVolumeOption = function(optionItem, index) {
        var data = this.makeCommonOption(optionItem, index, this._symbolVolume);
        this.pushOptionData(data);
    };

    ConfigManager.makeCommonOption = function(optionItem, index, type) {
        var data       = {};
        data.symbol    = `${type}${index + 1}`;
        data.name      = optionItem.Name;
        data.hidden    = getArgBoolean(optionItem.HiddenFlag);
        data.script    = optionItem.Script;
        data.initValue = getArgNumber(optionItem.DefaultValue);
        data.variable  = getArgNumber(optionItem.VariableID, 0);
        data.addPotion = optionItem.AddPosition;
        data.padding   = getArgNumber(optionItem.PaddingTop);
        return data;
    };

    ConfigManager.pushOptionData = function(data) {
        this.customParams[data.symbol] = data;
    };

    var _ConfigManager_makeData = ConfigManager.makeData;
    ConfigManager.makeData      = function() {
        var config        = _ConfigManager_makeData.apply(this, arguments);
        config.hiddenInfo = {};
        iterate(this.getCustomParams(), function(symbol) {
            config[symbol]            = this[symbol];
            config.hiddenInfo[symbol] = this.hiddenInfo[symbol];
        }.bind(this));
        return config;
    };

    var _ConfigManager_applyData = ConfigManager.applyData;
    ConfigManager.applyData      = function(config) {
        _ConfigManager_applyData.apply(this, arguments);
        iterate(this.getCustomParams(), function(symbol, item) {
            if (symbol.contains(this._symbolBoolean)) {
                this[symbol] = this.readFlagCustom(config, symbol, item);
            } else if (symbol.contains(this._symbolVolume)) {
                this[symbol] = this.readVolumeCustom(config, symbol, item);
            } else {
                this[symbol] = this.readOther(config, symbol, item);
            }
            if (config.hiddenInfo) {
                this.hiddenInfo[symbol] = (typeof config.hiddenInfo[symbol] === 'boolean' ? config.hiddenInfo[symbol] : item.hidden);
            } else {
                this.hiddenInfo[symbol] = item.hidden;
            }
        }.bind(this));
    };

    ConfigManager.customParamUnlock = function(name) {
        iterate(this.getCustomParams(), function(symbol, item) {
            if (item.name === name) this.hiddenInfo[symbol] = false;
        }.bind(this));
        this.save();
    };

    ConfigManager.readOther = function(config, name, item) {
        var value = config[name];
        if (value !== undefined) {
            return Number(value).clamp(item.min, item.max);
        } else {
            return item.initValue;
        }
    };

    ConfigManager.readFlagCustom = function(config, name, item) {
        if (config[name] !== undefined) {
            return this.readFlag(config, name);
        } else {
            return item.initValue;
        }
    };

    ConfigManager.readVolumeCustom = function(config, name, item) {
        if (config[name] !== undefined) {
            return this.readVolume(config, name);
        } else {
            return item.initValue;
        }
    };

    ConfigManager.exportCustomParams = function() {
        if (!$gameVariables || !$gameSwitches) return;
        iterate(this.getCustomParams(), function(symbol, item) {
            if (item.variable > 0) {
                if (symbol.contains(this._symbolBoolean)) {
                    $gameSwitches.setValue(item.variable, !!this[symbol]);
                } else {
                    $gameVariables.setValue(item.variable, this[symbol]);
                }
            }
        }.bind(this));
    };

    ConfigManager.importCustomParams = function() {
        if (!$gameVariables || !$gameSwitches) return;
        iterate(this.getCustomParams(), function(symbol, item) {
            if (item.variable > 0) {
                if (symbol.contains(this._symbolBoolean)) {
                    this[symbol] = $gameSwitches.value(item.variable);
                } else if (symbol.contains(this._symbolVolume)) {
                    this[symbol] = $gameVariables.value(item.variable).clamp(0, 100);
                } else {
                    this[symbol] = $gameVariables.value(item.variable).clamp(item.min, item.max);
                }
            }
        }.bind(this));
    };

    var _ConfigManager_save = ConfigManager.save;
    ConfigManager.save      = function() {
        _ConfigManager_save.apply(this, arguments);
        this.exportCustomParams();
    };

    //=============================================================================
    // Game_Map
    //  リフレッシュ時にオプション値を同期します。
    //=============================================================================
    var _Game_Map_refresh      = Game_Map.prototype.refresh;
    Game_Map.prototype.refresh = function() {
        _Game_Map_refresh.apply(this, arguments);
        ConfigManager.importCustomParams();
    };

    //=============================================================================
    // DataManager
    //  セーブ時とロード時にオプション値を同期します。
    //=============================================================================
    var _DataManager_setupNewGame = DataManager.setupNewGame;
    DataManager.setupNewGame      = function() {
        _DataManager_setupNewGame.apply(this, arguments);
        ConfigManager.exportCustomParams();
    };

    var _DataManager_loadGameWithoutRescue = DataManager.loadGameWithoutRescue;
    DataManager.loadGameWithoutRescue      = function(savefileId) {
        var result = _DataManager_loadGameWithoutRescue.apply(this, arguments);
        ConfigManager.exportCustomParams();
        return result;
    };

    //=============================================================================
    // Window_Options
    //  追加項目を描画します。
    //=============================================================================
    var _Window_Options_initialize      = Window_Options.prototype.initialize;
    Window_Options.prototype.initialize = function() {
        this._customParams = ConfigManager.getCustomParams();
        _Window_Options_initialize.apply(this, arguments);
        this.select(localOptionWindowIndex);
        localOptionWindowIndex = 0;
    };

    var _Window_Options_itemRect = Window_Options.prototype.itemRect;
    Window_Options.prototype.itemRect = function(index) {
        var rect = _Window_Options_itemRect.apply(this, arguments);
        rect.y += this.findAdditionalHeight(index);
        return rect;
    };

    Window_Options.prototype.findAdditionalHeight = function(index) {
        return this._list.reduce(function(prev, item, itemIndex) {
            return prev + (itemIndex <= index && item.ext ? item.ext : 0);
        }, 0);
    };

    var _Window_Options_makeCommandList      = Window_Options.prototype.makeCommandList;
    Window_Options.prototype.makeCommandList = function() {
        _Window_Options_makeCommandList.apply(this, arguments);
        this.addCustomOptions();
    };

    Window_Options.prototype.addCustomOptions = function() {
        iterate(this._customParams, function(key, item) {
            if (!ConfigManager.hiddenInfo[key]) {
                this.addCommand(item.name, key, undefined, item.padding);
                if (item.addPotion) {
                    this.shiftCustomOptions(item.addPotion);
                }
            }
        }.bind(this));
    };

    Window_Options.prototype.shiftCustomOptions = function(addPotion) {
        var targetCommand = this._list.filter(function(command) {
            return command.symbol === addPotion;
        })[0];
        if (!targetCommand) {
            return;
        }
        var targetIndex = this._list.indexOf(targetCommand);
        var newCommand = this._list.pop();
        this.addIndexForManoInputConfig(targetIndex);
        this._list.splice(targetIndex, 0, newCommand);
    };

    Window_Options.prototype.addIndexForManoInputConfig = function(index) {
        if (this._gamepadOptionIndex > index) {
            this._gamepadOptionIndex += 1;
        }
        if (this._keyboardConfigIndex > index) {
            this._keyboardConfigIndex += 1;
        }
    };

    var _Window_Options_statusText      = Window_Options.prototype.statusText;
    Window_Options.prototype.statusText = function(index) {
        var result = _Window_Options_statusText.apply(this, arguments);
        var symbol = this.commandSymbol(index);
        var value  = this.getConfigValue(symbol);
        if (this.isNumberSymbol(symbol)) {
            result = this.numberStatusText(value);
        } else if (this.isStringSymbol(symbol)) {
            result = this.stringStatusText(value, symbol);
        }
        return result;
    };

    Window_Options.prototype.isNumberSymbol = function(symbol) {
        return symbol.contains(ConfigManager._symbolNumber);
    };

    Window_Options.prototype.isStringSymbol = function(symbol) {
        return symbol.contains(ConfigManager._symbolString);
    };

    Window_Options.prototype.isCustomSymbol = function(symbol) {
        return !!this._customParams[symbol];
    };

    Window_Options.prototype.numberStatusText = function(value) {
        return value;
    };

    Window_Options.prototype.stringStatusText = function(value, symbol) {
        return this._customParams[symbol].values[value];
    };

    var _Window_Options_processOk      = Window_Options.prototype.processOk;
    Window_Options.prototype.processOk = function() {
        if (!this._shiftValue(1, true)) _Window_Options_processOk.apply(this, arguments);
        this.execScript();
    };

    var _Window_Options_cursorRight      = Window_Options.prototype.cursorRight;
    Window_Options.prototype.cursorRight = function(wrap) {
        if (!this._shiftValue(1, false)) _Window_Options_cursorRight.apply(this, arguments);
    };

    var _Window_Options_cursorLeft      = Window_Options.prototype.cursorLeft;
    Window_Options.prototype.cursorLeft = function(wrap) {
        if (!this._shiftValue(-1, false)) _Window_Options_cursorLeft.apply(this, arguments);
    };

    Window_Options.prototype._shiftValue = function(sign, loopFlg) {
        var symbol = this.commandSymbol(this.index());
        var value  = this.getConfigValue(symbol);
        if (this.isNumberSymbol(symbol)) {
            value += this.numberOffset(symbol) * sign;
            this.changeValue(symbol, this._clampValue(value, symbol, loopFlg));
            return true;
        }
        if (this.isStringSymbol(symbol)) {
            value += sign;
            this.changeValue(symbol, this._clampValue(value, symbol, loopFlg));
            return true;
        }
        return false;
    };

    Window_Options.prototype.execScript = function() {
        var symbol = this.commandSymbol(this.index());
        if (!this.isCustomSymbol(symbol)) return;
        var script = this._customParams[symbol].script;
        if (script) {
            eval(script);
            SoundManager.playOk();
        }
        localOptionWindowIndex = this.index();
    };

    Window_Options.prototype._clampValue = function(value, symbol, loopFlg) {
        var maxValue = this._customParams[symbol].max;
        var minValue = this._customParams[symbol].min;
        if (loopFlg) {
            if (value > maxValue) value = minValue;
            if (value < minValue) value = maxValue;
        }
        return value.clamp(this._customParams[symbol].min, this._customParams[symbol].max);
    };

    Window_Options.prototype.numberOffset = function(symbol) {
        var value = this._customParams[symbol].offset;
        if (Input.isPressed('shift')) value *= 10;
        return value;
    };

    Window_Options.prototype.windowHeight = function() {
        var height = this.fittingHeight(Math.min(this.numVisibleRows(), 14));
        return height + this.findAdditionalHeight(this.maxItems());
    };
})();