code:
//=============================================================================
// MPP_SmoothBattleLog.js
//=============================================================================
// Copyright (c) 2018 Mokusei Penguin
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc 【ver.1.0】戦闘ログの表示方法や動作を変更し、戦闘の進行を早くしたりします。
 * @author 木星ペンギン
 *
 * @help ▼ 動作詳細
 * --------------------------------
 *  〇 戦闘ログの表示方法を蓄積型にすることで、ログ進行が早くても
 *    文章がすぐに消ることがなくなります。
 *
 *  〇 通常、敵を倒した際の演出が終了するまでキャラクターは動きませんが、
 *    演出の終了を待たずにキャラクターが元の位置に戻ります。
 *
 *  〇 通常、前に行動したキャラクターが元の位置に戻らないと
 *    次のキャラクターは行動しませんが、
 *    前のキャラクターが行動を終了した時点で次のキャラクターが行動します。
 *
 *  〇 アニメーションの終了待ちの時間を短縮します。
 *    短縮する時間はプラグインパラメータ[Animation Short Count]にて変更可能です。
 *
 *  〇 パーティコマンドから戦闘過去ログを確認することができます。
 *
 * ================================================================
 * ▼ プラグインパラメータ 詳細
 * --------------------------------
 *  〇 Fast Forward Enabled? (戦闘ログの高速表示の有効/無効)
 *   「戦闘ログの高速表示」はツクールＭＶのデフォルトの機能です。
 *   決定キー長押しや長押しタッチなどでログ表示が早くなる機能の有無を
 *   変更します。
 *
 * --------------------------------
 *  〇 Log Type (戦闘ログの消去タイプ)
 *   0:まとめて消去
 *    最後のログが表示されてから一定時間がたつと戦闘ログウィンドウが
 *    非表示となります。
 *
 *   1:一行ずつ消去
 *    表示されてから一定時間経過したログから順に消去されます。
 *
 * --------------------------------
 *  〇 Not Display Skils (ログに表示しないスキルIDの配列)
 *   n-m と表記することで、nからmまでの数値を指定できます。
 *   (例 : 1-4,8 => 1,2,3,4,8)
 *
 * --------------------------------
 *  〇 Log Command (戦闘過去ログを表示するコマンド名)
 *   コマンドはパーティコマンドに追加されます。
 *
 * ================================
 * 制作 : 木星ペンギン
 * URL : http://woodpenguin.blog.fc2.com/
 *
 * @param === Base ===
 * @default 【基本的な設定】
 *
 * @param Fast Forward Enabled?
 * @type boolean
 * @desc 戦闘ログの高速表示の有効/無効
 * @default false
 * @parent === Base ===
 *
 * @param Log Type
 * @type number
 * @max 1
 * @desc 戦闘ログの消去タイプ
 * (0:まとめて消去, 1:一行ずつ消去)
 * @default 1
 * @parent === Base ===
 *
 * @param Message Speed
 * @type number
 * @desc 戦闘ログの表示速度
 * @default 8
 * @parent === Base ===
 *
 * @param View Duration
 * @type number
 * @desc 戦闘ログの表示時間
 * (0:常時表示)
 * @default 150
 * @parent === Base ===
 *
 * @param Start Messages On Log?
 * @type boolean
 * @desc 戦闘開始メッセージをログに表示するかどうか
 * @default false
 * @parent === Base ===
 *
 * @param Log Command
 * @desc 戦闘過去ログを表示するコマンド名
 * @default 戦闘ログ
 * @parent === Base ===
 *
 * @param Log Max Size
 * @type number
 * @desc 戦闘ログを保持する数
 * @default 100
 * @parent === Base ===
 *
 * @param Item Name Only?
 * @type boolean
 * @desc アイテム/スキル名のみ表示
 * @default false
 * @parent === Base ===
 *
 * @param Not Display Skils
 * @desc ログに表示しないスキルIDの配列
 * (範囲指定可)
 * @default 1,2
 * @parent === Base ===
 *
 *
 * @param === Window ===
 * @default 【ログウィンドウ】
 *
 * @param Log Window Y
 * @type number
 * @min -1000
 * @desc ログウィンドウのY座標
 * @default 0
 * @parent === Window ===
 *
 * @param Log Window Width
 * @type number
 * @desc ログウィンドウの幅
 * @default 816
 * @parent === Window ===
 *
 * @param Line Height
 * @type number
 * @desc 戦闘ログの一行の高さ
 * @default 30
 * @parent === Window ===
 *
 * @param Font Size
 * @type number
 * @desc 戦闘ログの文字サイズ
 * @default 24
 * @parent === Window ===
 *
 * @param Max Lines
 * @type number
 * @min 1
 * @desc 戦闘ログの最大表示行数
 * @default 6
 * @parent === Window ===
 *
 *
 * @param === Advanced ===
 * @default 【高度な設定】
 *
 * @param Indent Width
 * @type number
 * @desc インデント(字下げ)の幅
 * @default 12
 * @parent === Advanced ===
 *
 * @param Animation Next Delay
 * @type number
 * @desc 複数の対象にアニメーションを表示する際の間隔
 * @default 12
 * @parent === Advanced ===
 *
 * @param Animation Short Count
 * @type number
 * @desc アニメーション待ちを短縮する時間
 * @default 16
 * @parent === Advanced ===
 *
 *
 *
 *
 *
 *
 *
 */

