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

/*:
 * @target MV MZ
 * @plugindesc Allows you to set the brightness of the map.
 * @author Mokusei Penguin
 * @url
 *
 * @help [version 3.1.1]
 * This plugin is for RPG Maker MV and MZ.
 *
 * ▼ Plugin command
 *  - In MV, the variable N is referred to by writing v [N] in the item for
 *    inputting a numerical value.
 *  - In MZ, in the item to enter a numerical value, select the text and
 *    write v [N] to refer to the variable N.
 *  - For the color index (c), specify the one set in the plug-in parameter
 *    [Light Colors].
 *
 *  〇 MV / MZ
 *
 *  〇 SetCharLight evId r c a  / setCharLight
 *      evId : -1:Player, 0:This event, 1..:EventID
 *      r    : radius(1 = 1 square)
 *      c    : color index(Erase with 0)
 *      a    : amplitude(Specify from 0-100 / No blinking at 0 / Not set is 0)
 *   - The light is displayed around the character.
 *
 *  〇 SetPosLight x y r c a  / setPosLight
 *      x   : X coordinate
 *      y   : Y coordinate
 *      r   : radius(1 = 1 square)
 *      c   : color index(Erase with 0)
 *      a   : amplitude(Specify from 0-100 / No blinking at 0 / Not set is 0)
 *   - Lights up at the specified coordinates (x, y).
 *
 *  〇 SetFrontLight evId r c a  / setFrontLight
 *      evId : -1:Player, 0:This event, 1..:EventID
 *      c    : color index(Erase with 0)
 *      a    : amplitude(Specify from 0-100 / No blinking at 0 / Not set is 0)
 *   - A light is displayed in front of the character.
 *
 *  〇 EraseCharLight lId  / eraseCharLight
 *      evId : -1:Player, 0:This event, 1..:EventID
 *   - Turns off the lights centered on the character.
 *
 *  〇 ErasePosLight x y  / erasePosLight
 *      x   : X coordinate
 *      y   : Y coordinate
 *   - Turns off the light at the specified coordinates (x, y).
 *
 *  〇 EraseFrontLight lId  / eraseFrontLight
 *      evId : -1:Player, 0:This event, 1..:EventID
 *   - Turns off the light that illuminates the front of the character.
 *
 *  〇 SetMapDarkness d  / setDarkness
 *      d : Map darkness(Specify from 0-100)
 *   - Change the darkness of the map.
 *
 * ▼ Map notes
 *  〇 <Darkness:n>
 *      n : Map darkness(Specify from 0-100)
 *   - Specifies the darkness of the map.
 *   - By writing v[n], the value of the nth variable is referenced.
 *   - However, it is only referenced when you switch maps.
 *
 *  〇 <PosLight X,Y:r,c,a>
 *      X   : X coordinate
 *      Y   : Y coordinate
 *      r   : radius(1 = 1 square)
 *      c   : color index
 *      a   : amplitude(Specify from 0-100 / No blinking at 0 / Not set is 0)
 *   - Places the light at the specified coordinates (x, y).
 *
 * ▼ Annotation of event execution content
 *  〇 CharLight r c a
 *      r   : radius(1 = 1 square)
 *      c   : color index
 *      a   : amplitude(Specify from 0-100 / No blinking at 0 / Not set is 0)
 *   - Lights are displayed around this event.
 *   - This command applies only to the first annotation of the execution.
 *
 * ================================
 * Mail : wood_penguin＠yahoo.co.jp (＠ is half-width)
 * Blog : http://woodpenguin.blog.fc2.com/
 * License : MIT license
 *
 *  @command setCharLight
 *      @desc
 *      @arg character
 *          @desc -1:Player, 0:This event, 1..:EventID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *      @arg radius
 *          @desc 1 = 1 square
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg colorIndex
 *          @desc
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg amplitude
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 0
 *
 *  @command setPosLight
 *      @desc
 *      @arg x
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *      @arg y
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *      @arg radius
 *          @desc 1 = 1 square
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg colorIndex
 *          @desc
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg amplitude
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 0
 *
 *  @command setFrontLight
 *      @desc
 *      @arg character
 *          @desc -1:Player, 0:This event, 1..:EventID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *      @arg colorIndex
 *          @desc
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg amplitude
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 0
 *
 *  @command eraseCharLight
 *      @desc
 *      @arg character
 *          @desc -1:Player, 0:This event, 1..:EventID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *
 *  @command erasePosLight
 *      @desc
 *      @arg x
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *      @arg y
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *
 *  @command eraseFrontLight
 *      @desc
 *      @arg character
 *          @desc -1:Player, 0:This event, 1..:EventID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *
 *  @command setDarkness
 *      @desc
 *      @arg darkness
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 100
 *
 *
 *  @param Light Colors
 *      @desc
 *      @type string[]
 *      @default ["255,255,255","192,128,64","32,32,32"]
 *
 *  @param Front Light
 *      @desc
 *      @type struct<FrontLight>
 *      @default {"Radius":"6","Angle":"90","Oy":"4","Turn Duration":"24"}
 *
 *  @param Darkness Size
 *      @desc Resolution per tile
 *      @type number
 *          @min 1
 *          @max 48
 *      @default 3
 *
 */

/*~struct~FrontLight:
 *  @param Radius
 *      @desc
 *      @type number
 *          @min 1
 *          @max 99
 *      @default 6
 *
 *  @param Angle
 *      @desc
 *      @type number
 *          @min 1
 *          @max 180
 *      @default 90
 *
 *  @param Oy
 *      @desc
 *      @type number
 *          @min -9999
 *          @max 9999
 *      @default 4
 *
 *  @param Turn Duration
 *      @desc
 *      @type number
 *          @min 0
 *          @max 999
 *      @default 24
 *
 */

/*:ja
 * @target MV MZ
 * @plugindesc マップの明るさを設定できるようにします。
 * @author 木星ペンギン
 * @url
 *
 * @help [version 3.1.1]
 * このプラグインはRPGツクールMVおよびMZ用です。
 *
 * ▼ プラグインコマンド
 *  - MVでは数値を入力する項目で v[N] と記述することで変数N番を参照します。
 *  - MZでは数値を入力する項目で、テキストを選択して v[N] と記述することで
 *    変数N番を参照します。
 *  - 色番号(c)はプラグインパラメータ[Light Colors]で設定したものを指定してください。
 *
 *  〇 MV / MZ
 *
 *  〇 SetCharLight evId r c a  / キャラ灯り設定
 *      evId : イベントID(-1:プレイヤー, 0:このイベント)
 *      r    : 半径(1で1マス分)
 *      c    : 色番号(0で消去)
 *      a    : 明滅の振れ幅(0～100で指定 / 0で明滅なし / 未設定は0)
 *   - キャラクターを中心に灯りを表示します。
 *
 *  〇 SetPosLight x y r c a  / マップ灯り設定
 *      x   : X座標
 *      y   : Y座標
 *      r   : 半径(1で1マス分)
 *      c   : 色番号(0で消去)
 *      a   : 明滅の振れ幅(0～100で指定 / 0で明滅なし / 未設定は0)
 *   - 指定した座標(x,y)に灯り表示します。
 *
 *  〇 SetFrontLight evId r c a  / 前方灯り設定
 *      evId : イベントID(-1:プレイヤー, 0:このイベント)
 *      c    : 色番号(0で消去)
 *      a    : 明滅の振れ幅(0～100で指定 / 0で明滅なし / 未設定は0)
 *   - キャラクターの前方に灯りを表示します。
 *
 *  〇 EraseCharLight lId  / キャラ灯り消去
 *      evId : イベントID(-1:プレイヤー, 0:このイベント)
 *   - キャラクターを中心とした灯りを消去します。
 *
 *  〇 ErasePosLight x y  / マップ灯り消去
 *      x   : X座標
 *      y   : Y座標
 *   - 指定した座標(x,y)の灯りを消去します。
 *
 *  〇 EraseFrontLight lId  / 前方灯り消去
 *      evId : イベントID(-1:プレイヤー, 0:このイベント)
 *   - キャラクターの前方を照らす灯りを消去します。
 *
 *  〇 SetMapDarkness d  / マップ暗さ設定
 *      d : マップの暗さ(0～100で指定)
 *   - マップの暗さを変更します。
 *
 * ▼ マップのメモ
 *  〇 <Darkness:n>
 *      n : マップの暗さ(0～100で指定)
 *   - マップの暗さを指定します。
 *   - v[n] と記述することでn番の変数の値を参照します。
 *   - ただし、参照されるのはマップの切り替えを行ったときのみです。
 *
 *  〇 <PosLight X,Y:r,c,a>
 *      X   : X座標
 *      Y   : Y座標
 *      r   : 半径(1で1マス分)
 *      c   : 色番号
 *      a   : 明滅の振れ幅(0～100で指定 / 0で明滅なし / 未設定は0)
 *   - 指定した座標(x,y)に灯りを配置します。
 *
 * ▼ イベントの実行内容の注釈
 *  〇 灯り r c a
 *      r   : 半径(1で1マス分)
 *      c   : 色番号
 *      a   : 明滅の振れ幅(0～100で指定 / 0で明滅なし / 未設定は0)
 *   - このイベントを中心に灯りを表示します。
 *   - このコマンドは実行内容の最初の注釈のみ適用されます。
 *
 * ================================
 * Mail : wood_penguin＠yahoo.co.jp (＠は半角)
 * Blog : http://woodpenguin.blog.fc2.com/
 * License : MIT license
 *
 *  @command setCharLight
 *      @text キャラ灯り設定
 *      @desc
 *      @arg character
 *          @text 対象キャラクター
 *          @desc -1:プレイヤー, 0:このイベント, 1..:イベントID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *      @arg radius
 *          @text 半径
 *          @desc 1 = 1マス
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg colorIndex
 *          @text 色番号
 *          @desc
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg amplitude
 *          @text 明滅の振れ幅
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 0
 *
 *  @command setPosLight
 *      @text マップ灯り設定
 *      @desc
 *      @arg x
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *      @arg y
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *      @arg radius
 *          @text 半径
 *          @desc 1 = 1マス
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg colorIndex
 *          @text 色番号
 *          @desc
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg amplitude
 *          @text 明滅の振れ幅
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 0
 *
 *  @command setFrontLight
 *      @text 前方灯り設定
 *      @desc
 *      @arg character
 *          @text 対象キャラクター
 *          @desc -1:プレイヤー, 0:このイベント, 1..:イベントID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *      @arg colorIndex
 *          @text 色番号
 *          @desc
 *          @type number
 *              @min 0
 *              @max 99
 *          @default 1
 *      @arg amplitude
 *          @text 明滅の振れ幅
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 0
 *
 *  @command eraseCharLight
 *      @text キャラ灯り消去
 *      @desc
 *      @arg character
 *          @text 対象キャラクター
 *          @desc -1:プレイヤー, 0:このイベント, 1..:イベントID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *
 *  @command erasePosLight
 *      @text マップ灯り消去
 *      @desc
 *      @arg x
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *      @arg y
 *          @desc
 *          @type number
 *              @min -9999
 *              @max 9999
 *          @default 0
 *
 *  @command eraseFrontLight
 *      @text 前方灯り消去
 *      @desc
 *      @arg character
 *          @text 対象キャラクター
 *          @desc -1:プレイヤー, 0:このイベント, 1..:イベントID
 *          @type number
 *              @min -1
 *              @max 999
 *          @default 0
 *
 *  @command setDarkness
 *      @text マップ暗さ設定
 *      @desc
 *      @arg darkness
 *          @desc
 *          @type number
 *              @min 0
 *              @max 100
 *          @default 100
 *
 *
 *  @param Light Colors
 *      @text 灯りの色の配列
 *      @desc
 *      @type string[]
 *      @default ["255,255,255","192,128,64","32,32,32"]
 *
 *  @param Front Light
 *      @text 前方灯りパラメータ
 *      @desc
 *      @type struct<FrontLight>
 *      @default {"Radius":"6","Angle":"90","Oy":"4","Turn Duration":"24"}
 *
 *  @param Darkness Size
 *      @text 暗さの解像度
 *      @desc 1タイル当たりの解像度
 *      @type number
 *          @min 1
 *          @max 48
 *      @default 3
 *
 */