(function () {

var MPPlugin = {};

(function() {

    var parameters = PluginManager.parameters('MPP_SmoothBattleLog');

    function convertParam(name) {
        var param = parameters[name];
        var result = [];
        if (param) {
            var data = param.split(',');
            for (var i = 0; i < data.length; i++) {
                if (/(\d+)\s*-\s*(\d+)/.test(data[i])) {
                    for (var n = Number(RegExp.$1); n <= Number(RegExp.$2); n++) {
                        result.push(n);
                    }
                } else {
                    result.push(Number(data[i]));
                }
            }
        }
        return result;
    };

    MPPlugin.FastForwardEnabled = !!eval(parameters['Fast Forward Enabled?']);
    MPPlugin.LogType = Number(parameters['Log Type'] || 1);
    MPPlugin.MaxLines = Number(parameters['Max Lines'] || 6);
    MPPlugin.MessageSpeed = Number(parameters['Message Speed'] || 8);
    MPPlugin.ViewDuration = Number(parameters['View Duration'] || 150);
    MPPlugin.StartMessagesOnLog = !!eval(parameters['Start Messages On Log?']);
    MPPlugin.LogCommand = parameters['Log Command'] || '';
    MPPlugin.LogMaxSize = Number(parameters['Log Max Size'] || 100);
    MPPlugin.ItemNameOnly = !!eval(parameters['Item Name Only?']);
    MPPlugin.NotDisplaySkils = convertParam('Not Display Skils');

    MPPlugin.LogWindowY = Number(parameters['Log Window Y'] || 0);
    MPPlugin.LogWindowWidth = Number(parameters['Log Window Width'] || 816);
    MPPlugin.LineHeight = Number(parameters['Line Height'] || 30);
    MPPlugin.FontSize = Number(parameters['Font Size'] || 24);

    MPPlugin.IndentWidth = Number(parameters['Indent Width'] || 32);
    MPPlugin.AnimationNextDelay = Number(parameters['Animation Next Delay'] || 12);
    MPPlugin.AnimationShortCount = Number(parameters['Animation Short Count'] || 12);

})();

var Alias = {};

//-----------------------------------------------------------------------------
// BattleManager

//164
Alias.BaMa_isBusy = BattleManager.isBusy;
BattleManager.isBusy = function() {
    if (Alias.BaMa_isBusy.apply(this, arguments)) {
        return true;
    }
    if (this.isBattleEnd() && this.waitBattleEnd()) {
        return true;
    }
    return false;
};

BattleManager.isBattleEnd = function() {
    return ($gameParty.isAllDead() || $gameTroop.isAllDead());
};

BattleManager.waitBattleEnd = function() {
    return (this._spriteset.isEffecting() || this._spriteset.isAnyoneMoving());
};

//229
Alias.BaMa_displayStartMessages = BattleManager.displayStartMessages;
BattleManager.displayStartMessages = function() {
    if (!MPPlugin.StartMessagesOnLog)
        Alias.BaMa_displayStartMessages.apply(this, arguments);
};

BattleManager.displayStartMessagesOnLog = function() {
    $gameTroop.enemyNames().forEach(function(name) {
        this._logWindow.push('addText', TextManager.emerge.format(name));
    }, this);
    if (this._preemptive) {
        this._logWindow.push('wait');
        this._logWindow.push('addText', TextManager.preemptive.format($gameParty.name()));
    } else if (this._surprise) {
        this._logWindow.push('wait');
        this._logWindow.push('addText', TextManager.surprise.format($gameParty.name()));
    }
    this._logWindow.push('clear');
};

//480
Alias.BaMa_checkBattleEnd = BattleManager.checkBattleEnd;
BattleManager.checkBattleEnd = function() {
    var result = Alias.BaMa_checkBattleEnd.apply(this, arguments);
    if (result) {
        this._logWindow.clear_mppSBL();
        this._logWindow.endSelect();
    }
    return result;
};

//-----------------------------------------------------------------------------
// Window_Base

//303
Alias.WiBa_processEscapeCharacter = Window_Base.prototype.processEscapeCharacter;
Window_Base.prototype.processEscapeCharacter = function(code, textState) {
    if (code === 'PX') {
        textState.x += this.obtainEscapeParam(textState);
    } else {
        Alias.WiBa_processEscapeCharacter.apply(this, arguments);
    }
};

//-----------------------------------------------------------------------------
// Window_BattleLog

//14
Alias.WiBaLo_initialize = Window_BattleLog.prototype.initialize;
Window_BattleLog.prototype.initialize = function() {
    this._clearDuration = 0;
    this._logScrollYDuration = 0;
    this._logScrollY = this.lineHeight();
    this._logs = [];
    Alias.WiBaLo_initialize.apply(this, arguments);
    this.createLogSprites();
};

//34
Window_BattleLog.prototype.windowWidth = function() {
    return MPPlugin.LogWindowWidth;
};

//
Window_BattleLog.prototype.lineHeight = function() {
    return MPPlugin.LineHeight;
};

//
Window_BattleLog.prototype.standardFontSize = function() {
    return MPPlugin.FontSize;
};

//
Window_BattleLog.prototype.maxItems = function() {
    return this._logs.length;
};

//42
Window_BattleLog.prototype.maxLines = function() {
    return MPPlugin.MaxLines;
};

//46
Window_BattleLog.prototype.createBackBitmap = function() {
    this._backBitmap = new Bitmap(this.width, this.contentsHeight());
};

Window_BattleLog.prototype.createLogSprites = function() {
    this._logMainSprite = new Sprite();
    this.addChild(this._logMainSprite);
    this._logSprites = [];
    var max = this.maxLines() + 1;
    for (var i = 0; i < max; i++) {
        var sprite = new Sprite();
        sprite.bitmap = new Bitmap(this.contentsWidth(), this.lineHeight());
        this._logSprites[i] = sprite;
        this._logMainSprite.addChild(sprite);
    }
};

//61
Window_BattleLog.prototype.messageSpeed = function() {
    return MPPlugin.MessageSpeed;
};

//
if (Window_Message.prototype.hasOwnProperty('itemRectForText')) {
    Alias.WiBaLo_itemRectForText = Window_BattleLog.prototype.itemRectForText;
}
Window_BattleLog.prototype.itemRectForText = function(index) {
    var _super = Alias.WiBaLo_itemRectForText ||
            Window_Selectable.prototype.itemRectForText;
    var rect = _super.apply(this, arguments);
    if (!this.active) rect.y = 0;
    return rect;
};

//69
Alias.WiBaLo_update = Window_BattleLog.prototype.update;
Window_BattleLog.prototype.update = function() {
    Window_Selectable.prototype.update.call(this);
    Alias.WiBaLo_update.apply(this, arguments);
    this.updateLogSprites();
};

//
if (Window_Selectable.prototype.hasOwnProperty('updateArrows')) {
    Alias.WiSe_updateArrows = Window_Selectable.prototype.updateArrows;
}
Window_BattleLog.prototype.updateArrows = function() {
    if (Alias.WiSe_updateArrows) {
        Alias.WiSe_updateArrows.apply(this, arguments);
    } else {
        Window_Selectable.prototype.updateArrows.apply(this, arguments);
    }
    if (!this.active) {
        this.downArrowVisible = false;
        this.upArrowVisible = false;
    }
};

Window_BattleLog.prototype.updateLogSprites = function() {
    var lineHeight = this.lineHeight();
    if (this._logScrollYDuration > 0) {
        this._logScrollYDuration--;
        this._logScrollY = this.step(this._logScrollYDuration,
                                        lineHeight, this._logScrollY);
    }
    for (var i = 0; i < this._logSprites.length; i++) {
        var sprite = this._logSprites[i];
        var rect = this.itemRect(i);
        rect.y = i * lineHeight - this._logScrollY;
        if (sprite.logScrollXDuration > 0) sprite.logScrollXDuration--;
        sprite.x = Math.round(Math.pow(sprite.logScrollXDuration, 2) / 2);
        sprite.y = rect.y.clamp(0, (this.maxLines() - 1) * lineHeight);
        var y = Math.max(-rect.y, 0);
        sprite.setFrame(0, y, rect.width, rect.height - y);
        sprite.opacity = 255 - sprite.logScrollXDuration * 20;
        if (sprite.viewDuration > 0)
            sprite.viewDuration--;
    }
    if (this._clearDuration > 0) {
        this._clearDuration--;
        var max = Math.min(16, MPPlugin.ViewDuration);
        if (this._clearDuration < max) {
            this._logMainSprite.opacity = 255 * this._clearDuration / max;
            this._backSprite.opacity = 255 * this._clearDuration / max;
        }
        if (this._clearDuration === 0)
            this.clear_mppSBL();
    } else if (this.numLines() > 0) {
        if (this._logSprites[1].viewDuration === 0)
            this.shiftLine();
    }
    this._logMainSprite.x = this.padding;
    this._logMainSprite.y = this.padding;
    this._backSprite.y = this.padding;
    var height = (this.numLines() + 1) * lineHeight - this._logScrollY;
    height = Math.min(height, this.maxLines() * lineHeight);
    var y = this.maxLines() * lineHeight - height;
    this._backSprite.setFrame(0, y, this.width, height);
};

Window_BattleLog.prototype.step = function(d, t, n) {
    return Math.round(t + (n - t) * Math.pow(d, 2) / Math.pow(d + 1, 2));
};

Window_BattleLog.prototype.shiftLine = function() {
    this._lines.shift();
    var sprite = this._logSprites.shift();
    sprite.bitmap.clear();
    this._logSprites.push(sprite);
    this._logScrollY -= this.lineHeight();
    this._logScrollYDuration = 16;
};

//121
Alias.WiBaLo_isFastForward = Window_BattleLog.prototype.isFastForward;
Window_BattleLog.prototype.isFastForward = function() {
    return MPPlugin.FastForwardEnabled && Alias.WiBaLo_isFastForward.apply(this, arguments);
};

//131
Alias.WiBaLo_clear = Window_BattleLog.prototype.clear;
Window_BattleLog.prototype.clear = function() {
    if (MPPlugin.ItemNameOnly) {
        this.clear_mppSBL();
        return;
    }
    this._baseLineStack = [];
    if (MPPlugin.LogType === 0)
        this._clearDuration = MPPlugin.ViewDuration;
};
Window_BattleLog.prototype.clear_mppSBL = function() {
    Alias.WiBaLo_clear.call(this);
    for (var i = 0; i < this._logSprites.length; i++) {
        this._logSprites[i].bitmap.clear();
    }
    this._logScrollYDuration = 0;
    this._logScrollY = this.lineHeight();
};

//141
Window_BattleLog.prototype.waitForEffect = function() {
    //this.setWaitMode('effect');
};

//149
Window_BattleLog.prototype.addText = function(text) {
    var indent = this._baseLineStack.length;
    if (indent > 0) {
        text = '\\px[%1]'.format(indent * MPPlugin.IndentWidth) + text;
    }
    if (!MPPlugin.ItemNameOnly) {
        this._lines.push(text);
        if (this.numLines() > this.maxLines()) this.shiftLine();
    }
    this._logs.push(text);
    if (this.maxItems() > MPPlugin.LogMaxSize) this._logs.shift();

    if (this.active) {
        this.refresh();
    } else if (!MPPlugin.ItemNameOnly) {
        var index = this.numLines() - 1;
        var sprite = this._logSprites[index + 1];
        sprite.logScrollXDuration = 12;
        if (MPPlugin.LogType === 1)
            sprite.viewDuration = MPPlugin.ViewDuration || -1;

        this.drawLineText(index);
    }
    this.wait();
    this._clearDuration = 0;
    this._logMainSprite.opacity = 255;
    this._backSprite.opacity = 255;
};

Window_BattleLog.prototype.addItemName = function(name) {
    this._lines.push(name);
    var index = this.numLines() - 1;
    var sprite = this._logSprites[index + 1];
    sprite.logScrollXDuration = 0;
    sprite.viewDuration = -1;

    this.drawLineText(index);
};

//159
Window_BattleLog.prototype.popBaseLine = function() {
    var baseLine = this._baseLineStack.pop();
//    while (this._lines.length > baseLine) {
//        this._lines.pop();
//    }
};

//269
Window_BattleLog.prototype.animationNextDelay = function() {
    return MPPlugin.AnimationNextDelay;
};

//273
Alias.WiBaLo_refresh = Window_BattleLog.prototype.refresh;
Window_BattleLog.prototype.refresh = function() {
    if (this.active) {
        Window_Selectable.prototype.refresh.apply(this, arguments);
    } else {
        Alias.WiBaLo_refresh.apply(this, arguments);
    }
};

//290
Window_BattleLog.prototype.backRect = function() {
    return {
        x: 0,
        y: 0,
        width: this.width,
        height: this.contentsHeight()
    };
};

//307
Alias.WiBaLo_drawLineText = Window_BattleLog.prototype.drawLineText;
Window_BattleLog.prototype.drawLineText = function(index) {
    var sprite = this._logSprites[index + 1];
    var baseContents = this.contents;
    this.contents = sprite.bitmap;

    if (MPPlugin.ItemNameOnly) {
        var rect = this.itemRectForText(index);
        this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);
        this.drawText(this._lines[index], rect.x, rect.y, rect.width, 'center');
    } else {
        Alias.WiBaLo_drawLineText.apply(this, arguments);
    }

    this.contents = baseContents;
};

//326
Window_BattleLog.prototype.endAction = function(subject) {
    //this.push('waitForNewLine');
    this.push('clear');
    this.push('performActionEnd', subject);
};

//345
Alias.WiBaLo_displayAction = Window_BattleLog.prototype.displayAction;
Window_BattleLog.prototype.displayAction = function(subject, item) {
    if (MPPlugin.ItemNameOnly) {
        if (!DataManager.isSkill(item) || !MPPlugin.NotDisplaySkils.contains(item.id)) {
            this.push('addItemName', item.name);
        }
    }
    Alias.WiBaLo_displayAction.apply(this, arguments);
};

Window_BattleLog.prototype.drawItem = function(index) {
    var rect = this.itemRectForText(index);
    this.drawTextEx(this._logs[index], rect.x, rect.y, rect.width);
};

Window_BattleLog.prototype.startSelect = function(height) {
    this.activate();
    this.opacity = 255;
    this.height = height;
    this.createContents();
    this.openness = 0;
    this.open();
    this._logMainSprite.visible = false;
    this._backSprite.visible = false;
    this.select(Math.max(this.maxItems() - 1, 0));
    this.refresh();
};

//
Window_BattleLog.prototype.endSelect = function() {
    this.deactivate();
    this.opacity = 0;
    this.height = this.windowHeight();
    this._logMainSprite.visible = true;
    this._backSprite.visible = true;
    this.downArrowVisible = false;
    this.upArrowVisible = false;
    this.deselect();
    this.refresh();
};

//-----------------------------------------------------------------------------
// Window_PartyCommand

//28
Alias.WiPaCo_makeCommandList = Window_PartyCommand.prototype.makeCommandList;
Window_PartyCommand.prototype.makeCommandList = function() {
    Alias.WiPaCo_makeCommandList.apply(this, arguments);
    if (MPPlugin.LogCommand)
        this.addCommand(MPPlugin.LogCommand, 'battleLog');
};

//-----------------------------------------------------------------------------
// Sprite_Battler

//
Sprite_Battler.prototype.isAnimationPlaying = function() {
    return this._animationSprites.some(function(animation) {
        return animation._duration > MPPlugin.AnimationShortCount;
    });
};

//-----------------------------------------------------------------------------
// Spriteset_Battle

//271
Spriteset_Battle.prototype.isBusy = function() {
    return this.isAnimationPlaying();// || this.isAnyoneMoving();
};

//-----------------------------------------------------------------------------
// Scene_Battle

//46
Alias.ScBat_isAnyInputWindowActive = Scene_Battle.prototype.isAnyInputWindowActive;
Scene_Battle.prototype.isAnyInputWindowActive = function() {
    return (Alias.ScBat_isAnyInputWindowActive.apply(this, arguments) ||
            this._logWindow.active);
};

//127
Alias.ScBat_createDisplayObjects = Scene_Battle.prototype.createDisplayObjects;
Scene_Battle.prototype.createDisplayObjects = function() {
    Alias.ScBat_createDisplayObjects.apply(this, arguments);
    if (MPPlugin.StartMessagesOnLog)
        BattleManager.displayStartMessagesOnLog();
};

//156
Alias.ScBat_createLogWindow = Scene_Battle.prototype.createLogWindow;
Scene_Battle.prototype.createLogWindow = function() {
    Alias.ScBat_createLogWindow.apply(this, arguments);
    this._logWindow.y = MPPlugin.LogWindowY;
    this._logWindow.setHandler('cancel', this.onLogCancel.bind(this));
};

//166
Alias.ScBat_createPartyCommandWindow = Scene_Battle.prototype.createPartyCommandWindow;
Scene_Battle.prototype.createPartyCommandWindow = function() {
    Alias.ScBat_createPartyCommandWindow.apply(this, arguments);
    this._partyCommandWindow.setHandler('battleLog',  this.commandLog.bind(this));
};

Scene_Battle.prototype.commandLog = function() {
    this._logWindow.startSelect(this._statusWindow.y);
};

Scene_Battle.prototype.onLogCancel = function() {
    this._logWindow.endSelect();
    this._partyCommandWindow.activate();
};

//400
Alias.ScBat_endCommandSelection = Scene_Battle.prototype.endCommandSelection;
Scene_Battle.prototype.endCommandSelection = function() {
    Alias.ScBat_endCommandSelection.call(this);
    this._logWindow.endSelect();
};

})();


code:
var MikauSchekzen = MikauSchekzen || {};
MikauSchekzen.NoBattleBgm = MikauSchekzen.NoBattleBgm || {};

/*:
@plugindesc Allows the user to disable and enable battle BGM
@author MikauSchekzen

@help
Available plugin commands:
EnableBattleBgm
DisableBattleBgm
ToggleBattleBgm
*/

/*
	gameSystem
*/
MikauSchekzen.NoBattleBgm.gameSystem_initialize =
	Game_System.prototype.initialize;
Game_System.prototype.initialize = function() {
	MikauSchekzen.NoBattleBgm.gameSystem_initialize.call(this);
	this._battleBgmEnabled = true;
};

BattleManager.playBattleBgm = function() {
	if($gameSystem._battleBgmEnabled) {
  	AudioManager.playBgm($gameSystem.battleBgm());
  }
  AudioManager.stopBgs();
};

MikauSchekzen.NoBattleBgm.stopAudioOnBattleStart =
	Scene_Map.prototype.stopAudioOnBattleStart;
Scene_Map.prototype.stopAudioOnBattleStart = function() {
    if($gameSystem._battleBgmEnabled) {
    	MikauSchekzen.NoBattleBgm.stopAudioOnBattleStart.call(this);
    }
};

// Adjust Yanfly's Victory Aftermath processNormalVictory
if(Yanfly && Yanfly.VA) {
	BattleManager.processNormalVictory = function() {
	  if (!$gameSystem.skipVictoryMusic() && $gameSystem._battleBgmEnabled) this.playVictoryMe();
	  this.makeRewards();
	  this.startVictoryPhase();
	};
}
// Adjust default processVictory
else {
	BattleManager.processVictory = function() {
    $gameParty.removeBattleStates();
    $gameParty.performVictory();
    if($gameSystem._battleBgmEnabled) {
	    this.playVictoryMe();
	    this.replayBgmAndBgs();
	  }
    this.makeRewards();
    this.displayVictoryMessage();
    this.displayRewards();
    this.gainRewards();
    this.endBattle(0);
	};
}

// Enable plugin commands
MikauSchekzen.NoBattleBgm.Game_Interpreter_pluginCommand =
	Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function(command, args) {
	MikauSchekzen.NoBattleBgm.Game_Interpreter_pluginCommand.call(this, command, args);
	if(command === "EnableBattleBgm")	$gameSystem._battleBgmEnabled = true;
	if(command === "DisableBattleBgm")	$gameSystem._battleBgmEnabled = false;
	if(command === "ToggleBattleBgm")	$gameSystem._battleBgmEnabled = !$gameSystem._battleBgmEnabled;
};

repo_name: onms/sister

license: unknown


code:
//=============================================================================
// MT_ChangeMoveSpeed.js
// 移動速度を補正するプラグイン
// ----------------------------------------------------------------------------
// (C) 2019 Moooty
//=============================================================================

/*:
 * @plugindesc Change Move Speed.
 * @author Moooty
 *
 * @param playerWalkSpeedRate
 * @desc Player(and Follower)'s move speed rate(default：1)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param vehicle1MoveSpeedRate
 * @desc Vehicle1(Boat)'s move speed rate.(default: 1)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param vehicle2MoveSpeedRate
 * @desc Vehicle2(Ship)'s move speed rate.(default: 1)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param vehicle3MoveSpeedRate
 * @desc Vehicle3(Airship)'s move speed rate.(default: 1)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param eventSpeedRate
 * @desc Map Event's move speed rate.(default: 1)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @help
 * === Description ===
 * Multiply move speed by plagin paramter.
 *
 * Nothing plugin commnad this plugin.
 *
 *
 * === Change Log ===
 * Apr 18, 2019 ver1.00 Initial release.
 * Nov 24, 2019 ver1.10 Rename plugin file.（ChangeMoveSpeed → MT_ChangeMoveSpeed.js）
 *
 * === Manual & License(Japanese) ===
 * https://www.5ing-myway.com/rpgmaker-plugin-change-move-speed/
 *
 */

/*:ja
 * @plugindesc 移動速度を補正
 * @author むーてぃ
 *
 * @param playerWalkSpeedRate
 * @text プレイヤーの移動速度補正
 * @desc プレイヤーとフォロワー(仲間)の移動速度補正(デフォルト：1倍)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param vehicle1MoveSpeedRate
 * @text 乗り物1の移動速度補正
 * @desc 乗り物1の移動速度補正(デフォルト: 1倍)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param vehicle2MoveSpeedRate
 * @text 乗り物2の移動速度補正
 * @desc 乗り物2の移動速度補正(デフォルト: 1倍)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param vehicle3MoveSpeedRate
 * @text 乗り物3の移動速度補正
 * @desc 乗り物3の移動速度補正(デフォルト: 1倍)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @param eventSpeedRate
 * @text マップイベントの移動速度補正
 * @desc マップイベントの移動速度補正(デフォルト:1倍)
 * @type number
 * @decimals 2
 * @default 1.00
 *
 * @help
 * === 説明 ===
 * 移動速度を変更できるプラグインです。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * === 更新履歴 ===
 * 2019/04/18 ver1.00 初版
 * 2019/11/24 ver1.10 ファイル名変更（ChangeMoveSpeed → MT_ChangeMoveSpeed.js）
 *
 * === マニュアル＆ライセンス ===
 * https://www.5ing-myway.com/rpgmaker-plugin-change-move-speed/
 *
 */

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

(function(){
    'use strict';

    const PLUGIN_NAME       = "MT_ChangeMoveSpeed";
    var parameters          = PluginManager.parameters(PLUGIN_NAME);

    var playerMoveSpeedRate = getParameterValue(parameters['playerWalkSpeedRate'], 1);
    var vehiclesSpeedRate   = [];
    vehiclesSpeedRate.push(getParameterValue(parameters['vehicle1MoveSpeedRate'], 1));
    vehiclesSpeedRate.push(getParameterValue(parameters['vehicle2MoveSpeedRate'], 1));
    vehiclesSpeedRate.push(getParameterValue(parameters['vehicle3MoveSpeedRate'], 1));

    var eventSpeedRate = getParameterValue(parameters['eventSpeedRate'], 1);

    // ---------- rpg_object.js の変更ここから ----------
    // Game_CharacterBase
    // 元の式に移動速度補正をかける
    var _Game_CharacterBase_distancePerFrame = Game_CharacterBase.prototype.distancePerFrame;
    Game_CharacterBase.prototype.distancePerFrame = function() {
		return _Game_CharacterBase_distancePerFrame.call(this) * this.moveSpeedRate();
    };

    // メソッド追加(速度補正取得)
    Game_CharacterBase.prototype.moveSpeedRate = function(){
		return this._moveSpeedRate;
    };

    // Game_Player
    var _Game_Player_initialize = Game_Player.prototype.initialize;
    Game_Player.prototype.initialize = function() {
		_Game_Player_initialize.call(this);
		this._moveSpeedRate = playerMoveSpeedRate;
    };

    // メソッド追加(速度補正取得)
    Game_Player.prototype.moveSpeedRate = function(){
		if($gamePlayer.vehicle() != null){
			if($gamePlayer.vehicle()._driving){
				return $gamePlayer.vehicle()._moveSpeedRate;
			}
		}

		return this._moveSpeedRate;
    };

    // Game_Follower
    var _Game_Follower_initialize = Game_Follower.prototype.initialize;
    Game_Follower.prototype.initialize = function(memberIndex) {
		_Game_Follower_initialize.call(this, memberIndex);
		this._moveSpeedRate = playerMoveSpeedRate;
    };

    // Game_Vehicle
    var _Game_Vehicle_initialze = Game_Vehicle.prototype.initialize;
    Game_Vehicle.prototype.initialize = function(type) {
		_Game_Vehicle_initialze.call(this, type);

		if (this.isBoat()) {
				this._moveSpeedRate = vehiclesSpeedRate[0];
		} else if (this.isShip()) {
				this._moveSpeedRate = vehiclesSpeedRate[1];
		} else if (this.isAirship()) {
				this._moveSpeedRate = vehiclesSpeedRate[2];
		}
    };

    // Game_Event
    var _Game_Event_initialize = Game_Event.prototype.initialize;
    Game_Event.prototype.initialize = function(mapId, eventId) {
		this._moveSpeedRate = eventSpeedRate;
		_Game_Event_initialize.call(this, mapId, eventId);
    };
    // ---------- rpg_object.js の変更ここまで ----------

    // ---------- パラメータ取得用関数ここから ----------
    // @type numberのパラメータでも文字列を入れることができてしまう対策
    function getParameterValue(param, defaultValue){
	    var result = Number(param || defaultValue);

	    if(Number.isNaN(result)){
	        result = defaultValue;
	    }

	    return result;
    };
    // ---------- パラメータ取得用関数ここまで ----------
})();


code:
//=============================================================================
// MT_ConfirmEscape.js
// 逃げるコマンドに確認メッセージを表示するプラグイン
// ----------------------------------------------------------------------------
// (C) 2019 Moooty
//=============================================================================

/*:
 * @plugindesc Display confirm message for escape command.
 * @author Moooty
 *
 * @param message1
 * @desc Display message 1.
 * @type note
 * @default "Want to escape?\n(success rate：\\C[4]%\\C[0])"

 * @param rate1
 * @parent message1
 * @desc Display message1 when escape ratio under rate1.
 * @type number
 * @min 0
 * @max 100
 * @default 100
 *
 * @param message2
 * @desc Display message 2.
 * @type note
 * @default "Want to escape?\n(success rate：\\C[17]%\\C[0])"
 *
 * @param rate2
 * @parent message2
 * @desc Display message2 when escape ratio under rate2.
 * @type number
 * @min 0
 * @max 100
 * @default 60
 *
 * @param message3
 * @desc Display message 3.
 * @type note
 * @default "Want to escape?\n(success rate：\\C[18]%\\C[0])"
 *
 * @param rate3
 * @parent message3
 * @desc Display message3 when escape ratio under rate3.
 * @type number
 * @min 0
 * @max 100
 * @default 30
 *
 * @param commandYesLabel
 * @desc Text confirm command 'yes'.
 * @type string
 * @default Yes
 *
 * @param commandNoLabel
 * @desc Text confirm command 'no'.
 * @type string
 * @default No
 *
 * @param commandDefaultIndex
 * @desc Default button in confirm command.
 * @type select
 * @default 0
 *
 * @option command Yes
 * @value 0
 *
 * @option command No
 * @value 1
 *
 * @param commandPosition
 * @desc Display position confirm command.
 * @type select
 * @default 2
 *
 * @option Left
 * @value 0
 *
 * @option Middle
 * @value 1
 *
 * @option Center
 * @value 2
 *
 * @help
 * === Description ===
 * Display confirm message for escape command.
 *
 * Nothing plugin commnad this plugin.
 *
 *
 * === Change Log ===
 * Apr  7, 2019 ver1.00 initial release
 * Apr 22, 2019 ver1.01 bag fix(when party command is hide, freeze on cancel)
 * Nov 24, 2019 ver1.10 rename plugin file.(ConfirmEscape.js→MT_ConfirmEscape.js)
 *
 * === Manual & License(Japanese) ===
 * https://www.5ing-myway.com/rpgmaker-plugin-confirm-escape/
 *
 */

/*:ja
 * @plugindesc 逃げるコマンドに確認メッセージを表示するプラグイン
 * @author むーてぃ
 *
 * @param message1
 * @text メッセージ1
 * @desc 確認メッセージ1
 * @type note
 * @default "本当に逃げますか？\n(成功確率：\\C[4]%\\C[0])"
 *
 * @param rate1
 * @parent message1
 * @text 割合
 * @desc 逃走確率がこの値以下の時にメッセージ1が表示されます
 * @type number
 * @min 0
 * @max 100
 * @default 100
 *
 * @param message2
 * @text メッセージ2
 * @desc 確認メッセージ2
 * @type note
 * @default "本当に逃げますか？\n(成功確率：\\C[17]%\\C[0])"
 *
 * @param rate2
 * @parent message2
 * @text 割合
 * @desc 逃走確率がこの値以下の時にメッセージ2が表示されます
 * @type number
 * @min 0
 * @max 100
 * @default 60
 *
 * @param message3
 * @text メッセージ3
 * @desc 確認メッセージ3
 * @type note
 * @default "本当に逃げますか？\n(成功確率：\\C[18]%\\C[0])"
 *
 * @param rate3
 * @parent message3
 * @text 割合
 * @desc 逃走確率がこの値以下の時にメッセージ3が表示されます
 * @type number
 * @min 0
 * @max 100
 * @default 30
 *
 * @param commandYesLabel
 * @text 「はい」ボタンの名前
 * @desc 逃げるを実行するボタン名
 * @type string
 * @default はい

 * @param commandNoLabel
 * @text 「いいえ」ボタンの名前
 * @desc 逃げるをキャンセルするボタン名
 * @type string
 * @default いいえ
 *
 * @param commandDefaultIndex
 * @text デフォルトボタン
 * @desc デフォルトボタン
 * @type select
 * @default 0
 *
 * @option 「はい」ボタン
 * @value 0
 *
 * @option 「いいえ」ボタン
 * @value 1

 * @param commandPosition
 * @text 選択肢の表示位置
 * @desc 選択肢の表示位置
 * @type select
 * @default 2
 *
 * @option 左
 * @value 0
 *
 * @option 中
 * @value 1
 *
 * @option 右
 * @value 2
 *
 * @help
 * === 説明 ===
 * 逃げるコマンドを選択した時に確認メッセージを表示するプラグインです。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * === 更新履歴 ===
 * 2019/04/07 ver1.00 初版
 * 2019/04/22 ver1.01 パーティコマンドを非表示の時にキャンセルするとフリーズする不具合を修正。
 * 2019/11/24 ver1.10 ファイル名を変更(ConfirmEscape.js → MT_ConfirmEscape.js)
 *
 * === マニュアル＆ライセンス ===
 * https://www.5ing-myway.com/rpgmaker-plugin-confirm-escape/
 *
 */

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