/*~struct~FrontLight:ja
 *  @param Radius
 *      @text 距離
 *      @desc
 *      @type number
 *          @min 1
 *          @max 99
 *      @default 6
 *
 *   @param Angle
 *      @text 角度
 *      @desc
 *      @type number
 *          @min 1
 *          @max 180
 *      @default 90
 *
 *  @param Oy
 *      @text 原点Y
 *      @desc
 *      @type number
 *          @min -9999
 *          @max 9999
 *      @default 4
 *
 *  @param Turn Duration
 *      @text 回転時間
 *      @desc
 *      @type number
 *          @min 0
 *          @max 999
 *      @default 24
 *
 */

(() => {
    'use strict';

    const pluginName = 'MPP_MapLight';

    // Plugin Parameters
    const parameters = PluginManager.parameters(pluginName);
    const paramReplace = (key, value) => {
        try {
            return JSON.parse(value);
        } catch (e) {
            return value;
        }
    };
    const param_LightColors = JSON.parse(parameters['Light Colors']);
    const param_FrontLight = JSON.parse(parameters['Front Light'], paramReplace);
    const param_DarknessSize = Number(parameters['Darkness Size'] || 3);

    // Dealing with other plugins
    const _importedPlugin = (...names) => {
        return names.some(name => PluginManager._scripts.includes(name));
    };

    //-----------------------------------------------------------------------------
    // Bitmap

    if (Utils.RPGMAKER_NAME === 'MV') {

        Bitmap.prototype.destroy = function () {
            if (this._baseTexture) {
                this._baseTexture.destroy();
                this.__baseTexture = null;
            }
            this._destroyCanvas();
        };

        Bitmap.prototype._destroyCanvas = function () {
            if (this._canvas) {
                this._canvas.width = 0;
                this._canvas.height = 0;
                this.__canvas = null;
            }
        };

    }

    Bitmap.prototype.mppBlur = function (level) {
        const { canvas, context, width: w, height: h } = this;
        const tempCanvas = document.createElement('canvas');
        const tempContext = tempCanvas.getContext('2d');
        tempCanvas.width = w + 2;
        tempCanvas.height = h + 2;
        for (let i = 0; i < level; i++) {
            tempContext.clearRect(0, 0, w + 2, h + 2);
            tempContext.drawImage(canvas, 0, 0, w, h, 1, 1, w, h);
            tempContext.drawImage(canvas, 0, 0, w, 1, 1, 0, w, 1);
            tempContext.drawImage(canvas, 0, 0, 1, h, 0, 1, 1, h);
            tempContext.drawImage(canvas, 0, h - 1, w, 1, 1, h + 1, w, 1);
            tempContext.drawImage(canvas, w - 1, 0, 1, h, w + 1, 1, 1, h);
            tempContext.drawImage(canvas, 0, 0, 1, 1, 0, 0, 1, 1);
            tempContext.drawImage(canvas, w - 1, 0, 1, 1, w + 1, 0, 1, 1);
            tempContext.drawImage(canvas, 0, h - 1, 1, 1, 0, h + 1, 1, 1);
            tempContext.drawImage(canvas, w - 1, h - 1, 1, 1, w + 1, h + 1, 1, 1);
            context.save();
            context.clearRect(0, 0, w, h);
            context.globalCompositeOperation = 'lighter';
            context.globalAlpha = 1 / 9;
            for (let y = 0; y < 3; y++) {
                for (let x = 0; x < 3; x++) {
                    context.drawImage(tempCanvas, x, y, w, h, 0, 0, w, h);
                }
            }
            context.restore();
        }
        this._baseTexture.update();
    };

    //-------------------------------------------------------------------------
    // Tilemap

    const _Tilemap_destroy = Tilemap.prototype.destroy;
    Tilemap.prototype.destroy = function () {
        this._darknessLayer.destroy();
        _Tilemap_destroy.apply(this, arguments);
    };

    const _Tilemap__createLayers = Tilemap.prototype._createLayers;
    Tilemap.prototype._createLayers = function () {
        _Tilemap__createLayers.apply(this, arguments);
        this._createDarknessLayer();
    };

    Tilemap.prototype._createDarknessLayer = function () {
        this._darknessLayer = new DarknessLayer();
        this._darknessLayer.z = 9;
        this.addChild(this._darknessLayer);
    };

    const _Tilemap_updateTransform = Tilemap.prototype.updateTransform;
    Tilemap.prototype.updateTransform = function () {
        const ox = Math.ceil(this.origin.x);
        const oy = Math.ceil(this.origin.y);
        const startX = Math.floor((ox - this._margin) / this._tileWidth);
        const startY = Math.floor((oy - this._margin) / this._tileHeight);
        const mx = startX * this._tileWidth - ox;
        const my = startY * this._tileHeight - oy;
        this._moveDarkness(mx, my);
        _Tilemap_updateTransform.apply(this, arguments);
        if (this._darknessLayer.bitmap && this._darknessLayer.opacity > 0) {
            this._addDarknessLayer(startX, startY);
        }
    };

    Tilemap.prototype._moveDarkness = function (x, y) {
        this._darknessLayer.x = x;
        this._darknessLayer.y = y;
        this._darknessLayer.opacity = $gameMap.darknessOpacity();
    };

    Tilemap.prototype._addDarknessLayer = function (startX, startY) {
        const layer = this._darknessLayer;
        layer.clear();
        this._addDarkness();
        const sx = startX - this.origin.x / this._tileWidth;
        const sy = startY - this.origin.y / this._tileHeight;
        for (const light of $gameMap.allMapLights()) {
            layer._addMapLidht(light, sx, sy);
        }
    };

    Tilemap.prototype.createDarknessBitmap = function () {
        const size = param_DarknessSize;
        const widthWithMatgin = this.width + this._margin * 2;
        const heightWithMatgin = this.height + this._margin * 2;
        const tileCols = Math.ceil(widthWithMatgin / this._tileWidth) + 1;
        const tileRows = Math.ceil(heightWithMatgin / this._tileHeight) + 1;
        const bitmap = new Bitmap(tileCols * size, tileRows * size);
        bitmap.smooth = true;
        this._darknessLayer.bitmap = bitmap;
        this._darknessLayer.scale.x = this._tileWidth / size;
        this._darknessLayer.scale.y = this._tileHeight / size;
    };

    Tilemap.prototype._addDarkness = function () {
        this._darknessLayer.fillAll('black');
    };

    //-------------------------------------------------------------------------
    // ShaderTilemap

    if (Utils.RPGMAKER_NAME === 'MV') {

        const _ShaderTilemap_updateTransform = ShaderTilemap.prototype.updateTransform;
        ShaderTilemap.prototype.updateTransform = function () {
            const ox = this.roundPixels ? Math.floor(this.origin.x) : this.origin.x;
            const oy = this.roundPixels ? Math.floor(this.origin.y) : this.origin.y;
            const startX = Math.floor((ox - this._margin) / this._tileWidth);
            const startY = Math.floor((oy - this._margin) / this._tileHeight);
            this._moveDarkness(startX * this._tileWidth - ox, startY * this._tileHeight - oy);
            _ShaderTilemap_updateTransform.apply(this, arguments);
            if (this._darknessLayer.opacity > 0) {
                this._addDarknessLayer(startX, startY);
            }
        };

        const _ShaderTilemap__createLayers = ShaderTilemap.prototype._createLayers;
        ShaderTilemap.prototype._createLayers = function () {
            _ShaderTilemap__createLayers.apply(this, arguments);
            this._createDarknessLayer();
        };

    }

    //-----------------------------------------------------------------------------
    // DarknessLayer

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

    if (_importedPlugin('MPP_MapLight_Op2')) {
        window.DarknessLayer = DarknessLayer;
    }

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

    DarknessLayer.prototype.initialize = function () {
        Sprite.prototype.initialize.call(this);
        this._frontBitmaps = {};
        this.blendMode = 2;
    };

    DarknessLayer.prototype.destroy = function () {
        for (const bitmap of Object.values(this._frontBitmaps)) {
            bitmap.destroy();
        }
        if (this.bitmap) {
            this.bitmap.destroy();
        }
        Sprite.prototype.destroy.call(this);
    };

    DarknessLayer.prototype.clear = function () {
        this.bitmap.clear();
    };

    DarknessLayer.prototype.fillAll = function (color) {
        this.bitmap.fillAll(color);
    };

    DarknessLayer.prototype._addMapLidht = function (mapLight, sx, sy) {
        if (mapLight.isValid()) {
            const dx = mapLight.scrolledX() - sx + 0.5;
            const dy = mapLight.scrolledY() - sy + 0.4;
            const alpha = mapLight.opacity / 255;
            const rgb = mapLight.rgb();
            if (mapLight.isFront()) {
                this._addFrontLidht(dx, dy, rgb, mapLight.angle, alpha);
            } else {
                this._addNormalMapLidht(dx, dy, rgb, mapLight.radius, alpha);
            }
        }
    };

    DarknessLayer.prototype._addFrontLidht = function (x, y, rgb, angle, alpha) {
        const frontBitmap = this._createFrontBitmap(rgb);
        const size = param_DarknessSize;
        const bitmap = this.bitmap;
        const context = bitmap.context;
        const { width: sw, height: sh } = frontBitmap;
        const dx = -sw / 2 * size / 4;
        const dy = -param_FrontLight.Oy * size / 4;
        const dw = sw * size / 4;
        const dh = sh * size / 4;

        // MVで size = 4, angle = 0 の場合、他の値の小数点以下が無視されるため、その対処
        if (size === 4 && Utils.RPGMAKER_NAME === 'MV') angle = angle || 0.1;

        context.save();
        context.translate(x * size, y * size);
        context.rotate(angle * Math.PI / 180);
        context.globalAlpha = alpha;
        bitmap.blt(frontBitmap, 0, 0, sw, sh, dx, dy, dw, dh);
        context.restore();
    };

    DarknessLayer.prototype._createFrontBitmap = function (rgb) {
        const dict = this._frontBitmaps;
        if (!dict[rgb]) {
            const { Radius: radius = 6, Angle: angle = 90 } = param_FrontLight;
            const r = radius * 4;
            const bitmap = new Bitmap(r * 2 + 4, r + 4);
            const context = bitmap.context;
            context.save();
            context.beginPath();
            context.moveTo(r + 2, 2);
            const startAngle = (90 - angle / 2) / 180 * Math.PI;
            const endAngle = (90 + angle / 2) / 180 * Math.PI;
            context.arc(r + 2, 2, r, startAngle, endAngle);
            context.closePath();
            const grad = context.createRadialGradient(r + 2, 2, 0, r + 2, 2, r);
            grad.addColorStop(0, 'rgba(%1,1)'.format(rgb));
            grad.addColorStop(1, 'rgba(%1,0)'.format(rgb));
            context.fillStyle = grad;
            context.fill();
            context.restore();
            bitmap.mppBlur(2);
            dict[rgb] = bitmap;
        }
        return dict[rgb];
    };

    DarknessLayer.prototype._addNormalMapLidht = function (x, y, rgb, r, alpha) {
        const size = param_DarknessSize;
        const dx = x * size;
        const dy = y * size;
        const dr = r * size;
        const bitmap = this.bitmap;
        const context = bitmap.context;
        const grad = context.createRadialGradient(dx, dy, 0, dx, dy, dr);
        grad.addColorStop(0, 'rgba(%1,1)'.format(rgb));
        grad.addColorStop(1, 'rgba(%1,0)'.format(rgb));
        context.globalAlpha = alpha;
        bitmap.drawCircle(dx, dy, dr, grad);
        context.globalAlpha = 1;
    };

    //-----------------------------------------------------------------------------
    // Game_MapLight

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

    window.Game_MapLight = Game_MapLight;

    Object.defineProperties(Game_MapLight.prototype, {
        colorIndex: {
            get() { return this._colorIndex; },
            configurable: true
        },
        radius: {
            get() { return this._radius; },
            configurable: true
        },
        opacity: {
            get() { return this._opacity; },
            configurable: true
        },
        angle: {
            get() { return this._angle; },
            configurable: true
        }
    });

    Game_MapLight.prototype.initialize = function (id) {
        this.id = id;
        this._eventId = 0;
        this._x = 0;
        this._y = 0;
        this._colorIndex = 0;
        this._radius = 0;
        this._targetRadius = 0;
        this._isFront = false;
        this._opacity = 0;
        this._targetOpacity = 0;
        this._amplitude = 0;
        this._moveDuration = 0;
        this._angle = 0;
        this._subjectDirection = 0;
        this._angleDuration = 0;
    };

    Game_MapLight.prototype.subject = function () {
        if (this._eventId < 0) {
            return $gamePlayer;
        } else if (this._eventId > 0) {
            return $gameMap.event(this._eventId);
        }
        return null;
    };

    Game_MapLight.prototype.rgb = function () {
        return this._colorIndex > 0
            ? param_LightColors[this._colorIndex - 1]
            : null;
    };

    Game_MapLight.prototype.isFront = function () {
        return this._isFront;
    };

    Game_MapLight.prototype.isValid = function () {
        return (
            (this._radius > 0 || this._isFront) &&
            this._opacity > 0 &&
            this.rgb()
        );
    };

    Game_MapLight.prototype.setCharLight = function (
        eventId, radius, colorIndex, amplitude
    ) {
        this._isFront = false;
        this._eventId = eventId;
        this._targetRadius = radius;
        this._colorIndex = colorIndex;
        this._targetOpacity = 255;
        this._amplitude = amplitude;
        this._moveDuration = 16;
        this._subjectDirection = 0;
        this._angleDuration = 0;
    };

    Game_MapLight.prototype.setPosLight = function (
        x, y, radius, colorIndex, amplitude
    ) {
        this._isFront = false;
        this._x = x;
        this._y = y;
        this._targetRadius = radius;
        this._colorIndex = colorIndex;
        this._targetOpacity = 255;
        this._amplitude = amplitude;
        this._moveDuration = 16;
        this._eventId = 0;
        this._subjectDirection = 0;
        this._angleDuration = 0;
    };

    Game_MapLight.prototype.setFrontLight = function (
        eventId, colorIndex, amplitude
    ) {
        this._isFront = true;
        this._eventId = eventId;
        this._colorIndex = colorIndex;
        this._targetOpacity = 255;
        this._amplitude = amplitude;
        this._moveDuration = 16;
        const subject = this.subject();
        this._angle = this.directionAngle(subject);
        this._subjectDirection = subject ? subject.direction() : 0;
        this._angleDuration = 0;
        this._radius = 0;
    };

    Game_MapLight.prototype.skip = function () {
        this._radius = this._targetRadius;
        this._opacity = this._targetOpacity;
        this.setupAmplitude();
    };

    Game_MapLight.prototype.setupAmplitude = function () {
        if (this._targetOpacity > 0 && this._amplitude > 0) {
            this._targetOpacity = 255 - Math.randomInt(255 * this._amplitude / 100);
            this._moveDuration = 8;
        } else {
            this._moveDuration = 0;
        }
    };

    Game_MapLight.prototype.update = function () {
        this.updateMove();
        this.updateAngle();
    };

    Game_MapLight.prototype.updateMove = function () {
        if (this._moveDuration > 0) {
            const d = this._moveDuration;
            this._radius = (this._radius * (d - 1) + this._targetRadius) / d;
            this._opacity = (this._opacity * (d - 1) + this._targetOpacity) / d;
            this._moveDuration--;
            if (this._moveDuration === 0) this.setupAmplitude();
        }
    };

    Game_MapLight.prototype.updateAngle = function () {
        if (this._isFront) {
            const subject = this.subject();
            if (subject) {
                if (this._subjectDirection !== subject.direction()) {
                    this._subjectDirection = subject.direction();
                    this.startAngle(subject);
                }
                if (this._angleDuration > 0) {
                    const d = this._angleDuration;
                    const target = this.targetAngle(subject);
                    const max = d * (d + 1) / 2;
                    this._angle += (target - this._angle) * d / max;
                    this._angle = (this._angle + 360) % 360;
                    this._angleDuration--;
                }
            }
        }
    };

    Game_MapLight.prototype.startAngle = function (subject) {
        this._angleDuration = param_FrontLight['Turn Duration'] || 0;
        if (this._angleDuration === 0) {
            this._angle = this.directionAngle(subject);
        }
    };

    Game_MapLight.prototype.targetAngle = function (subject) {
        let result = this.directionAngle(subject);
        const sa = this._angle - result;
        if (Math.abs(sa) > Math.abs(sa - 360)) result += 360;
        if (Math.abs(sa) > Math.abs(sa + 360)) result -= 360;
        return result;
    };

    Game_MapLight.prototype.directionAngle = function (subject) {
        if (subject) {
            switch (subject.direction()) {
                case 2: return 0;
                case 4: return 90;
                case 6: return 270;
                case 8: return 180;
            }
        }
        return 0;
    };

    Game_MapLight.prototype.scrolledX = function () {
        const subject = this.subject();
        return subject ? subject.scrolledX() : $gameMap.adjustX(this._x);
    };

    Game_MapLight.prototype.scrolledY = function () {
        const subject = this.subject();
        return subject ? subject.scrolledY() : $gameMap.adjustY(this._y);
    };

    //-------------------------------------------------------------------------
    // Game_Map

    const _Game_Map_setup = Game_Map.prototype.setup;
    Game_Map.prototype.setup = function (mapId) {
        this._mapLights = {};
        _Game_Map_setup.apply(this, arguments);
        this._darkness = 0;
        this._mapLightId = 0;
        for (const [name, param] of Object.entries($dataMap.meta)) {
            const match = /^PosLight\s+(\d+)\s*,\s*(\d+)\s*$/.exec(name);
            if (match) {
                const x = Number(match[1]);
                const y = Number(match[2]);
                const data = param.split(',').map(Number);
                this.setPosLight(x, y, ...data);
            } else if (name === 'Darkness') {
                this._darkness = PluginManager.mppValue(param).clamp(0, 100);
            }
        }
        for (const light of Object.values(this._mapLights)) {
            light.skip();
        }
    };

    Game_Map.prototype.darknessOpacity = function () {
        return 255 * this._darkness / 100;
    };

    Game_Map.prototype.setDarkness = function (opacity) {
        this._darkness = opacity.clamp(0, 100);
    };

    Game_Map.prototype.allMapLights = function () {
        // 順番関係なし
        return Object.values(this._mapLights);
        //        return Object.values(this._mapLights).sort((a, b) => {
        //            if (a.colorIndex !== b.colorIndex) {
        //                return b.colorIndex - a.colorIndex;
        //            } else {
        //                return a.id !== b.id;
        //            }
        //        });
    };

    Game_Map.prototype.getMapLight = function (key) {
        const dict = this._mapLights;
        if (!dict[key]) dict[key] = new Game_MapLight(this._mapLightId++);
        return dict[key];
    };

    Game_Map.prototype.setCharLight = function (eventId, r = 0, c = 0, a = 0) {
        const key = 'char%1'.format(eventId);
        this.getMapLight(key).setCharLight(eventId, r, c, a);
    };

    Game_Map.prototype.setPosLight = function (x, y, r = 0, c = 0, a = 0) {
        const key = 'pos%1,%2'.format(x, y);
        this.getMapLight(key).setPosLight(x, y, r, c, a);
    };

    Game_Map.prototype.setFrontLight = function (eventId, c = 0, a = 0) {
        const key = 'front%1'.format(eventId);
        this.getMapLight(key).setFrontLight(eventId, c, a);
    };

    Game_Map.prototype.eraseCharLight = function (eventId) {
        this.eraseLight('char%1'.format(eventId));
    };

    Game_Map.prototype.erasePosLight = function (x, y) {
        this.eraseLight('pos%1,%2'.format(x, y));
    };

    Game_Map.prototype.eraseFrontLight = function (eventId) {
        this.eraseLight('front%1'.format(eventId));
    };

    Game_Map.prototype.eraseLight = function (key) {
        delete this._mapLights[key];
    };

    const _Game_Map_update = Game_Map.prototype.update;
    Game_Map.prototype.update = function (sceneActive) {
        _Game_Map_update.apply(this, arguments);
        for (const light of Object.values(this._mapLights)) {
            light.update();
        }
    };

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

    const _Game_Event_clearPageSettings = Game_Event.prototype.clearPageSettings;
    Game_Event.prototype.clearPageSettings = function () {
        _Game_Event_clearPageSettings.apply(this, arguments);
        $gameMap.eraseCharLight(this.eventId());
    };

    const _Game_Event_setupPageSettings = Game_Event.prototype.setupPageSettings;
    Game_Event.prototype.setupPageSettings = function () {
        _Game_Event_setupPageSettings.apply(this, arguments);
        if (!this.setupMapLight()) {
            $gameMap.eraseCharLight(this.eventId());
        }
    };

    Game_Event.prototype.setupMapLight = function () {
        for (const command of this.list()) {
            switch (command.code) {
                case 108:
                case 408:
                    const comment = command.parameters[0];
                    if (
                        comment.startsWith('灯り') ||
                        comment.startsWith('CharLight')
                    ) {
                        const [_, ...args] = comment.split(' ');
                        const eventId = this.eventId();
                        $gameMap.setCharLight(eventId, ...args.map(Number));
                        return true;
                    }
                    break;
                default:
                    return false;
            }
        }
        return false;
    };

    //-------------------------------------------------------------------------
    // Game_Interpreter

    const _mzCommands = {
        SetCharLight: {
            name: 'setCharLight',
            keys: ['character', 'radius', 'colorIndex', 'amplitude']
        },
        SetPosLight: {
            name: 'setPosLight',
            keys: ['x', 'y', 'radius', 'colorIndex', 'amplitude']
        },
        SetFrontLight: {
            name: 'setFrontLight',
            keys: ['character', 'colorIndex', 'amplitude']
        },
        EraseCharLight: { name: 'eraseCharLight', keys: ['character'] },
        ErasePosLight: { name: 'erasePosLight', keys: ['x', 'y'] },
        EraseFrontLight: { name: 'eraseFrontLight', keys: ['character'] },
        SetMapDarkness: { name: 'setDarkness', keys: ['darkness'] }
    };
    Object.assign(_mzCommands, {
        'キャラ灯り設定': _mzCommands.SetCharLight,
        'マップ灯り設定': _mzCommands.SetPosLight,
        '前方灯り設定': _mzCommands.SetFrontLight,
        'キャラ灯り消去': _mzCommands.EraseCharLight,
        'マップ灯り消去': _mzCommands.ErasePosLight,
        '前方灯り消去': _mzCommands.EraseFrontLight,
        'マップ暗さ設定': _mzCommands.SetMapDarkness
    });

    const _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function (command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        const mzCommand = _mzCommands[command];
        if (mzCommand) {
            const args2 = Object.assign(...mzCommand.keys.map((k, i) => ({ [k]: args[i] })));
            PluginManager.callCommand(this, pluginName, mzCommand.name, args2);
        }
    };

    //-------------------------------------------------------------------------
    // PluginManager

    PluginManager._commands = PluginManager._commands || {};

    if (!PluginManager.registerCommand) {
        PluginManager.registerCommand = function (pluginName, commandName, func) {
            const key = pluginName + ":" + commandName;
            this._commands[key] = func;
        };
    }

    if (!PluginManager.callCommand) {
        PluginManager.callCommand = function (self, pluginName, commandName, args) {
            const key = pluginName + ":" + commandName;
            const func = this._commands[key];
            if (typeof func === "function") {
                func.bind(self)(args);
            }
        };
    }

    PluginManager.registerCommand(pluginName, 'setCharLight', function (args) {
        const eventId = PluginManager.mppValue(args.character) || this.eventId();
        const r = PluginManager.mppValue(args.radius);
        const c = PluginManager.mppValue(args.colorIndex);
        const a = PluginManager.mppValue(args.amplitude || '0');
        $gameMap.setCharLight(eventId, r, c, a);
    });

    PluginManager.registerCommand(pluginName, 'setPosLight', args => {
        const x = PluginManager.mppValue(args.x);
        const y = PluginManager.mppValue(args.y);
        const r = PluginManager.mppValue(args.radius);
        const c = PluginManager.mppValue(args.colorIndex);
        const a = PluginManager.mppValue(args.amplitude || '0');
        $gameMap.setPosLight(x, y, r, c, a);
    });

    PluginManager.registerCommand(pluginName, 'setFrontLight', function (args) {
        const eventId = PluginManager.mppValue(args.character) || this.eventId();
        const c = PluginManager.mppValue(args.colorIndex);
        const a = PluginManager.mppValue(args.amplitude || '0');
        $gameMap.setFrontLight(eventId, c, a);
    });

    PluginManager.registerCommand(pluginName, 'eraseCharLight', function (args) {
        const eventId = PluginManager.mppValue(args.character) || this.eventId();
        $gameMap.eraseCharLight(eventId);
    });

    PluginManager.registerCommand(pluginName, 'erasePosLight', args => {
        const x = PluginManager.mppValue(args.x);
        const y = PluginManager.mppValue(args.y);
        $gameMap.erasePosLight(x, y);
    });

    PluginManager.registerCommand(pluginName, 'eraseFrontLight', function (args) {
        const eventId = PluginManager.mppValue(args.character) || this.eventId();
        $gameMap.eraseFrontLight(eventId);
    });

    PluginManager.registerCommand(pluginName, 'setDarkness', args => {
        const darkness = PluginManager.mppValue(args.darkness);
        $gameMap.setDarkness(darkness);
    });

    PluginManager.mppValue = function (value) {
        const match = /^V\[(\d+)\]$/i.exec(value);
        return match ? $gameVariables.value(+match[1]) : +value;
    };

    //-------------------------------------------------------------------------
    // Spriteset_Map

    const _Spriteset_Map_createTilemap = Spriteset_Map.prototype.createTilemap;
    Spriteset_Map.prototype.createTilemap = function () {
        _Spriteset_Map_createTilemap.apply(this, arguments);
        this._tilemap.createDarknessBitmap();
    };

})();


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