(function(){
    'use strict';

    // 定数の定義
    const PLUGIN_NAME = "MT_ConfirmEscape";

    // ---------- 基本システムの変更 ここから ----------
    // <rpg_managers.js>
    // BattleManagerに逃走確率を取得するメソッドを追加
    BattleManager.getEscapeRatio = function() {
	    return this._escapeRatio;
    };

    // <rpg_scenes.js>
    var _Scene_Battle_initialize = Scene_Battle.prototype.initialize;
    Scene_Battle.prototype.initialize = function() {
	    _Scene_Battle_initialize.call(this);
	    this._isSelectEscape = null;
	    this._confirmEscape = new ConfirmEscape();
    };

    // 逃げるコマンドをオーバーライド
    var _Scene_Battle_commandEscape = Scene_Battle.prototype.commandEscape;
    Scene_Battle.prototype.commandEscape = function() {
	    this._confirmEscape.setText();
	    this._confirmEscape.setChoices();
	    this._confirmEscape.setCallback(function(isEscape) {
	        this._isSelectEscape = isEscape;

		if(!this._isSelectEscepe){
		    this.changeInputWindow();
		}

	        // これを入れないとBattleManager.updateが呼ばれずにフリーズする
		this._partyCommandWindow.deactivate();
		this._actorCommandWindow.deactivate();// 個人コマンドから呼びだした時用

	        // ここで元のcommandEscapeを呼びだすと
	        // 逃走結果メッセージが表示されないのでupdateで判定する
	    }.bind(this));
    };

    // updateに逃げた時の判定処理を追加
    var _Scene_Battle_update = Scene_Battle.prototype.update;
    Scene_Battle.prototype.update = function() {
	    if(this._isSelectEscape != null){
	        if(this._isSelectEscape){
		    _Scene_Battle_commandEscape.call(this);
	        }

	        this._isSelectEscape = null;
	     }

	    _Scene_Battle_update.call(this);
    };
    // ----------基本システムの変更 ここまで ----------

    // ----------ConfirmEscape ここから ----------
    // プラグインパラメータを受け取る
    var parameters = PluginManager.parameters(PLUGIN_NAME);

    function ConfirmEscape(){
	    this.initialize.call(this, arguments);
    };

    ConfirmEscape.prototype.initialize = function(){
	    this._isEscape = null;
	    this._callback = null;
    };

    ConfirmEscape.prototype.setCallback = function(callback){
	    this._callback = callback;
    };

    // 逃走メッセージ取得
    ConfirmEscape.prototype.setText = function(){
	    var ratio = parseInt(BattleManager.getEscapeRatio() * 100);
	    if(ratio > 100){
	        ratio = 100;
	    }

	    var message = this.getMessageByRate(ratio);

	    ratio = ratio + '%';
	    message = message.replace('%', ratio);

	    $gameMessage.add(message);
    };

    // 逃走確率によってメッセージを変える
    ConfirmEscape.prototype.getMessageByRate = function(ratio){
	    var messages = [];
	    var rates = [];

	    for(var i = 1; i < 4; i++ ){
	        messages.push(JsonEx.parse(parameters['message' + i]));
	        rates.push(getParameterValue(parameters['rate' + i], 0));
	    }

	    var result;
	    for(var ri = rates.length - 1; ri >= 0; ri--){
	        var threshold = rates[ri];
	        if(ratio <= threshold){
		        if(messages[ri] !== ''){
		            result = messages[ri];
		            break;
		        }
	        }
	    }

	    if(result === ''){
	        result = messages[0];
	    }

	    return result;
    };

    // 選択肢を設定
    ConfirmEscape.prototype.setChoices = function() {
	    const BACKGROUND_WINDOW = 0;
		const POSITION_RIGHT    = 2;
	    const COMMAND_NO        = 1;

	    var commandYesLabel = parameters['commandYesLabel'];
	    var commandNoLabel  = parameters['commandNoLabel'];
	    var commandDefault  = getParameterValue(parameters['commandDefaultIndex'], 0);
	    var commandPosition = getParameterValue(parameters['commandPosition'], POSITION_RIGHT);

	    var choices         = [commandYesLabel, commandNoLabel];
	    var cancelType      = COMMAND_NO;

	    $gameMessage.setChoices(choices, commandDefault, cancelType);
	    $gameMessage.setChoiceBackground(BACKGROUND_WINDOW);
	    $gameMessage.setChoicePositionType(commandPosition);
	    $gameMessage.setChoiceCallback(function(n) {
	        if(this._callback != null){
		        this._callback(this.selectEscapeYes(n));
		        this._callback = null;
	        }
	    }.bind(this));
    };

    ConfirmEscape.prototype.selectEscapeYes = function(index){
	    if(index === 0){
	        return true;
	    }
	    return false;
    };
    // ----------ConfirmEscape ここまで ----------

    // ---------- パラメータ取得用関数ここから ----------
    // @type numberのパラメータでも文字列を入れることができてしまう対策
    function getParameterValue(param, defaultValue){
	    var result = Number(param || defaultValue);

	    if(Number.isNaN(result)){
	        result = defaultValue;
	    }

	    return result;
    };
})();


code:
/*:
 * NOTE: Images are stored in the img/system folder.
 *
 * @plugindesc Show a Splash Screen "Made with MV" and/or a Custom Splash Screen before going to main screen.
 * @author Dan "Liquidize" Deptula
 *
 * @help This plugin does not provide plugin commands.
 *
 * @param Show Made With MV
 * @desc Enabled/Disables showing the "Made with MV" splash screen.
 * OFF - false     ON - true
 * Default: ON
 * @default true
 *
 * @param Made with MV Image
 * @desc The image to use when showing "Made with MV"
 * Default: MadeWithMv
 * @default MadeWithMv
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param Show Custom Splash
 * @desc Enabled/Disables showing the "Made with MV" splash screen.
 * OFF - false     ON - true
 * Default: OFF
 * @default false
 *
 * @param Custom Image
 * @desc The image to use when showing "Made with MV"
 * Default:
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param Fade Out Time
 * @desc The time it takes to fade out, in frames.
 * Default: 120
 * @default 120
 *
 * @param Fade In Time
 * @desc The time it takes to fade in, in frames.
 * Default: 120
 * @default 120
 *
 * @param Wait Time
 * @desc The time between fading in and out, in frames.
 * Default: 160
 * @default 160
 *
 */
/*:ja
 * メモ: イメージはimg／systemフォルダ内に保存されます。
 *
 * @plugindesc メイン画面へ進む前に、"Made with MV"のスプラッシュ画面もしくはカスタマイズされたスプラッシュ画面を表示します。
 * @author Dan "Liquidize" Deptula
 *
 * @help  このプラグインにはプラグインコマンドはありません。
 *
 * @param Show Made With MV
 * @desc "Made with MV"のスプラッシュ画面を表示できる/できないようにします。
 * OFF - false     ON - true
 * デフォルト: ON
 * @default true
 *
 * @param Made with MV Image
 * @desc "Made with MV"を表示する際に使用する画像
 * デフォルト: MadeWithMv
 * @default MadeWithMv
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param Show Custom Splash
 * @desc "Made with MV"のスプラッシュ画面を表示できる/できないようにします。
 * OFF - false     ON - true
 * デフォルト: OFF
 * @default false
 *
 * @param Custom Image
 * @desc "Made with MV"を表示する際に使用する画像
 * デフォルト:
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param Fade Out Time
 * @desc フェードアウトに要する時間（フレーム数）
 * デフォルト: 120
 * @default 120
 *
 * @param Fade In Time
 * @desc フェードインに要する時間（フレーム数）
 * デフォルト: 120
 * @default 120
 *
 * @param Wait Time
 * @desc フェードインからフェードアウトまでに要する時間（フレーム数）
 * デフォルト: 160
 * @default 160
 *
 */
var Liquidize = Liquidize || {};
Liquidize.MadeWithMV = {};
Liquidize.MadeWithMV.Parameters = PluginManager.parameters('MadeWithMv');

Liquidize.MadeWithMV.ShowMV = JSON.parse(Liquidize.MadeWithMV.Parameters["Show Made With MV"]);
Liquidize.MadeWithMV.MVImage = String(Liquidize.MadeWithMV.Parameters["Made with MV Image"]);
Liquidize.MadeWithMV.ShowCustom = JSON.parse(Liquidize.MadeWithMV.Parameters["Show Custom Splash"]);
Liquidize.MadeWithMV.CustomImage = String(Liquidize.MadeWithMV.Parameters["Custom Image"]);
Liquidize.MadeWithMV.FadeOutTime = Number(Liquidize.MadeWithMV.Parameters["Fade Out Time"]) || 120;
Liquidize.MadeWithMV.FadeInTime = Number(Liquidize.MadeWithMV.Parameters["Fade In Time"]) || 120;
Liquidize.MadeWithMV.WaitTime = Number(Liquidize.MadeWithMV.Parameters["Wait Time"]) || 160;

//-----------------------------------------------------------------------------
// Scene_Splash
//
// This is a constructor, implementation is done in the inner scope.

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

(function() {

    //-----------------------------------------------------------------------------
    // Scene_Boot
    //
    // The scene class for dealing with the game boot.

    var _Scene_Boot_loadSystemImages = Scene_Boot.prototype.loadSystemImages;
    Scene_Boot.prototype.loadSystemImages = function() {
        _Scene_Boot_loadSystemImages.call(this);
        if (Liquidize.MadeWithMV.ShowMV) {
            ImageManager.loadSystem(Liquidize.MadeWithMV.MVImage);
        }
        if (Liquidize.MadeWithMV.ShowCustom) {
            ImageManager.loadSystem(Liquidize.MadeWithMV.CustomImage);
        }
    };

    var _Scene_Boot_start = Scene_Boot.prototype.start;
    Scene_Boot.prototype.start = function() {
        if ((Liquidize.MadeWithMV.ShowMV || Liquidize.MadeWithMV.ShowCustom) && !DataManager.isBattleTest() && !DataManager.isEventTest()) {
            SceneManager.goto(Scene_Splash);
        } else {
            _Scene_Boot_start.call(this);
        }
    };

    //-----------------------------------------------------------------------------
    // Scene_Splash
    //
    // The scene class for dealing with the splash screens.

    Scene_Splash.prototype = Object.create(Scene_Base.prototype);
    Scene_Splash.prototype.constructor = Scene_Splash;

    Scene_Splash.prototype.initialize = function() {
        Scene_Base.prototype.initialize.call(this);
        this._mvSplash = null;
        this._customSplash = null;
        this._mvWaitTime = Liquidize.MadeWithMV.WaitTime;
        this._customWaitTime = Liquidize.MadeWithMV.WaitTime;
        this._mvFadeOut = false;
        this._mvFadeIn = false;
        this._customFadeOut = false;
        this._customFadeIn = false;
    };

    Scene_Splash.prototype.create = function() {
        Scene_Base.prototype.create.call(this);
        this.createSplashes();
    };

    Scene_Splash.prototype.start = function() {
        Scene_Base.prototype.start.call(this);
        SceneManager.clearStack();
        if (this._mvSplash != null) {
            this.centerSprite(this._mvSplash);
        }
        if (this._customSplash != null) {
            this.centerSprite(this._customSplash);
        }
    };

    Scene_Splash.prototype.update = function() {
        if (Liquidize.MadeWithMV.ShowMV) {
            if (!this._mvFadeIn) {
                this.startFadeIn(Liquidize.MadeWithMV.FadeInTime, false);
                this._mvFadeIn = true;
            } else {
                if (this._mvWaitTime > 0 && this._mvFadeOut == false) {
                    this._mvWaitTime--;
                } else {
                    if (this._mvFadeOut == false) {
                        this._mvFadeOut = true;
                        this.startFadeOut(Liquidize.MadeWithMV.FadeOutTime, false);
                    }
                }
            }
        }

        if (Liquidize.MadeWithMV.ShowCustom) {
            if (Liquidize.MadeWithMV.ShowMV && this._mvFadeOut == true) {
                if (!this._customFadeIn && this._fadeDuration == 0) {
                    this._customSplash.opacity = 255;
                    this._customWaitTime = Liquidize.MadeWithMV.WaitTime;
                    this.startFadeIn(Liquidize.MadeWithMV.FadeInTime, false);
                    this._customFadeIn = true;
                } else {
                    if (this._customWaitTime > 0 && this._customFadeOut == false) {
                        this._customWaitTime--;
                    } else {
                        if (this._customFadeOut == false) {
                            this._customFadeOut = true;
                            this.startFadeOut(Liquidize.MadeWithMV.FadeOutTime, false);
                        }
                    }
                }
            } else if (!Liquidize.MadeWithMV.ShowMV) {
                if (!this._customFadeIn) {
                    this._customSplash.opacity = 255;
                    this.startFadeIn(Liquidize.MadeWithMV.FadeInTime, false);
                    this._customFadeIn = true;
                } else {
                    if (this._customWaitTime > 0 && this._customFadeOut == false) {
                        this._customWaitTime--;
                    } else {
                        if (this._customFadeOut == false) {
                            this._customFadeOut = true;
                            this.startFadeOut(Liquidize.MadeWithMV.FadeOutTime, false);
                        }
                    }
                }
            }
        }

        if (Liquidize.MadeWithMV.ShowCustom) {
            if (Liquidize.MadeWithMV.ShowMV && this._mvFadeOut == true && this._customFadeOut == true) {
                this.gotoTitleOrTest();
            } else if (!Liquidize.MadeWithMV.ShowMV && this._customFadeOut == true) {
                this.gotoTitleOrTest();
            }
        } else {
            if (this._mvFadeOut == true) {
                this.gotoTitleOrTest();
            }
        }

        Scene_Base.prototype.update.call(this);
    };

    Scene_Splash.prototype.createSplashes = function() {
        if (Liquidize.MadeWithMV.ShowMV) {
            this._mvSplash = new Sprite(ImageManager.loadSystem(Liquidize.MadeWithMV.MVImage));
            this.addChild(this._mvSplash);
        }
        if (Liquidize.MadeWithMV.ShowCustom) {
            this._customSplash = new Sprite(ImageManager.loadSystem(Liquidize.MadeWithMV.CustomImage));
            this._customSplash.opacity = 0;
            this.addChild(this._customSplash);
        }
    };

    Scene_Splash.prototype.centerSprite = function(sprite) {
        sprite.x = Graphics.width / 2;
        sprite.y = Graphics.height / 2;
        sprite.anchor.x = 0.5;
        sprite.anchor.y = 0.5;
    };

    Scene_Splash.prototype.gotoTitleOrTest = function() {
        Scene_Base.prototype.start.call(this);
        SoundManager.preloadImportantSounds();
        if (DataManager.isBattleTest()) {
            DataManager.setupBattleTest();
            SceneManager.goto(Scene_Battle);
        } else if (DataManager.isEventTest()) {
            DataManager.setupEventTest();
            SceneManager.goto(Scene_Map);
        } else {
            this.checkPlayerLocation();
            DataManager.setupNewGame();
            SceneManager.goto(Scene_Title);
            Window_TitleCommand.initCommandPosition();
        }
        this.updateDocumentTitle();
    };

    Scene_Splash.prototype.updateDocumentTitle = function() {
        document.title = $dataSystem.gameTitle;
    };

    Scene_Splash.prototype.checkPlayerLocation = function() {
        if ($dataSystem.startMapId === 0) {
            throw new Error('Player\'s starting position is not set');
        }
    };

})();


code:
//=============================================================================
// Mano_CoinShop.js
// ----------------------------------------------------------------------------
// Copyright (c) 2019-2019 Sigureya
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 0.9.0 2019/05/26 初版
// ----------------------------------------------------------------------------
// [Twitter]: https://twitter.com/Sigureya/
//=============================================================================
/*:
 * @plugindesc 変数やアイテムを消費して購入できるショップが作れます。
 * 競合率・中ぐらい
 * @author しぐれん(https://github.com/Sigureya/RPGmakerMV)
 *
 * @help
 * お金の代わりに変数やアイテムを消費して購入できるショップを作成できます。
 *
 * 内部的には専用の財布を作って、そこに処理を流します。
 * 既存処理を再定義しているため、競合の可能性があります。
 * （ポイントカードのようなプラグインを使っている場合、これより後ろにおいてください）
 *
 * プラグインコマンドで以下の内容を入力してください。
 * 設定変更は１回のみ有効です。
 *
 * ShopMode モード 識別番号 単位
 * パラメータは上記の通りです。
 * この機能を使った場合、売却機能は強制的にロックされます。
 *
 * ShopMode Variable 8 枚
 * お金の代わりに変数8番の数値を見ます。
 * 単位として「枚」を使うようになります。
 *
 * ShopMode item 3 個
 * お金の代わりにitemID[3]のアイテムの所持数を見ます
 * 単位として「個」を使うようになります。
 *
 * 2019/05/26 公開
 *
*/

(function(){
    'use strict';

class WalletBase{

    /**
     * @param {String} unit
     */
    constructor(unit){
        this.setUnit(unit ||TextManager.currencyUnit);
    }
    /**
     * @param {String} unit
     */
    setUnit(unit){
        this._unit = unit;
    }

    value(){
        return 0;
    }
    pay(value){
    }

    loseValue(value){
        this.pay(value);
    }

    gainValue(value){
        this.pay(-value);
    }
    unit(){
        return this._unit;
    }

    canSeil(){
        return false;
    }

    isGold(){
        return false;
    }
}

class WalletGold extends WalletBase{
    constructor(){
        super(TextManager.currencyUnit);
    }
    value(){
        return $gameParty.gold();
    }
    pay(value){
        $gameParty.loseGold(value);
    }
    canSeil(){
        return true;
    }
    isGold(){
        return true;
    }
}

class WalletItem extends WalletBase{
    /**
     * @param {Number} itemId
     */
    constructor(itemId){
        super();
        this._itemId=itemId;
    }

    item(){
        return $dataItems[this._itemId];
    }

    value(){
        return $gameParty.numItems(this.item());
    }

    pay(value){
        $gameParty.loseItem( this.item(), value);
    }

}
window[WalletItem.name] =WalletItem;

class WalletVariable extends WalletBase{
    /**
     * @param {Number} id
     */
    constructor(id){
        super();
        this._variableId=id;
    }
    value(){
        return $gameVariables.value(this._variableId);
    }

    pay(value){
        const lastValue = this.value();
        $gameVariables.setValue(this._variableId, lastValue-value );
    }

}

/**
 * @returns {WalletBase}
 * @param {String} mode
 * @param {Number} id
 */
function makeWallet(mode,id){
    if(mode ==="item"){
        const wi = new WalletItem(id);
        return wi;
    }

    if(mode ==="variable"){
        const wv = new WalletVariable(id);
        return wv;
    }

    return new WalletGold();
}

let g_wallet =null;
const Game_Interpreter_pluginCommand=Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand =function(cmd,args){
    if(cmd ==="ShopMode"){
        const mode = args[0];
        const id = Number( args[1]);
        const unit =args[2];
        const wallet = makeWallet(mode,id);
        wallet.setUnit(unit);
        g_wallet =wallet;
        return;
    }
    Game_Interpreter_pluginCommand.call(this,cmd,args);
};

const Scene_Load_onLoadSuccess=Scene_Load.prototype.onLoadSuccess
Scene_Load.prototype.onLoadSuccess =function(){
    g_wallet=null;
    Scene_Load_onLoadSuccess.call(this);
};

Window_Gold.prototype.setupWallet =function(){
    const w = g_wallet || new WalletGold();
    this._wallet =w;
    g_wallet =null;
};
Window_Gold.prototype.value = function() {
    return this._wallet.value();
};

Window_Gold.prototype.currencyUnit = function() {
    return this._wallet.unit();
};
Window_Gold.prototype.wallet =function(){
    return this._wallet;
};

const Window_Gold_initialize =Window_Gold.prototype.initialize;
Window_Gold.prototype.initialize =function(x,y){
    this.setupWallet();
    Window_Gold_initialize.call(this,x,y);
};
const Scene_Shop_createGoldWindow =Scene_Shop.prototype.createGoldWindow;
Scene_Shop.prototype.createGoldWindow =function(){
    Scene_Shop_createGoldWindow.call(this);
    this._purchaseOnly =this._purchaseOnly || !this._goldWindow.wallet().canSeil();
};

Scene_Shop.prototype.doBuy = function(number) {
    this._goldWindow.wallet().loseValue(number * this.buyingPrice());
    $gameParty.gainItem(this._item, number);
};

Scene_Shop.prototype.doSell = function(number) {
    const p =number * this.sellingPrice();
    this._goldWindow.wallet().gainValue(p);
    $gameParty.loseItem(this._item, number);
};

})();


code:
/*:
 * @plugindesc ピクチャを利用してゲージを表示します。
 * @author しぐれん
 *
 * @param list
 * @desc 最もシンプルなゲージです。
 * 画像の幅を基準にします。
 * @type struct<GaugeVariable>[]
 * @default []
 *
 *
 * @help
 * 1.プラグインパラメータでゲージの設定を登録します。
 * 2.イベントコマンドでゲージとなるピクチャーを表示します。
 * 3.GAUGE_PICTURE ピクチャ番号 名前でゲージ扱いのパラメータを追加します。
 *
 * ゲージは伸縮タイプとスクロールタイプの2種類です。
 *
 * ピクチャの一部分を切り取ることでゲージとして使います。
 *
 * ピクチャの消去を行うと、関連付けられたデータが解除されます。
 * これによって再び普通のピクチャとして使えるようになります。
 *
 *
 * ■プラグインコマンド一覧
 * GAUGE_PICTURE ピクチャ番号 ゲージ名称
 * ピクチャに対してゲージ用の設定を取り付けます
 *
 * GAUGE_REMOVE ピクチャ番号
 * ゲージとピクチャの関連付けを解除します
*/

/*~struct~GaugeVariable:
 *
 * @param name
 * @text ゲージ識別子
 * @desc ゲージの名前です。
 * プラグインコマンドで使います。
 *
 * @param valueId
 * @text 変数番号(現在値)
 * @desc ゲージに使う数値の変数番号です。
 * @type variable
 * @default 0
 *
 * @param maxValueId
 * @text 変数番号(最大値)
 * @desc ゲージの最大値の変数番号です。
 * 変数の状態にかかわらず、数値は最低でも1です。
 * @type variable
 * @default 0
 *
 * @param maxWidth
 * @text ゲージの最大幅
 * @desc ここで指定した数値と画像の大きさの内、小さい値が使われます。
 * スクロールタイプの時に使います。
 * @type number
 * @default 12345
 *
 * @param maxHeight
 * @text ゲージの最大高さ
 * @desc ここで指定した数値と画像の大きさの内、小さい値が使われます。
 * スクロールタイプの時に使います。
 * @type number
 * @default 12345
 *
 * @param filter
 * @text ゲージの種類
 * @desc ゲージの動く方向を指定します。
 * leftとupでゲージがプルプルするのは修整不可です。
 * @type combo
 * @option right
 * @option left
 * @option up
 * @option down
 * @option ScrollLeft
 * @option ScrollUp
 * @default right
 */