/*:
 * @plugindesc 【ver.1.2】各イベントにセルフ変数を追加します。
 * @author 木星ペンギン
 *
 * @help ●プラグインパラメータにて設定した番号の変数が、
 * 　イベントごとのセルフ変数を参照します。
 *
 *   数値を設定する際、n-m と表記することでnからmまでの数値を指定できます。
 *   (例 : 1-4,8 => 1,2,3,4,8)
 *
 * ●[変数の操作]を行うと、実行中のイベントのセルフ変数が操作されます。
 *
 * ●イベントの[出現条件]ではセルフ変数が参照されます。
 *
 * ●コモンイベントでセルフ変数を操作した場合、以下のようになります。
 *  ▽マップのイベントから[コモンイベントの呼び出し]を行った場合
 *   各イベントのセルフ変数が参照されます。
 *
 *  ▽コモンイベントを自動実行or並列実行した場合
 *   コモンイベントごとのセルフ変数が参照されます。
 *
 * ●トループのバトルイベントにはセルフ変数が適用されません。
 *   通常の変数と同じ扱いとなります。
 *
 * ●通常のイベントでも、並列処理の場合は以下のコマンドでは使用できません。
 * 　（並列処理でなければ使用できます）
 *  ・文章の表示（制御文字）
 *  ・選択肢の表示（制御文字）
 *  ・数値入力の処理
 *  ・アイテム選択の処理
 *  ・文章のスクロール表示（制御文字）
 *
 * ================================
 * 制作 : 木星ペンギン
 * URL : http://woodpenguin.blog.fc2.com/
 *
 * @param Variables
 * @desc セルフ変数にする変数番号の配列
 * @default
 *
 */