(function(){
    'use strict';

class PictureSetting_V2{
    constructor(obj){
//        this.image=String(obj.image);
        this.valueId=Number(obj.valueId);
        this.maxValueId=Number(obj.maxValueId);
        this._filter =String(obj.filter);
        this.maxWidth =Number(obj.maxWidth);
        this.maxheight =Number(obj.maxHeight);
    }
    create(){
        const result = new GaugeValue_Variable();
        result.setValueId(this.valueId);
        result.setMaxValueId(this.maxValueId);
        result._setwidth(this.maxWidth);
        result._setHeight(this.maxheight);
        const filter = FilterFactory.create(this._filter)
        if(filter){
            result.setFilter(filter);
        }
        return result;
    }
}

/**
 * @param {String[]} textList
 */
function craeteGaugeImageMap(textList){
    /**
     * @type {Map<String,PictureSetting_V2>}
     */
    const result = new Map();
    for (const iterator of textList) {
        const obj =JSON.parse(iterator);
        const value = new PictureSetting_V2(obj);
        const key =obj.name;
        result.set(key,value);
    }
    return result;
}

function getParam(){ return PluginManager.parameters('Mano_Gauge');  }
const setting = (function(){
    const param =getParam();
    /**
     * @type {String[]}
     */
    const imageList=JSON.parse(param.list);
    const result ={
        imageMap:craeteGaugeImageMap(imageList),
    };
    return result;
})();

class GaugeManager_T{
    constructor(){

        /**
         * @type {GaugeValueBase[]}
         */
        this._list =[]
        /**
         * @type {Number[]}
         */
        this._reserved =[];
    }
    clear(){
        for (const iterator of this._list) {
            iterator.setSprite(null);
        }
        this._list.length=0;
        this._reserved.length=0;
    }
    /**
     * @param {Sprite} sprite
     */
    remove(sprite){
        for (let index = 0; index < this._list.length; index++) {
            const value = this._list[index];
            if(value.sprite ===sprite){
                value.setSprite(null);
                this._list.splice(index,1);
            }
        }
    }

    /**
     * @param {Sprite} sprite
     */
    add(sprite){
        /**
         * @type {String}
         */
        const name = sprite.gaugeName();
        if(name ===""){
            this.remove(sprite);
            return;
        }
        if(!sprite.bitmap){
            return;
        }

        const data= setting.imageMap.get(name);
        const gaugeValue = data.create();

        const _this=this;
        sprite.bitmap.addLoadListener(function(){
            gaugeValue.setSprite(sprite);
            _this._list.push(gaugeValue);
        });
    }
    update(){
        for (const iterator of this._list) {
            iterator.update();
        }

        for (let index = 0; index < this._list.length; index++) {
            const element = this._list[index];
            if(!element.sprite){
                this._list.splice(index,1);
            }
        }
    }
    /**
     * @param {Spriteset_Base} spriteset
     */
    bindSprite(spriteset){
        if(this._reserved.length >0){
            for (const iterator of this._reserved) {
                spriteset.bindGaugeAt(iterator);
            }
            this._reserved.length =0;
        }
    }
    /**
     * @param {Number} picutureid
     */
    reservePicuture(picutureid){
        this._reserved.push(picutureid);
    }
}

function onLoadOrNewGame() {
    GaugeManager.clear();
}

const DataManager_createGameObjects=DataManager.createGameObjects;
DataManager.createGameObjects=function() {
    DataManager_createGameObjects.call(this);
    onLoadOrNewGame();
};
const DataManager_extractSaveContents =DataManager.extractSaveContents;
DataManager.extractSaveContents = function(contents){
    DataManager_extractSaveContents.call(this,contents);
    onLoadOrNewGame();
};

class ReadOnly_GaugeValueBase{
    /**
     * @returns {Sprite}
     * @desc 所持しているSpriteを返す 実際の実行時には常にnullでないものを返す
     */
    get sprite(){
        return null;
    }
    get time(){
        return 0;
    }

    get value(){
        return 5;
    }
    get maxValue(){
        return 10;
    }
    get gaugeRate(){
        const m =Math.max(this.maxValue,1);
        return this.value/m;
    }
    get maxWidth(){
        return 1024;
    }
    get maxheight(){
        return 1024;
    }
    get bitmapWidth(){
        return 2048;
    }
    get bitmapHeight(){
        return 2048;
    }
}

class GaugeValueBase extends ReadOnly_GaugeValueBase{
    constructor(){
        super();
        this._setwidth(1024);
        this._setHeight(1024);
        this._timer=0;
        /**
         * @type {GaugeFilterBase[]}
         */
        this._filters=[];
        this.setFilter(null);
        this.setSprite(null);
    }
    /**
     * @param {GaugeFilterBase} filter
     */
    setFilter(filter){
        this._filter =filter;
    }

    get bitmapWidth(){
        return this._sprite.bitmap.width;
    }
    get bitmapHeight(){
        return this._sprite.bitmap.height;
    }

    get sprite(){
        return this._sprite;
    }

    get time(){
        return this._timer;
    }
    update(){
        if(this.name()===""){
            this.setSprite(null);
            return;
        }
        if(this._filter && this._sprite){
            const baseRect = new Rectangle(0,0,this.bitmapWidth,this.bitmapHeight);
            this._filter.update(this,baseRect);
            // for (const iterator of this._filters) {
            //     iterator.update(this,baseRect);
            // }
            this._sprite.setFrame(baseRect.x,baseRect.y,baseRect.width,baseRect.height);
        }
    }
    /**
     * @param {Number} w
     */
    _setwidth(w){
        this._width=w;
    }

    get maxWidth(){
        return this._width;
    }
    /**
     * @param {Number} h
     */
    _setHeight(h){
        this._height=h;
    }

    get maxheight(){
        return this._height;
    }
    /**
     * @param {Sprite} sprite
     */
    setSprite(sprite){
        this._sprite=sprite;
        if(sprite){
            if(sprite.bitmap){
                this._setwidth(Math.min(this._width , sprite.bitmap.width));
                this._setHeight(Math.min( this._height, sprite.bitmap.height));
            }
            this.onLoad();
        }
    }
    /**
     * @returns {String}
     */
    name(){
        if(this._sprite){
            return this._sprite.gaugeName();
        }
        return "";
    }
    onLoad(){}
}

class GaugeValue_Variable extends GaugeValueBase{
    constructor(){
        super();
        this.setValueId(0);
        this.setMaxValueId(0);
    }
    onLoad(){
        super.onLoad();
    }
    /**
     * @param {Number} id
     */
    setValueId(id){
        this._valueId =id;
    }
    /**
     * @param {Number} id
     */
    setMaxValueId(id){
        this._maxValueId =id;
    }
    get value(){
        return $gameVariables.value(this._valueId);
    }
    get maxValue(){
        return $gameVariables.value(this._maxValueId);
    }
}

class GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){}
}

class FilterFactory_T {
    constructor(){
        /**
         * @type {Map<String,()=>GaugeFilterBase}
         */
        this._map = new Map();
    }
    /**
     *
     * @param {String} key
     */
    create(key){
        const func = this._map.get(key);
        if(func){
            return func();
        }
        return null;
    }
    /**
     * @param {String} key
     * @param {()=> GaugeFilterBase} func
     */
    addFunction(key,func){
        this._map.set(key,func);
    }
    /**
     * @param {String} key
     * @param {typeof GaugeFilterBase} filterType
     */
    addClass(key,filterType){
        const filterMakeFunction =(function(){
            return new filterType();
        });
        this.addFunction(key,filterMakeFunction);
    }
}

const FilterFactory= new FilterFactory_T();

class GaugeFilter_Up extends GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){
        rect.height *= gaugeValue.gaugeRate;
        rect.y = gaugeValue.maxheight - rect.height;
        gaugeValue.sprite.y += rect.y;
    }
}
FilterFactory.addClass("up",GaugeFilter_Up);

class GaugeFilter_Down extends GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){
        rect.height *= gaugeValue.gaugeRate;
    }
}
FilterFactory.addClass("down",GaugeFilter_Down);

class GaugeFilter_Left extends GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){
        rect.width *= gaugeValue.gaugeRate;
        rect.x = gaugeValue.maxWidth - rect.width;
        gaugeValue.sprite.x += rect.x;
    }
}
FilterFactory.addClass("left",GaugeFilter_Left);

class GaugeFilter_Right extends GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){
        rect.width *= gaugeValue.gaugeRate;
    }
}
FilterFactory.addClass("right",GaugeFilter_Right);

class GaugeFilter_ScrollLeft extends GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){
        const x_Base= gaugeValue.bitmapWidth -gaugeValue.maxWidth;
        rect.x = x_Base *gaugeValue.gaugeRate;
        rect.width = gaugeValue.maxWidth;
    }
}
FilterFactory.addClass("ScrollLeft",GaugeFilter_ScrollLeft);
class GaugeFilter_ScrollUp extends GaugeFilterBase{
    /**
     * @param {ReadOnly_GaugeValueBase} gaugeValue
     * @param {Rectangle} rect
     */
    update(gaugeValue,rect){
        const y_Base= gaugeValue.bitmapHeight -gaugeValue.maxheight;

        rect.y = y_Base *gaugeValue.gaugeRate;  // Math.min(x_test,x_Max);
        rect.height = gaugeValue.maxheight;
    }
}
FilterFactory.addClass("ScrollUp",GaugeFilter_ScrollUp);

Sprite.prototype.gaugeName =function(){
    return "";
};
const Spriteset_Base_update=Spriteset_Base.prototype.update;
Spriteset_Base.prototype.update =function(){
    Spriteset_Base_update.call(this);
    GaugeManager.bindSprite(this);
    GaugeManager.update();
};
Spriteset_Base.prototype.bindGaugeAt =function(picutureid){
    const sprite= this._pictureContainer.getChildAt(picutureid-1);
    if(sprite ){
        sprite.bindGauge();
    }
}

const Spriteset_Base_createPictures=Spriteset_Base.prototype.createPictures;
Spriteset_Base.prototype.createPictures=function(){
    Spriteset_Base_createPictures.call(this);
    this.addListener("removed",function(){
        GaugeManager.clear();
    });
};
/**
 *  * @param {Number} id
 * @param {String} name
 */
function gaugePicture(id,name){
    const pic = $gameScreen.picture(id);
    if(!pic){return false;}

    const o=  setting.imageMap.get(name);
    if(o){
        pic.setGaugeName(name);
        GaugeManager.reservePicuture(id);
        return true;
    }
    return false;
}
/**
 * @param {Number} id
 */
function gaugeRemove(id){
    const pic = $gameScreen.picture(id);
    if(!pic){return false;}
    pic.setGaugeName("");
    GaugeManager.reservePicuture(id);
}

const Game_Interpreter_pluginCommand =Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function(cmd,args){

    if(cmd[0]!=='G'){
        Game_Interpreter_pluginCommand.call(this,cmd,args);
        return;
    }
    switch (cmd) {
        case "GAUGE_PICTURE":
            gaugePicture(Number(args[0]),args[1]);
            break;
        case "GAUGE_REMOVE":
            gaugeRemove(Number(args[0]));
            break;
        default:
            break;
    }
};

const GaugeManager = new GaugeManager_T();
/**
 * @param {String} name
 */
Game_Picture.prototype.setGaugeName =function(name){
    this._gaugeName=name;
};
Game_Picture.prototype.getGaugeName =function(){
    return this._gaugeName ||"";
};

Game_Picture.prototype.isGaugePicture_MA=function(){
    return !!(this._gaugeName );
};

Sprite_Picture.prototype.gaugeName =function(){
    const p = this.picture();
    if(p){
        return p.getGaugeName();
    }
    return "";
};
// const Sprite_Picture_initialize=Sprite_Picture.prototype.initialize;
// Sprite_Picture.prototype.initialize =function(picId){
//     Sprite_Picture_initialize.call(this,picId);
//     this.bindGauge();
// }

Sprite_Picture.prototype.bindGauge =function(){
    GaugeManager.add(this);
};
})();


code:
//=============================================================================
// MenuCommonEvent.js
// ----------------------------------------------------------------------------
// Copyright (c) 2015-2017 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.2.0 2017/12/24 公式ガチャプラグインと連携できるよう修正
// 1.1.3 2017/12/02 NobleMushroom.jsとの競合を解消
// 1.1.2 2017/11/18 コモンイベントを一切指定しない状態でメニューを開くとエラーになる現象を修正
// 1.1.1 2017/11/05 ヘルプとダウンロード先を追記
// 1.1.0 2017/11/05 タイマー有効化機能などいくつかの機能を追加
// 1.0.0 2017/11/04 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc MenuCommonEventPlugin
 * @author triacontane
 *
 * @param CommonEventInfo
 * @desc 各画面で実行するコモンイベントの情報です。
 * @default
 * @type struct<CommonEventInfo>[]
 *
 * @param MaxMenuPicture
 * @desc メニュー画面で表示するピクチャの最大数です。
 * @default 10
 * @type number
 * @min 1
 * @max 100
 *
 * @param SaveInterpreterIndex
 * @desc イベントの実行位置を記憶して別画面から戻ってきたときに記憶した位置から再開します。
 * @default false
 * @type boolean
 *
 * @param ActivateTimer
 * @desc メニュー画面中でもタイマーを表示し、かつタイマーを進めます。
 * @default false
 * @type boolean
 *
 * @param CommandPrefix
 * @desc プラグインコマンドおよびメモ欄の接頭辞です。コマンドやメモ欄が他プラグインと被る場合に指定してください。
 * @default
 *
 * @help MenuCommonEvent.js
 *
 * メニュー画面やプラグインで追加した画面(※1)でコモンイベントを並列実行できます。
 * メッセージやピクチャ、変数の操作などが各イベントコマンド(※2)が実行可能です。
 * コモンイベントは各画面につきひとつ実行できます。
 *
 * ※1 メニュー系の画面であれば利用できます。
 * サウンドテストプラグインや用語辞典プラグインとの連携は確認済みです。
 *
 * ※2 移動ルートの設定などキャラクターを対象にする一部コマンドは動作しません。
 * また、プラグインによって追加されたスクリプトやコマンドは正しく動作しない
 * 可能性があります。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * ウィンドウ操作禁止      # メニュー画面のウィンドウ操作を禁止します。
 * DISABLE_WINDOW_CONTROL  # 同上
 * ウィンドウ操作許可      # 禁止したメニュー画面のウィンドウ操作を許可します。
 * ENABLE_WINDOW_CONTROL   # 同上
 *
 * プラグインコメント名が他のプラグインと被っている場合はパラメータの
 * 「コマンド接頭辞」に値を設定してください。
 *
 * スクリプト詳細
 *  イベントコマンド「スクリプト」「変数の操作」から実行。
 *
 * // ウィンドウオブジェクトを取得
 * this.getSceneWindow(windowName);
 * 指定した名前のウィンドウオブジェクトを返します。
 * プロパティの取得や設定が可能です。上級者向け機能です。
 * 主要画面のウィンドウ名は以下の通りです。
 *
 * ・メインメニュー
 * commandWindow   コマンドウィンドウ
 * statusWindow    ステータスウィンドウ
 * goldWindow      お金ウィンドウ
 *
 * ・アイテム画面
 * categoryWindow  アイテムカテゴリウィンドウ
 * itemWindow      アイテムウィンドウ
 * actorWindow     アクター選択ウィンドウ
 *
 * ・スキル画面
 * skillTypeWindow スキルタイプウィンドウ
 * statusWindow    ステータスウィンドウ
 * itemWindow      スキルウィンドウ
 * actorWindow     アクター選択ウィンドウ
 *
 * ・装備画面
 * helpWindow      ヘルプウィンドウ
 * commandWindow   コマンドウィンドウ
 * slotWindow      スロットウィンドウ
 * statusWindow    ステータスウィンドウ
 * itemWindow      装備品ウィンドウ
 *
 * ・ステータス画面
 * statusWindow    ステータスウィンドウ
 *
 * // ウィンドウアクティブ判定
 * this.isWindowActive(windowName);
 * 指定した名前のウィンドウがアクティブなときにtrueを返します。
 * ウィンドウの指定例は上と同じです。
 *
 * // ウィンドウインデックス取得
 * this.getSceneWindowIndex();
 * 現在アクティブなウィンドウのインデックスを取得します。先頭は0です。
 *
 * // 選択中のアクターオブジェクト取得
 * $gameParty.menuActor();
 * 装備画面やステータス画面で選択中のアクターの情報を取得します。
 * 上級者向けスクリプトです。(※1)
 *
 * // 選択中のアクターID取得
 * $gameParty.menuActor().actorId();
 * 装備画面やステータス画面で選択中のアクターIDを取得します。
 *
 * ※1 既存のコアスクリプトですが、有用に使えるため記載しています。
 *
 * // 用語辞典の表示内容更新
 * this.refreshGlossary();
 * 用語辞典プラグインにおいて用語の表示内容を最新にします。
 * 同プラグインと連携した場合に使用します。
 *
 * 〇他のプラグインとの連携
 * ピクチャのボタン化プラグイン（PictureCallCommon.js）と併用する場合
 * コマンドは「P_CALL_CE」ではなく「P_CALL_SWITCH」を使ってください。
 *
 * プラグインURL
 * https://raw.githubusercontent.com/triacontane/RPGMakerMV/master/MenuCommonEvent.js
 *
 * ヘルプURL
 * https://github.com/triacontane/RPGMakerMV/blob/master/ReadMe/MenuCommonEvent.md
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~CommonEventInfo:
 *
 * @param SceneName
 * @desc コモンイベント実行対象の画面です。独自に追加した画面を対象にする場合はクラス名を直接入力してください。
 * @type select
 * @default
 * @option メインメニュー
 * @value Scene_Menu
 * @option アイテム
 * @value Scene_Item
 * @option スキル
 * @value Scene_Skill
 * @option 装備
 * @value Scene_Equip
 * @option ステータス
 * @value Scene_Status
 * @option オプション
 * @value Scene_Options
 * @option セーブ
 * @value Scene_Save
 * @option ロード
 * @value Scene_Load
 * @option ゲーム終了
 * @value Scene_End
 * @option ショップ
 * @value Scene_Shop
 * @option 名前入力
 * @value Scene_Name
 * @option デバッグ
 * @value Scene_Debug
 * @option サウンドテスト
 * @value Scene_SoundTest
 * @option 用語辞典
 * @value Scene_Glossary
 *
 * @param CommonEventId
 * @desc 画面で並列実行するコモンイベントのIDです。トリガーを並列実行にする必要はなく、スイッチも参照されません。
 * @default 1
 * @type common_event
 *
 */