(function () {

    var MPPlugin = {};
    MPPlugin.params = PluginManager.parameters('MPP_SelfVariable');

    MPPlugin.convertParam = function (name) {
        var param = this.params[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.Variables = MPPlugin.convertParam('Variables');

    var Alias = {};

    //-----------------------------------------------------------------------------
    // Game_Variables

    //15
    Alias.GaVa_clear = Game_Variables.prototype.clear;
    Game_Variables.prototype.clear = function () {
        Alias.GaVa_clear.call(this);
        this._selfVariables = {};
        this._mapId = 0;
        this._eventId = 0;
    };

    //19
    Alias.GaVa_value = Game_Variables.prototype.value;
    Game_Variables.prototype.value = function (variableId) {
        if (this._eventId > 0 && MPPlugin.Variables.contains(variableId)) {
            var key = [this._mapId, this._eventId, variableId];
            return this._selfVariables[key] || 0;
        } else {
            return Alias.GaVa_value.call(this, variableId);
        }
    };

    //23
    Alias.GaVa_setValue = Game_Variables.prototype.setValue;
    Game_Variables.prototype.setValue = function (variableId, value) {
        if (this._eventId > 0 && MPPlugin.Variables.contains(variableId)) {
            if (typeof value === 'number') {
                value = Math.floor(value);
            }
            var key = [this._mapId, this._eventId, variableId];
            this._selfVariables[key] = value;
            this.onChange();
        } else {
            Alias.GaVa_setValue.call(this, variableId, value);
        }
    };

    Game_Variables.prototype.reserveEvent = function (mapId, eventId) {
        this._mapId = mapId;
        this._eventId = eventId;
    };

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

    //188
    Alias.GaEv_findProperPageIndex = Game_Event.prototype.findProperPageIndex;
    Game_Event.prototype.findProperPageIndex = function () {
        $gameVariables.reserveEvent(this._mapId, this._eventId);
        return Alias.GaEv_findProperPageIndex.call(this);
    };

    //-----------------------------------------------------------------------------
    // Game_CommonEvent

    //24
    Alias.GaCoEv_refresh = Game_CommonEvent.prototype.refresh;
    Game_CommonEvent.prototype.refresh = function () {
        Alias.GaCoEv_refresh.call(this);
        if (this._interpreter) {
            this._interpreter._commonEventId = this._commonEventId;
        }
    };

    //-----------------------------------------------------------------------------
    // Game_Interpreter

    //55
    Alias.GaIn_setupReservedCommonEvent = Game_Interpreter.prototype.setupReservedCommonEvent;
    Game_Interpreter.prototype.setupReservedCommonEvent = function () {
        this._commonEventId = $gameTemp._commonEventId;
        return Alias.GaIn_setupReservedCommonEvent.call(this);
    };

    //68
    Alias.GaIn_update = Game_Interpreter.prototype.update;
    Game_Interpreter.prototype.update = function () {
        this.reserveSelfVar();
        Alias.GaIn_update.call(this);
    };

    //608
    Alias.GaIn_setupChild = Game_Interpreter.prototype.setupChild;
    Game_Interpreter.prototype.setupChild = function (list, eventId) {
        Alias.GaIn_setupChild.call(this, list, eventId);
        this._childInterpreter._commonEventId = this._commonEventId;
    };

    Game_Interpreter.prototype.reserveSelfVar = function () {
        if (this._commonEventId) {
            $gameVariables.reserveEvent(-1, this._commonEventId);
        } else {
            $gameVariables.reserveEvent(this._mapId, this._eventId);
        }
    };

})();

repo_name: dazed/translations

license: unknown


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:
//=============================================================================
// MakeScreenCapture.js
// ----------------------------------------------------------------------------
// (C)2015-2018 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.8.0++ 2022/07/03 ピクチャに指定変数を埋め込む・復元する機能を追加しました。
// 1.8.0+ 2022/06/10 ピクチャをキャプチャに含めるか設定する機能を追加しました。
// 1.8.0 2021/09/24 署名に制御文字\v[n]を使えるよう修正
// 1.7.3 2018/06/28 出力パスの算出方法を変更
// 1.7.2 2018/03/06 各種ファンクションキーにCtrlおよびAltの同時押し要否の設定を追加しました。
// 1.7.1 2017/11/11 総合開発支援プラグインとの連携による修正
// 1.7.0 2017/08/13 パラメータの型指定機能に対応
// 1.6.0 2016/12/25 jpg保存時の拡張子を「jpeg」→「jpg」に変更
//                  jpeg品質をパラメータから指定できる機能を追加
// 1.5.0 2016/10/20 本体バージョン1.3.2でエラーが発生していたのを修正
// 1.4.0 2016/10/06 パラメータに環境変数を使えるように修正
// 1.3.0 2016/06/24 WEBP形式のショートカットキーを追加
// 1.2.3 2016/06/23 著名に画像とテキストを両方使えるよう修正
// 1.2.2 2016/05/13 プラグインコマンドから出力したときに拡張子の表示がおかしくなる問題を修正
// 1.2.1 2016/05/11 定期実行キャプチャを行ったときに拡張子の表示がおかしくなる問題を修正
// 1.2.0 2016/04/23 署名に任意の画像ファイルを利用できるようになりました。
//                  細部のリファクタリング
// 1.1.5 2016/04/10 画像の出力先を管理画面のパラメータとして設定できるよう修正
// 1.1.4 2016/03/31 画像の出力先を絶対パスで指定できるよう修正
// 1.1.3 2016/03/15 文章のスクロール表示が正しくキャプチャできない問題を修正
// 1.1.2 2016/03/01 pngとjpegの形式ごとのファンクションキーを割り当てるよう修正
// 1.1.1 2016/02/26 PrintScreenでもキャプチャできるように修正
// 1.1.0 2016/02/25 複数のウィンドウを含む画面で正しくキャプチャできない不具合を修正
//                  高度な設定項目の追加
// 1.0.0 2016/02/24 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc Screen Capture Plugin
 * @author triacontane
 *
 * @param FuncKeyPngCapture
 * @desc キャプチャとファイル保存を行うファンクションキーです。
 * 保存形式の設定にかかわらずpng形式で出力します。
 * @default F6
 * @type select
 * @option none
 * @option F1
 * @option F2
 * @option F3
 * @option F4
 * @option F5
 * @option F6
 * @option F7
 * @option F8
 * @option F9
 * @option F10
 * @option F11
 * @option F12
 *
 * @param FuncKeyJpegCapture
 * @desc キャプチャとファイル保存を行うファンクションキーです。
 * 保存形式の設定にかかわらずjpeg形式で出力します。
 * @default F7
 * @type select
 * @option none
 * @option F1
 * @option F2
 * @option F3
 * @option F4
 * @option F5
 * @option F6
 * @option F7
 * @option F8
 * @option F9
 * @option F10
 * @option F11
 * @option F12
 *
 * @param FuncKeyWebpCapture
 * @desc キャプチャとファイル保存を行うファンクションキーです。
 * 保存形式の設定にかかわらずwebp形式で出力します。
 * @default
 * @type select
 * @option none
 * @option F1
 * @option F2
 * @option F3
 * @option F4
 * @option F5
 * @option F6
 * @option F7
 * @option F8
 * @option F9
 * @option F10
 * @option F11
 * @option F12
 *
 * @param SimultaneousCtrl
 * @desc 各機能を利用する際にCtrlキーの同時押しが必要かどうかです。他のプラグインと対象キーが競合する場合に利用します。
 * @default false
 * @type boolean
 *
 * @param SimultaneousAlt
 * @desc 各機能を利用する際にAltキーの同時押しが必要かどうかです。他のプラグインと対象キーが競合する場合に利用します。
 * @default false
 * @type boolean
 *
 * @param FileName
 * @desc 画像のファイル名です。
 * プラグインコマンドから実行した場合は参照されません。
 * @default image
 *
 * @param Location
 * @desc ファイルの出力パスです。相対パス、絶対パスが利用できます。
 * 区切り文字は「/」もしくは「\」で指定してください。
 * @default captures
 *
 * @param FileFormat
 * @desc 画像のデフォルト保存形式です。(png/jpeg/webp)
 * @default png
 * @type select
 * @option png
 * @option jpeg
 * @option webp
 *
 * @param NumberDigit
 * @desc キャプチャファイルの連番桁数です。
 * @default 2
 * @type number
 *
 * @param TimeStamp
 * @desc ONにすると連番の代わりにタイムスタンプを付与します。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param Signature
 * @desc 保存時に画像の右下に書き込まれる署名です。
 * @default
 *
 * @param SignatureSize
 * @desc 署名のフォントサイズです。
 * @default 22
 * @type number
 *
 * @param SignatureImage
 * @desc 保存時に画像の右下に書き込まれる著名画像ファイル名です。「img/pictures」に配置。拡張子不要。
 * @default
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param Interval
 * @desc キャプチャを定期実行する間隔（秒単位）です。
 * 0にすると、定期キャプチャを行いません。
 * @default 0
 * @type number
 *
 * @param SeName
 * @desc キャプチャ実行時に演奏する効果音のファイル名です。
 * @default
 * @require 1
 * @dir audio/se/
 * @type file
 *
 * @param JpegQuality
 * @desc JPEG出力したときの品質です。値を小さくすると容量も小さくなります。(1...10)
 * @default 9
 * @type number
 * @min 1
 * @max 10
 *
 * @help プレー中のゲーム画面をキャプチャして
 * ファイルに保存したり、ピクチャとして表示したりできます。
 * キャプチャは以下のタイミングで実行されます。
 *
 * ・ファンクションキー or PrintScreen押下
 * ・一定時間ごと
 * ・プラグインコマンド実行時
 *
 * プラグインコマンド以外は、テストプレー時のみ有効になります。
 *
 * キャプチャしたファイルの保存場所は絶対パス、相対パスいずれも指定できるほか、
 * OSの環境変数（%USERPROFILE%など）にも対応しています。
 *
 * また、キャプチャの際に著名を自動で埋め込むことができます。
 * 著名は文字列で指定できるほか、任意の画像も指定可能です。
 * （両方指定すると画像が優先されます）
 *
 * 注意！
 * キャプチャピクチャの表示状態はセーブできません。
 * セーブされる前に「ピクチャの消去」で消去してください。
 *
 * 注意！
 * キャプチャを出力する機能はローカル環境でのみ有効です。
 * ブラウザやスマホ上では動作しません。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * MSC_MAKE
 *  実行時点でのキャプチャを作成して保持します。
 *  ex：MSC_MAKE
 *
 * MSC_PICTURE
 *  保持していた画面キャプチャをピクチャに表示します。
 *  このコマンドの直後に「ピクチャの表示」を実行するとキャプチャピクチャが
 *  表示されます。
 *  ex：MSC_PICTURE
 *
 * MSC_SAVE [ファイル名] [変数番号]
 *  保持していた画面キャプチャをファイルに保存します。
 *  ファイル名は自由に指定できます。
 *  拡張子は自動で設定されるので設定不要です。
 *  変数番号の指定がある場合、値をキャプチャ内に埋め込みます。
 *  ex：MSC_SAVE image 1
 *
 * MSC_LOAD [スイッチ番号] [変数番号] [読み込み失敗時の値]
 *  OS標準のファイル選択ウィンドウを表示し、プレイヤーが選んだPNG画像を読み込みます。
 *  読み込みに成功した場合は、指定したスイッチがONになります。
 *  キャンセルされた場合は、システムのキャンセル音を再生し、指定したスイッチがOFFになります。
 *  PNGファイルとしての読み込みに失敗するファイルが選ばれた際は、システムのブザー音を再生し、指定したスイッチがOFFになります。
 *
 *  変数番号を指定した場合、画像から値を読み取ろうとします。
 *  成功した場合は読み取った値が、値がない、破損している等の理由で失敗した場合は、失敗時の値が代入されます。
 *
 *  例:画面キャプチャ読込 1 3 -1
 *
 * MSC_HIDDEN [ピクチャ番号] [ON/OFF]
 *  指定した番号のピクチャを画面キャプチャに描画しないようにします。
 *  ゲームの再起動、またはリロードまで有効となります。
 *
 *  例: 画面キャプチャ内非表示 1 ON
 *      1番のピクチャをキャプチャに含めないようにします
 *  例: 画面キャプチャ内非表示 1 OFF
 *      1番のピクチャをキャプチャに含むようにします
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 画面キャプチャ管理プラグイン
 * @author トリアコンタン
 *
 * @param PNGキャプチャキー
 * @desc キャプチャとファイル保存を行うファンクションキーです。
 * 保存形式の設定にかかわらずpng形式で出力します。
 * @default F6
 * @type select
 * @option none
 * @option F1
 * @option F2
 * @option F3
 * @option F4
 * @option F5
 * @option F6
 * @option F7
 * @option F8
 * @option F9
 * @option F10
 * @option F11
 * @option F12
 *
 * @param JPEGキャプチャキー
 * @desc キャプチャとファイル保存を行うファンクションキーです。
 * 保存形式の設定にかかわらずjpeg形式で出力します。
 * @default F7
 * @type select
 * @option none
 * @option F1
 * @option F2
 * @option F3
 * @option F4
 * @option F5
 * @option F6
 * @option F7
 * @option F8
 * @option F9
 * @option F10
 * @option F11
 * @option F12
 *
 * @param WEBPキャプチャキー
 * @desc キャプチャとファイル保存を行うファンクションキーです。
 * 保存形式の設定にかかわらずwebp形式で出力します。
 * @default F9
 * @type select
 * @option none
 * @option F1
 * @option F2
 * @option F3
 * @option F4
 * @option F5
 * @option F6
 * @option F7
 * @option F8
 * @option F9
 * @option F10
 * @option F11
 * @option F12
 *
 * @param Ctrl同時押し
 * @desc 各機能を利用する際にCtrlキーの同時押しが必要かどうかです。他のプラグインと対象キーが競合する場合に利用します。
 * @default false
 * @type boolean
 *
 * @param Alt同時押し
 * @desc 各機能を利用する際にAltキーの同時押しが必要かどうかです。他のプラグインと対象キーが競合する場合に利用します。
 * @default false
 * @type boolean
 *
 * @param ファイル名
 * @desc 画像のファイル名です。
 * プラグインコマンドから実行した場合は参照されません。
 * @default image
 *
 * @param 出力場所
 * @desc ファイルの出力パスです。相対パス、絶対パスが利用できます。
 * 区切り文字は「/」もしくは「\」で指定してください。
 * @default captures
 *
 * @param 保存形式
 * @desc 画像のデフォルト保存形式です。(png/jpeg/webp)
 * @default png
 * @type select
 * @option png
 * @option jpeg
 * @option webp
 *
 * @param 連番桁数
 * @desc キャプチャファイルの連番桁数です。数値はゲーム実行の度に初期化されるのでご注意ください。
 * @default 2
 * @type number
 *
 * @param タイムスタンプ
 * @desc ONにすると連番の代わりにタイムスタンプを付与します。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param 署名
 * @desc 保存時に画像の右下に書き込まれる署名です。
 * @default
 *
 * @param 署名サイズ
 * @desc 署名のフォントサイズです。
 * @default 22
 * @type number
 *
 * @param 署名画像
 * @desc 保存時に画像の右下に書き込まれる著名画像ファイル名です。「img/pictures」に配置。拡張子不要。
 * @default
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param 実行間隔
 * @desc キャプチャを定期実行する間隔（秒単位）です。
 * 0にすると、定期キャプチャを行いません。
 * @default 0
 * @type number
 *
 * @param 効果音
 * @desc キャプチャ実行時に演奏する効果音のファイル名です。
 * @default
 * @require 1
 * @dir audio/se/
 * @type file
 *
 * @param JPEG品質
 * @desc JPEG出力したときの品質です。値を小さくすると容量も小さくなります。(1...10)
 * @default 9
 * @type number
 * @min 1
 * @max 10
 *
 * @help プレー中のゲーム画面をキャプチャして
 * ファイルに保存したり、ピクチャとして表示したりできます。
 * キャプチャは以下のタイミングで実行されます。
 *
 * ・ファンクションキー or PrintScreen押下
 * ・一定時間ごと
 * ・プラグインコマンド実行時
 *
 * プラグインコマンド以外は、テストプレー時のみ有効になります。
 *
 * キャプチャしたファイルの保存場所は絶対パス、相対パスいずれも指定できるほか、
 * OSの環境変数（%USERPROFILE%など）にも対応しています。
 *
 * また、キャプチャの際に著名を自動で埋め込むことができます。
 * 著名は文字列で指定できるほか、任意の画像も指定可能です。
 * （両方指定すると画像が優先されます）
 *
 * 注意！
 * キャプチャピクチャの表示状態はセーブできません。
 * セーブされる前に「ピクチャの消去」で消去してください。
 *
 * 注意！
 * キャプチャを出力する機能はローカル環境でのみ有効です。
 * ブラウザやスマホ上では動作しません。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * MSC_MAKE or 画面キャプチャ作成
 *  実行時点でのキャプチャを作成して保持します。
 *  例：画面キャプチャ作成
 *
 * MSC_PICTURE or 画面キャプチャピクチャ
 *  保持していた画面キャプチャをピクチャに表示します。
 *  このコマンドの直後に「ピクチャの表示」を実行するとキャプチャピクチャが
 *  表示されます。
 *  例：画面キャプチャピクチャ
 *
 * MSC_SAVE [ファイル名] or 画面キャプチャ保存 [ファイル名]
 *  保持していた画面キャプチャをファイルに保存します。
 *  ファイル名は自由に指定できます。
 *  拡張子は自動で設定されるので設定不要です。
 *  変数番号の指定がある場合、値をキャプチャ内に埋め込みます。
 *  例：画面キャプチャ保存 image 1
 *
 * MSC_LOAD [スイッチ番号] [変数番号] [読み込み失敗時の値] or 画面キャプチャ読込 [スイッチ番号] [変数番号] [読み込み失敗時の値]
 *  OS標準のファイル選択ウィンドウを表示し、プレイヤーが選んだPNG画像を読み込みます。
 *  読み込みに成功した場合は、指定したスイッチがONになります。
 *  キャンセルされた場合は、システムのキャンセル音を再生し、指定したスイッチがOFFになります。
 *  PNGファイルとしての読み込みに失敗するファイルが選ばれた際は、システムのブザー音を再生し、指定したスイッチがOFFになります。
 *
 *  変数番号を指定した場合、画像から値を読み取ろうとします。
 *  成功した場合は読み取った値が、値がない、破損している等の理由で失敗した場合は、失敗時の値が代入されます。
 *
 *  例:画面キャプチャ読込 1 3 -1
 *
 * MSC_HIDDEN [ピクチャ番号] [ON/OFF] or 画面キャプチャ内非表示 [ピクチャ番号] [ON/OFF]
 *  指定した番号のピクチャを画面キャプチャに描画しないようにします。
 *  ゲームの再起動、またはリロードまで有効となります。
 *
 *  例: 画面キャプチャ内非表示 1 ON
 *      1番のピクチャをキャプチャに含めないようにします
 *  例: 画面キャプチャ内非表示 1 OFF
 *      1番のピクチャをキャプチャに含むようにします
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function () {
    'use strict';
    //=============================================================================
    // ユーザ書き換え領域 - 開始 -
    //  高度な設定を記述しています。必要な場合は書き換えてください。
    //=============================================================================
    var settings = {
        /* 署名のフォント情報です。faceはあらかじめフォントをロードしておかなければ使えません */
        signature: { face: 'GameFont', color: 'rgba(255,255,255,1.0)', align: 'right' },
        /* 効果音情報です。ファイル名はプラグイン管理画面から取得します */
        se: { volume: 90, pitch: 100, pan: 0 },
        /* テストプレー以外での動作を無効にするフラグです */
        testOnly: true
    };
    //=============================================================================
    // ユーザ書き換え領域 - 終了 -
    //=============================================================================
    var pluginName = 'MakeScreenCapture';
    const WAIT_MODE = "MSC_LOAD";

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

    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' || (value || '').toUpperCase() === 'TRUE';
    };

    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 Utils.isNwjs() ? convertEnvironmentVariable(name) : name;
        }
        return null;
    };

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

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

    var convertEnvironmentVariable = function (text) {
        if (text == null) text = '';
        text = text.replace(/%(\w+)%/gi, function () {
            return process.env[arguments[1]] || '';
        }.bind(this));
        return text;
    };

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

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramFuncKeyPngCapture = getParamString(['FuncKeyPngCapture', 'PNGキャプチャキー']);
    var paramFuncKeyJpegCapture = getParamString(['FuncKeyJpegCapture', 'JPEGキャプチャキー']);
    var paramFuncKeyWebpCapture = getParamString(['FuncKeyWebpCapture', 'WEBPキャプチャキー']);
    var paramFileName = getParamString(['FileName', 'ファイル名']);
    var paramLocation = getParamString(['Location', '出力場所']);
    var paramFileFormat = getParamString(['FileFormat', '保存形式']).toLowerCase();
    var paramSignature = getParamString(['Signature', '署名']);
    var paramSignatureImage = getParamString(['SignatureImage', '署名画像']);
    var paramSignatureSize = getParamNumber(['SignatureSize', '署名サイズ']);
    var paramNumberDigit = getParamNumber(['NumberDigit', '連番桁数']);
    var paramInterval = getParamNumber(['Interval', '実行間隔']);
    var paramSeName = getParamString(['SeName', '効果音']);
    var paramTimeStamp = getParamBoolean(['TimeStamp', 'タイムスタンプ']);
    var paramJpegQuality = getParamNumber(['JpegQuality', 'JPEG品質']);
    var paramSimultaneousCtrl = getParamBoolean(['SimultaneousCtrl', 'Ctrl同時押し']);
    var paramSimultaneousAlt = getParamBoolean(['SimultaneousAlt', 'Alt同時押し']);

    const stateHiddenOnCaptureNumberSet = new Set();

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

    Game_Interpreter.prototype.pluginCommandMakeScreenCapture = function (command, args) {
        switch (getCommandName(command)) {
            case 'MSC_MAKE':
            case '画面キャプチャ作成':
                SceneManager.makeCapture();
                break;
            case 'MSC_PICTURE':
            case '画面キャプチャピクチャ':
                $gameScreen.captureFlg = true;
                break;
            case 'MSC_LOAD':
            case '画面キャプチャ読込':
                this.setWaitMode(WAIT_MODE)
                loadPngImage(Number(args[0]), Number(args[1]), args[2]);
                break;
            case 'MSC_SAVE':
            case '画面キャプチャ保存':
                SceneManager.saveCapture(getArgString(args[0]) || paramFileName, paramFileFormat, parseInt(args[1]) || 0);
                break;
            case 'MSC_HIDDEN':
            case '画面キャプチャ内非表示':
                var pictureId = parseInt(args[0]);
                if (isNaN(pictureId) || $gameScreen.maxPictures() < pictureId) {
                    console.warn(`${getCommandName(command)} 不正なピクチャー番号${args[0]}が指定されています`);
                    break;
                }
                if ((args[1] || "").toUpperCase() === "ON") {
                    stateHiddenOnCaptureNumberSet.add(pictureId);
                } else {
                    stateHiddenOnCaptureNumberSet.delete(pictureId);
                }
                break;
        }
    };

    //=============================================================================
    // Game_Screen
    //  キャプチャピクチャ用のプロパティを追加定義します。
    //=============================================================================
    var _Game_Screen_clear = Game_Screen.prototype.clear;
    Game_Screen.prototype.clear = function () {
        _Game_Screen_clear.apply(this, arguments);
        this.clearCapturePicture();
    };

    Game_Screen.prototype.clearCapturePicture = function () {
        this.captureFlg = false;
    };

    //=============================================================================
    // Game_Picture
    //  キャプチャピクチャ用のプロパティを追加定義します。
    //=============================================================================
    var _Game_Picture_show = Game_Picture.prototype.show;
    Game_Picture.prototype.show = function (name, origin, x, y, scaleX,
        scaleY, opacity, blendMode) {
        if ($gameScreen.captureFlg) {
            arguments[0] = Date.now().toString();
            this.captureFlg = true;
        } else {
            this.captureFlg = null;
        }
        $gameScreen.clearCapturePicture();
        _Game_Picture_show.apply(this, arguments);
    };

    //=============================================================================
    // Scene_Base
    //  定期実行キャプチャを定義します。
    //=============================================================================
    var _Scene_Base_update = Scene_Base.prototype.update;
    Scene_Base.prototype.update = function () {
        _Scene_Base_update.apply(this, arguments);
        var count = Graphics.frameCount;
        if (paramInterval !== 0 && Utils.isTestCapture() && (count + 1) % (paramInterval * 60) === 0) {
            SceneManager.takeCapture();
        }
    };

    //=============================================================================
    // Sprite_Picture
    //  画像の動的生成を追加定義します。
    //=============================================================================
    var _Sprite_Picture_loadBitmap = Sprite_Picture.prototype.loadBitmap;
    Sprite_Picture.prototype.loadBitmap = function () {
        if (this.picture().captureFlg) {
            this.bitmap = SceneManager.getCapture();
        } else {
            _Sprite_Picture_loadBitmap.apply(this, arguments);
        }
    };

    //=============================================================================
    // Utils
    //  テスト用のキャプチャを許可するかどうかを返します。
    //=============================================================================
    Utils.isTestCapture = function () {
        return !settings.testOnly || Utils.isOptionValid('test');
    };

    //=============================================================================
    // Bitmap
    //  対象のビットマップを保存します。現状、ローカル環境下でのみ動作します。
    //=============================================================================
    Bitmap.prototype.save = function (fileName, format, extend) {
        if (extend.saveVariableNumber <= 0) {
            let data = this._canvas.toDataURL('image/' + format, extend.quality);
            data = data.replace(/^.*,/, '');
            if (format === 'jpeg') format = 'jpg';
            if (data) StorageManager.saveImg(fileName, format, data);
            return;
        }
        const value = $gameVariables.value(extend.saveVariableNumber);
        window.SteganographyLibrary.embed(this, value)
            .then(function (bitmap) {
                return new Promise((resolve, reject) => {
                    if (format !== "png") {
                        return reject();
                    }
                    bitmap._canvas.toBlob(async function (blob) {
                        if (!blob) {
                            return reject();
                        }
                        const reader = new FileReader();
                        reader.addEventListener("loadend", function () {
                            try {
                                const embedBuffer = window.SteganographyLibrary.embedChunk(reader.result, value);
                                const binaryString = window.SteganographyLibrary.bufferToBinaryString(embedBuffer);
                                resolve(window.btoa(binaryString));
                            } catch (e) {
                                reject(e);
                            }
                        }, { once: true });
                        reader.addEventListener("abort", reject, { once: true });
                        reader.addEventListener("error", reject, { once: true });
                        reader.readAsArrayBuffer(blob);
                    }, format, extend.quality)
                });
            })
            .then(function (dataUrl) {
                const data = dataUrl.replace(/^.*,/, '');
                if (format === 'jpeg') format = 'jpg';
                if (data) StorageManager.saveImg(fileName, format, data);
            }, (e) => {
                const dataUrl = this._canvas.toDataURL('image/' + format, extend.quality);
                const data = dataUrl.replace(/^.*,/, '');
                if (format === 'jpeg') format = 'jpg';
                if (data) StorageManager.saveImg(fileName, format, data);
            });
    };

    Bitmap.prototype.sign = function (text, fontInfo) {
        this.fontFace = fontInfo.face;
        this.fontSize = fontInfo.size;
        this.textColor = fontInfo.color;
        this.drawText(text, 8, this.height - this.fontSize - 8, this.width - 8 * 2, this.fontSize, fontInfo.align);
    };

    Bitmap.prototype.signAndSave = function (signature, fileName, format, signatureImage, saveVariableNumber) {
        var fileFullPath = StorageManager.getLocalImgFileName(fileName);
        if (signatureImage) {
            this.signImage(signatureImage, signature);
        }
        this.sign(convertEscapeCharacters(paramSignature), signature);
        this.save(fileFullPath, format, {
            quality: format === 'jpeg' ? paramJpegQuality / 10 : undefined,
            saveVariableNumber
        });
    };

    Bitmap.prototype.signImage = function (signBitmap, fontInfo) {
        var dx = 0, dy = this.height - signBitmap.height;
        switch (fontInfo.align) {
            case 'center':
                dx = this.width / 2 - signBitmap.width / 2;
                break;
            case 'right':
                dx = this.width - signBitmap.width;
                break;
        }
        this.blt(signBitmap, 0, 0, signBitmap.width, signBitmap.height, dx, dy);
    };

    //=============================================================================
    // Input
    //  ファンクションキーのマップを定義します。
    //=============================================================================
    Input.functionReverseMapper = {
        F1: 112,
        F2: 113,
        F3: 114,
        F4: 115,
        F5: 116,
        F6: 117,
        F7: 118,
        F8: 119,
        F9: 120,
        F10: 121,
        F11: 122,
        F12: 123
    };

    //=============================================================================
    // SceneManager
    //  ファンクションキーが押下されたときにキャプチャを実行します。
    //=============================================================================
    SceneManager.captureNumber = 0;
    SceneManager.makeCapture = function () {
        if (paramSeName) {
            var se = settings.se;
            se.name = paramSeName;
            AudioManager.playSe(se);
        }
        this.beforeCapture();
        this._captureBitmap = this.snap();
        this.afterCapture();
    };

    SceneManager.beforeCapture = function () {
        // 非表示指定のピクチャーを不可視状態とする
        const scene = SceneManager._scene;
        if (!scene._spriteset) {
            return;
        }
        const pictureContainer = scene._spriteset._pictureContainer;
        stateHiddenOnCaptureNumberSet.forEach(function (pictureId) {
            const picture = $gameScreen.picture(pictureId);
            if (!picture || !picture.name()) {
                return;
            }
            const pictureSprite = pictureContainer.children.find(function (pictureSprite) {
                return pictureSprite._pictureId === pictureId;
            });
            pictureSprite.visible = false;
        });
    }

    SceneManager.afterCapture = function () {
        // 標準版スクリプトではフレーム更新時に再表示されるため、明示的にフラグを戻す必要はない
    }

    SceneManager.getCapture = function () {
        return this._captureBitmap || ImageManager.loadEmptyBitmap();
    };

    SceneManager.saveCapture = function (fileName, format, saveVariableNumber) {
        if (!this._captureBitmap) return;
        var signature = this.getSignature();
        if (paramSignatureImage) {
            var image = ImageManager.loadPicture(paramSignatureImage, 0);
            image.addLoadListener(function () {
                this._captureBitmap.signAndSave(signature, fileName, format, image, saveVariableNumber);
            }.bind(this));
        } else {
            this._captureBitmap.signAndSave(signature, fileName, format, null, saveVariableNumber);
        }
    };

    SceneManager.getSignature = function () {
        var signature = settings.signature;
        signature.size = paramSignatureSize;
        return signature;
    };

    SceneManager.takeCapture = function (format) {
        if (!format) {
            format = paramFileFormat;
        }
        this.makeCapture();
        this.saveCapture(paramFileName, format, null);
    };

    var _SceneManager_setupErrorHandlers = SceneManager.setupErrorHandlers;
    SceneManager.setupErrorHandlers = function () {
        _SceneManager_setupErrorHandlers.apply(this, arguments);
        if (Utils.isTestCapture()) {
            document.addEventListener('keyup', this.onKeyUpForCapture.bind(this));
        }
    };

    var _SceneManager_onKeyDown = SceneManager.onKeyDown;
    SceneManager.onKeyDown = function (event) {
        _SceneManager_onKeyDown.apply(this, arguments);
        if (paramSimultaneousCtrl === event.ctrlKey && paramSimultaneousAlt === event.altKey && Utils.isTestCapture()) {
            this.onKeyDownForCapture(event);
        }
    };

    SceneManager.onKeyDownForCapture = function (event) {
        switch (event.keyCode) {
            case Input.functionReverseMapper[paramFuncKeyPngCapture]:
                SceneManager.takeCapture('png');
                break;
            case Input.functionReverseMapper[paramFuncKeyJpegCapture]:
                SceneManager.takeCapture('jpeg');
                break;
            case Input.functionReverseMapper[paramFuncKeyWebpCapture]:
                SceneManager.takeCapture('webp');
                break;
        }
    };

    SceneManager.onKeyUpForCapture = function (event) {
        // PrintScreen
        if (event.keyCode === 44) SceneManager.takeCapture();
    };

    //=============================================================================
    // StorageManager
    //  イメージファイルを保存します。
    //=============================================================================
    StorageManager.saveImg = function (fileName, format, data) {
        if (this.isLocalMode()) {
            this.saveImgToLocalFile(fileName + '.' + format, data);
        } else {
            this.saveImgToWebStorage(fileName, data);
        }
    };

    StorageManager.saveImgToWebStorage = function (fileName, data) {
        localStorage.setItem(fileName, data);
    };

    StorageManager.saveImgToLocalFile = function (fileName, data) {
        var fs = require('fs');
        var dirPath = this.localImgFileDirectoryPath();
        var filePath = dirPath + fileName;
        if (!fs.existsSync(dirPath)) {
            fs.mkdirSync(dirPath);
        }
        fs.writeFileSync(filePath, new Buffer(data, 'base64'));
    };

    StorageManager.localImgFileDirectoryPath = function () {
        var filePath = paramLocation;
        if (!filePath.match(/^[A-Z]:/)) {
            var path = require('path');
            filePath = path.join(path.dirname(process.mainModule.filename), filePath);
        }
        return decodeURIComponent(filePath.match(/\/$/) ? filePath : filePath + '/');
    };

    StorageManager.getLocalImgFileName = function (fileName) {
        if (paramTimeStamp) {
            var date = new Date();
            return fileName + '_' + date.getFullYear() + (date.getMonth() + 1).padZero(2) + date.getDate().padZero(2) +
                '_' + date.getHours().padZero(2) + date.getMinutes().padZero(2) + date.getSeconds().padZero(2);
        } else {
            var number = SceneManager.captureNumber;
            if (number >= Math.pow(10, paramNumberDigit)) number = 0;
            SceneManager.captureNumber = number + 1;
            return fileName + (number > 0 ? number.padZero(paramNumberDigit) : '');
        }
    };

    //=============================================================================
    // ファイル読み込み
    //=============================================================================
    function createChangeEvent(resultSwitchNumber, readValueVariableNumber, errorValue) {
        return function (e) {
            const path = e.target.value;
            if (!path || !e.target.files.length) {
                return loadCancelEvent(resultSwitchNumber);
            }
            const file = e.target.files[0];
            e.target.value = "";
            if (file.type !== "image/png") {
                SoundManager.playBuzzer();
                $gameSwitches.setValue(resultSwitchNumber, 0);
                window.alert("対応していないファイルが選択されました");
                Graphics.endLoading();
                imgLoadProcessing = false;
                return;
            }
            const url = URL.createObjectURL(file);
            Decrypter._ignoreList.push(url);
            const bitmap = Bitmap.load(url);
            bitmap.addLoadListener(URL.revokeObjectURL.bind(URL, url));
            SceneManager._captureBitmap = bitmap;

            if (!readValueVariableNumber) {
                bitmap.addLoadListener(function () {
                    $gameSwitches.setValue(resultSwitchNumber, 1);
                    imgLoadProcessing = false;
                });
                Graphics.endLoading();
                return;
            }

            new Promise((resolve, reject) => {
                bitmap.addLoadListener(function () {
                    window.SteganographyLibrary.digUp(bitmap).then(resolve, reject);
                })
                setTimeout(reject, 3000);
            }).catch(function () {
                const fs = nw.require('fs');
                return new Promise((resolve, reject) => {
                    fs.readFile(path, function (err, data) {
                        if (err) {
                            return Promise.reject(err);
                        }
                        const Signature = String.fromCharCode(137, 80, 78, 71, 13, 10, 26, 10);
                        let rpos = 0;
                        if (String.fromCharCode.apply(null, data.subarray(rpos, rpos += 8)) !== Signature) {
                            throw new Error('invalid signature');
                        }
                        try {
                            const result = window.SteganographyLibrary.digUpChunk(data);
                            resolve(result);
                        } catch (e) {
                            reject(e);
                        }
                    });
                });
            }).then(function (loadedValue) {
                Graphics.endLoading();
                $gameSwitches.setValue(resultSwitchNumber, 1);
                if (loadedValue === undefined) {
                    $gameVariables.setValue(readValueVariableNumber, errorValue);
                    return;
                }
                $gameVariables.setValue(readValueVariableNumber, loadedValue);
            }, function (err) {
                SoundManager.playBuzzer();
                Graphics.endLoading();
                $gameSwitches.setValue(resultSwitchNumber, 0);
                console.error(err);
            }).finally(() => {
                imgLoadProcessing = false;
            });
        };
    }

    function loadCancelEvent(resultSwitchNumber) {
        SoundManager.playCancel();
        $gameSwitches.setValue(resultSwitchNumber, 0);
        Graphics.endLoading();
        imgLoadProcessing = false;
    }

    let imgLoadProcessing = false;
    let input;

    function loadPngImage(resultSwitchNumber, readValueVariableNumber, errorValue) {
        if (!Utils.isNwjs()) {
            return;
        }
        Graphics.startLoading();
        input = document.createElement("input");
        input.type = "file";
        input.accept = "image/png";
        input.id = "MSC_FILE";
        input.value = "";

        imgLoadProcessing = true;
        input.addEventListener("cancel", loadCancelEvent.bind(null, resultSwitchNumber), { once: true });
        input.addEventListener("change", createChangeEvent(resultSwitchNumber, readValueVariableNumber, errorValue), { once: true });
        input.click();
    }

    const Game_Interpreter_updateWaitMode = Game_Interpreter.prototype.updateWaitMode;
    Game_Interpreter.prototype.updateWaitMode = function () {
        if (this._waitMode === WAIT_MODE) {
            return imgLoadProcessing;
        }
        return Game_Interpreter_updateWaitMode.apply(this, arguments);
    }
})();