/*:ja
 * @plugindesc メニュー内コモンイベントプラグイン
 * @author トリアコンタン
 *
 * @param コモンイベント情報
 * @desc 各画面で実行するコモンイベントの情報です。
 * @default
 * @type struct<CommonEventInfo>[]
 *
 * @param ピクチャ表示最大数
 * @desc メニュー画面で表示するピクチャの最大数です。
 * @default 10
 * @type number
 * @min 1
 * @max 100
 *
 * @param 実行位置を記憶
 * @desc イベントの実行位置を記憶して別画面から戻ってきたときに記憶した位置から再開します。
 * @default false
 * @type boolean
 *
 * @param タイマー有効化
 * @desc メニュー画面中でもタイマーを表示し、かつタイマーを進めます。
 * @default false
 * @type boolean
 *
 * @param コマンド接頭辞
 * @desc プラグインコマンドおよびメモ欄の接頭辞です。コマンドやメモ欄が他プラグインと被る場合に指定してください。
 * @default
 *
 * @help MenuCommonEvent.js
 *
 * メニュー画面やプラグインで追加した画面(※1)でコモンイベントを並列実行できます。
 * メッセージやピクチャ、変数の操作などが各イベントコマンド(※2)が実行可能です。
 * コモンイベントは各画面につきひとつ実行できます。
 *
 * ※1 メニュー系の画面であれば利用できます。
 * サウンドテストプラグインや用語辞典プラグインとの連携は確認済みです。
 *
 * ※2 移動ルートの設定などキャラクターを対象にする一部コマンドは動作しません。
 * また、プラグインによって追加されたスクリプトやコマンドは正しく動作しない
 * 可能性があります。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * ウィンドウ操作禁止      # メニュー画面のウィンドウ操作を禁止します。
 * DISABLE_WINDOW_CONTROL  # 同上
 * ウィンドウ操作許可      # 禁止したメニュー画面のウィンドウ操作を許可します。
 * ENABLE_WINDOW_CONTROL   # 同上
 *
 * プラグインコメント名が他のプラグインと被っている場合はパラメータの
 * 「コマンド接頭辞」に値を設定してください。
 *
 * スクリプト詳細
 *  イベントコマンド「スクリプト」「変数の操作」から実行。
 *
 * // ウィンドウオブジェクトを取得
 * this.getSceneWindow(windowName);
 * 指定した名前のウィンドウオブジェクトを返します。
 * プロパティの取得や設定が可能です。上級者向け機能です。
 * 主要画面のウィンドウ名は以下の通りです。
 *
 * ・メインメニュー
 * commandWindow   コマンドウィンドウ
 * statusWindow    ステータスウィンドウ
 * goldWindow      お金ウィンドウ
 *
 * ・アイテム画面
 * categoryWindow  アイテムカテゴリウィンドウ
 * itemWindow      アイテムウィンドウ
 * actorWindow     アクター選択ウィンドウ
 *
 * ・スキル画面
 * skillTypeWindow スキルタイプウィンドウ
 * statusWindow    ステータスウィンドウ
 * itemWindow      スキルウィンドウ
 * actorWindow     アクター選択ウィンドウ
 *
 * ・装備画面
 * helpWindow      ヘルプウィンドウ
 * commandWindow   コマンドウィンドウ
 * slotWindow      スロットウィンドウ
 * statusWindow    ステータスウィンドウ
 * itemWindow      装備品ウィンドウ
 *
 * ・ステータス画面
 * statusWindow    ステータスウィンドウ
 *
 * // ウィンドウアクティブ判定
 * this.isWindowActive(windowName);
 * 指定した名前のウィンドウがアクティブなときにtrueを返します。
 * ウィンドウの指定例は上と同じです。
 *
 * // ウィンドウインデックス取得
 * this.getSceneWindowIndex();
 * 現在アクティブなウィンドウのインデックスを取得します。先頭は0です。
 *
 * // 選択中のアクターオブジェクト取得
 * $gameParty.menuActor();
 * 装備画面やステータス画面で選択中のアクターの情報を取得します。
 * 上級者向けスクリプトです。(※1)
 *
 * // 選択中のアクターID取得
 * $gameParty.menuActor().actorId();
 * 装備画面やステータス画面で選択中のアクターIDを取得します。
 *
 * ※1 既存のコアスクリプトですが、有用に使えるため記載しています。
 *
 * // 用語辞典の表示内容更新
 * this.refreshGlossary();
 * 用語辞典プラグインにおいて用語の表示内容を最新にします。
 * 同プラグインと連携した場合に使用します。
 *
 * 〇他のプラグインとの連携
 * ピクチャのボタン化プラグイン（PictureCallCommon.js）と併用する場合
 * コマンドは「P_CALL_CE」ではなく「P_CALL_SWITCH」を使ってください。
 *
 * プラグインURL
 * https://raw.githubusercontent.com/triacontane/RPGMakerMV/master/MenuCommonEvent.js
 *
 * ヘルプURL
 * https://github.com/triacontane/RPGMakerMV/blob/master/ReadMe/MenuCommonEvent.md
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~CommonEventInfo:ja
 *
 * @param SceneName
 * @desc コモンイベント実行対象の画面です。独自に追加した画面を対象にする場合はクラス名を直接入力してください。
 * @type select
 * @default
 * @option メインメニュー
 * @value Scene_Menu
 * @option アイテム
 * @value Scene_Item
 * @option スキル
 * @value Scene_Skill
 * @option 装備
 * @value Scene_Equip
 * @option ステータス
 * @value Scene_Status
 * @option オプション
 * @value Scene_Options
 * @option セーブ
 * @value Scene_Save
 * @option ロード
 * @value Scene_Load
 * @option ゲーム終了
 * @value Scene_End
 * @option ショップ
 * @value Scene_Shop
 * @option 名前入力
 * @value Scene_Name
 * @option デバッグ
 * @value Scene_Debug
 * @option サウンドテスト
 * @value Scene_SoundTest
 * @option 用語辞典
 * @value Scene_Glossary
 * @option 公式ガチャ
 * @value Scene_Gacha
 *
 * @param CommonEventId
 * @desc 画面で並列実行するコモンイベントのIDです。トリガーを並列実行にする必要はなく、スイッチも参照されません。
 * @default 1
 * @type common_event
 *
 */

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

    //=============================================================================
    // ローカル関数
    //  プラグインパラメータやプラグインコマンドパラメータの整形やチェックをします
    //=============================================================================
    var getParamString = function(paramNames) {
        if (!Array.isArray(paramNames)) paramNames = [paramNames];
        for (var i = 0; i < paramNames.length; i++) {
            var name = PluginManager.parameters(pluginName)[paramNames[i]];
            if (name !== undefined) return name;
        }
        return '';
    };

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

    var getParamBoolean = function(paramNames) {
        var value = getParamString(paramNames);
        return value.toUpperCase() === 'TRUE';
    };

    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:.js\nName:[]\nValue:`);
            value = defaultValue;
        }
        return value;
    };

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

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

    var convertAllArguments = function(args) {
        return args.map(function(arg) {
            return convertEscapeCharacters(arg);
        })
    };

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

    var getClassName = function(object) {
        return object.constructor.toString().replace(/function\s+(.*)\s*\([\s\S]*/m, '$1');
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var param                  = {};
    param.commonEventInfo      = getParamArrayJson(['CommonEventInfo', 'コモンイベント情報'], []);
    param.commandPrefix        = getParamString(['CommandPrefix', 'コマンド接頭辞']);
    param.maxMenuPicture       = getParamNumber(['MaxMenuPicture', 'ピクチャ表示最大数'], 1);
    param.saveInterpreterIndex = getParamBoolean(['SaveInterpreterIndex', '実行位置を記憶']);
    param.activateTimer        = getParamBoolean(['ActivateTimer', 'タイマー有効化']);

    var pluginCommandMap = new Map();
    setPluginCommand('ウィンドウ操作禁止', 'execDisableWindowControl');
    setPluginCommand('DISABLE_WINDOW_CONTROL', 'execDisableWindowControl');
    setPluginCommand('ウィンドウ操作許可', 'execEnableWindowControl');
    setPluginCommand('ENABLE_WINDOW_CONTROL', 'execEnableWindowControl');

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

    Game_Interpreter.prototype.execDisableWindowControl = function() {
        $gameTemp.setDisableWindowControl(true);
    };

    Game_Interpreter.prototype.execEnableWindowControl = function() {
        $gameTemp.setDisableWindowControl(false);
    };

    Game_Interpreter.prototype.isWindowActive = function(windowName) {
        var sceneWindow = this.getSceneWindow(windowName);
        return sceneWindow ? sceneWindow.active : false;
    };

    Game_Interpreter.prototype.getSceneWindow = function(windowName) {
        return SceneManager.getSceneWindow('_' + windowName);
    };

    Game_Interpreter.prototype.getSceneWindowIndex = function() {
        var index = -1;
        SceneManager.getSceneWindowList().some(function(sceneWindow) {
            if (sceneWindow instanceof Window_Selectable && sceneWindow.active) {
                index = sceneWindow.index();
                return true;
            } else {
                return false;
            }
        });
        return index;
    };

    Game_Interpreter.prototype.refreshGlossary = function() {
        var glossaryWindow = this.getSceneWindow('glossaryWindow');
        if (glossaryWindow.visible) {
            var glossaryListWindow = this.getSceneWindow('glossaryListWindow');
            glossaryWindow.refresh(glossaryListWindow.item());
        }
    };

    //=============================================================================
    // Game_Temp
    //  メニューコモンイベントを作成、更新します。
    //=============================================================================
    var _Game_Temp_initialize      = Game_Temp.prototype.initialize;
    Game_Temp.prototype.initialize = function() {
        _Game_Temp_initialize.apply(this, arguments);
        this._menuCommonEvent = {};
        this.clearSceneInformation();
    };

    Game_Temp.prototype.setupMenuCommonEvent = function(commonEventId, sceneName, sceneIndex) {
        this._sceneName  = sceneName;
        this._sceneIndex = sceneIndex;
        if (param.saveInterpreterIndex && this.isExistSameCommonEvent(commonEventId)) {
            return this._menuCommonEvent[sceneName];
        }
        return this._menuCommonEvent[sceneName] = this.createMenuCommonEvent(commonEventId);
    };

    Game_Temp.prototype.createMenuCommonEvent = function(commonEventId) {
        if (commonEventId > 0) {
            var commonEvent = new Game_MenuCommonEvent(commonEventId);
            if (commonEvent.event()) {
                return commonEvent
            }
        }
        return null;
    };

    Game_Temp.prototype.isExistSameCommonEvent = function(commonEventId) {
        var commonEvent = this._menuCommonEvent[this._sceneName];
        return commonEvent && commonEvent.isSameEvent(commonEventId);
    };

    Game_Temp.prototype.setDisableWindowControl = function(value) {
        this._disableWindowControl = value;
    };

    Game_Temp.prototype.isDisableWindowControl = function() {
        return !!this._disableWindowControl;
    };

    Game_Temp.prototype.getSceneIndex = function() {
        return this._sceneIndex;
    };

    Game_Temp.prototype.isInMenu = function() {
        return this.getSceneIndex() >= 0
    };

    Game_Temp.prototype.clearSceneInformation = function() {
        this._sceneIndex = -1;
        this._sceneName  = '';
    };

    //=============================================================================
    // Game_Screen
    //  シーンごとにピクチャを管理できるようにします。
    //=============================================================================
    if (param.maxMenuPicture > 0) {
        var _Game_Screen_realPictureId      = Game_Screen.prototype.realPictureId;
        Game_Screen.prototype.realPictureId = function(pictureId) {
            var sceneIndex = $gameTemp.getSceneIndex();
            if (sceneIndex >= 0) {
                return pictureId + this.maxMapPictures() * 2 + sceneIndex * this.maxPictures();
            } else {
                return _Game_Screen_realPictureId.apply(this, arguments);
            }
        };

        var _Game_Screen_maxPictures      = Game_Screen.prototype.maxPictures;
        Game_Screen.prototype.maxPictures = function() {
            return $gameTemp.isInMenu() ? param.maxMenuPicture : _Game_Screen_maxPictures.apply(this, arguments);
        };

        Game_Screen.prototype.maxMapPictures = function() {
            return _Game_Screen_maxPictures.apply(this, arguments);
        };
    }

    //=============================================================================
    // Game_MenuCommonEvent
    //  メニューコモンイベントを扱うクラスです。
    //=============================================================================
    function Game_MenuCommonEvent() {
        this.initialize.apply(this, arguments);
    }

    Game_MenuCommonEvent.prototype             = Object.create(Game_CommonEvent.prototype);
    Game_MenuCommonEvent.prototype.constructor = Game_MenuCommonEvent;

    Game_MenuCommonEvent.prototype.isActive = function() {
        return true;
    };

    Game_MenuCommonEvent.prototype.isSameEvent = function(commonEventId) {
        return this._commonEventId === commonEventId;
    };

    var _Game_MenuCommonEvent_update      = Game_MenuCommonEvent.prototype.update;
    Game_MenuCommonEvent.prototype.update = function() {
        if (this._interpreter && !this._interpreter.isRunning()) {
            this._interpreter.execEnableWindowControl();
        }
        _Game_MenuCommonEvent_update.apply(this, arguments);
    };

    //=============================================================================
    // Scene_MenuBase
    //  メニューコモンイベントを実行します。
    //=============================================================================
    var _Scene_MenuBase_create      = Scene_MenuBase.prototype.create;
    Scene_MenuBase.prototype.create = function() {
        _Scene_MenuBase_create.apply(this, arguments);
        this.createCommonEvent();
    };

    Scene_MenuBase.prototype.createCommonEvent = function() {
        this.setupCommonEvent();
        if (!this.hasCommonEvent()) {
            return;
        }
        this.createSpriteset();
        if (!this._messageWindow) {
            this.createMessageWindow();
        }
        this.changeParentMessageWindow();
    };

    Scene_MenuBase.prototype.hasCommonEvent = function() {
        return !!this._commonEvent;
    };

    Scene_MenuBase.prototype.createMessageWindow = function() {
        Scene_Map.prototype.createMessageWindow.call(this);
    };

    Scene_MenuBase.prototype.changeParentMessageWindow = function() {
        this._windowLayer.removeChild(this._messageWindow);
        this.addChild(this._messageWindow);
    };

    // Resolve conflict for NobleMushroom.js
    Scene_MenuBase.prototype.changeImplementationWindowMessage  = Scene_Map.prototype.changeImplementationWindowMessage;
    Scene_MenuBase.prototype.restoreImplementationWindowMessage = Scene_Map.prototype.restoreImplementationWindowMessage;
    Scene_MenuBase.prototype.onPause                            = Scene_Map.prototype.onPause;
    Scene_MenuBase.prototype.offPause                           = Scene_Map.prototype.offPause;

    Scene_MenuBase.prototype.createSpriteset = function() {
        this._spriteset = new Spriteset_Menu();
        this.addChild(this._spriteset);
    };

    Scene_MenuBase.prototype.setupCommonEvent = function() {
        var commonEventItem = this.getCommonEventData();
        var commonEventId   = commonEventItem ? parseInt(commonEventItem['CommonEventId']) : 0;
        var sceneIndex      = param.commonEventInfo.indexOf(commonEventItem);
        this._commonEvent   = $gameTemp.setupMenuCommonEvent(commonEventId, this._sceneName, sceneIndex);
    };

    Scene_MenuBase.prototype.getCommonEventData = function() {
        this._sceneName = getClassName(this);
        return param.commonEventInfo.filter(function(data) {
            return data['SceneName'] === this._sceneName;
        }, this)[0];
    };

    var _Scene_MenuBase_updateChildren      = Scene_MenuBase.prototype.updateChildren;
    Scene_MenuBase.prototype.updateChildren = function() {
        if (this.hasCommonEvent()) {
            this.children.forEach(function(child) {
                if (child.update && !this.isStopWindow(child)) {
                    child.update();
                }
            }, this);
        } else {
            _Scene_MenuBase_updateChildren.apply(this, arguments);
        }
    };

    Scene_MenuBase.prototype.isStopWindow = function(child) {
        return child === this._windowLayer && ($gameTemp.isDisableWindowControl() || $gameMessage.isBusy());
    };

    Scene_MenuBase.prototype.updateCommonEvent = function() {
        if (!this.hasCommonEvent()) {
            return;
        }
        this._commonEvent.update();
        $gameScreen.update();
        if (param.activateTimer) {
            $gameTimer.update(true);
        }
        this.checkGameover();
        this.updateTouchPicturesIfNeed();
    };

    /**
     * updateTouchPicturesIfNeed
     * for PictureCallCommon.js
     */
    Scene_MenuBase.prototype.updateTouchPicturesIfNeed = function() {
        if (this.updateTouchPictures && param.maxMenuPicture > 0) {
            this.updateTouchPictures();
        }
    };

    //=============================================================================
    // Scene_Base
    //  メニューコモンイベントを更新します。
    //=============================================================================
    var _Scene_Base_update      = Scene_Base.prototype.update;
    Scene_Base.prototype.update = function() {
        this.updateCommonEvent();
        _Scene_Base_update.apply(this, arguments);
    };

    Scene_Base.prototype.updateCommonEvent = function() {
        // do nothing
    };

    var _Scene_Base_terminate      = Scene_Base.prototype.terminate;
    Scene_Base.prototype.terminate = function() {
        _Scene_Base_terminate.apply(this, arguments);
        if ($gameTemp) {
            $gameTemp.clearSceneInformation();
        }
    };

    //=============================================================================
    // Spriteset_Menu
    //  メニュー画面用のスプライトセットです。
    //=============================================================================
    function Spriteset_Menu() {
        this.initialize.apply(this, arguments);
    }

    Spriteset_Menu.prototype             = Object.create(Spriteset_Base.prototype);
    Spriteset_Menu.prototype.constructor = Spriteset_Menu;

    var _Spriteset_Menu_createBaseSprite      = Spriteset_Menu.prototype.createBaseSprite;
    Spriteset_Menu.prototype.createBaseSprite = function() {
        _Spriteset_Menu_createBaseSprite.apply(this, arguments);
        this._blackScreen.opacity = 0;
    };

    var _Spriteset_Menu_createTimer      = Spriteset_Menu.prototype.createTimer;
    Spriteset_Menu.prototype.createTimer = function() {
        if (param.activateTimer) {
            _Spriteset_Menu_createTimer.apply(this, arguments);
        }
    };

    //=============================================================================
    // SceneManager
    //  ウィンドウオブジェクトを取得します。
    //=============================================================================
    SceneManager.getSceneWindow = function(windowName) {
        var sceneWindow = this._scene[windowName];
        return sceneWindow instanceof Window ? sceneWindow : null;
    };

    SceneManager.getSceneWindowList = function() {
        var windowList = [];
        for (var sceneWindow in this._scene) {
            if (this._scene.hasOwnProperty(sceneWindow) && this._scene[sceneWindow] instanceof Window) {
                windowList.push(this._scene[sceneWindow]);
            }
        }
        return windowList;
    };
})();