code:
//=============================================================================
// NRP_ParallaxesPlus.js
//=============================================================================
/*:
 * @target MZ
 * @plugindesc v1.002 Display parallaxes freely.
 * @author Takeshi Sunagawa (http://newrpg.seesaa.net/)
 * @url http://newrpg.seesaa.net/article/488413806.html
 *
 * @help Provides the ability to display parallaxes at will.
 * You can display as many parallaxes as you like,
 * at any coordinates, in any range, and with any display priority.
 * They can also be used during battle.
 *
 * Although the term "parallax" is used,
 * it can be used for various purposes by changing the display priority.
 * ※e.g., clouds displayed on top of a map.
 *
 * You can also change the settings of the parallaxes once displayed.
 * Feel free to change the scrolling speed and display coordinates.
 *
 * -------------------------------------------------------------------
 * [Usage]
 * -------------------------------------------------------------------
 * Invoke plugin commands as needed.
 *
 * Note that there is no function to reflect the map settings themselves.
 * I think it would be better to use parallel processing (+Erase Event),
 * etc., to display the map immediately after the map starts.
 *
 * -------------------------------------------------------------------
 * [Plugin Commands MZ]
 * -------------------------------------------------------------------
 * ◆AddParallax
 * Add Parallax to the current map or battle screen.
 * See [Setting Items] for details.
 *
 * ◆ChangeParallax
 * Manipulate & change Parallax information for the specified ID.
 * Unspecified items inherit the settings at the time of creation.
 *
 * ◆RemoveParallax
 * Removes the Parallax with the specified ID.
 * If ID is not specified, all Parallaxes will be removed.
 *
 * -------------------------------------------------------------------
 * [Script For MV]
 * -------------------------------------------------------------------
 * This plugin does not support plugin commands for MV,
 * but can be called from MV via an external plugin.
 *
 * The following is an example using callPluginCommandMZ.js(unagi ootoro).
 * https://raw.githubusercontent.com/unagiootoro/RPGMZ/master/callPluginCommandMZ.js
 *
 * Note that it is executed by a script, not a plugin command.
 * ※Check the definitions of item
 *   and command names in the JS file on your own.
 * -------------------------------------------------------------------
 * // Basic
 * const args = {};
 * args.Image = "StarlitSky"; // parallaxes file
 * args.Z = 0.5;
 * args.MapX = 2;
 * args.MapY = 2;
 * args.Width = 240;
 * args.Height= 240;
 * args.ParallaxTile = true;
 *
 * // Options
 * args.Options = {};
 * args.Options.BlendMode = 1;
 *
 * // execute
 * callPluginCommand(this, "NRP_ParallaxesPlus", "AddParallax", args);
 *
 * -------------------------------------------------------------------
 * [Setting Items]
 * -------------------------------------------------------------------
 * Items that can be used with the plugin commands
 * (AddParallax / ChangeParallax).
 * The basic items are the same as for normal Parallax,
 * but some of them are explained below.
 *
 * ◆Z
 * Z coordinate (priority) to be displayed.
 * The meaning of the Z-coordinate is as follows.
 *
 * 0 : Lower tiles
 * 1 : Lower characters
 * 3 : Normal characters
 * 4 : Upper tiles
 * 5 : Upper characters
 * 6 : Airship shadow
 * 7 : Balloon
 * 8 : Animation
 * 9 : Touch Operation Destination
 *
 * For example, if you want to display between "Lower tiles"
 * and "Lower characters", you can set a value such as "z = 0.5".
 * The default value is -1,
 * because it is displayed below the Lower tiles.
 *
 * Note that it cannot be displayed
 * below the standard Parallax of RPG Maker.
 *
 * ◆ParallaxTile
 * Make Parallax scroll the same way as tiles when the screen scrolls.
 * (Same behavior as when the filename is prefixed
 *  with ! at the beginning of the filename)
 *
 * For more detailed settings, see "Options > ParallaxX, ParallaxY".
 *
 * ◆MapX, MapY
 * Place Parallax at the specified coordinates on the map.
 * The specified coordinates will be the starting point (upper left).
 * The end point should be controlled by "Width" and "Height".
 *
 * ◆Options > ParallaxX, ParallaxY
 * Set the details of the linkage method when scrolling the screen.
 * Settings take precedence over "ParallaxTile".
 *
 * "Screen" is not affected by scrolling at all.
 * "Tile" scrolls like a tile. (Same as ParallaxTile)
 * "1/2 Speed" scrolls at 1/2 the speed of tile.
 *  (Same behavior as when Loop Horizontally / Vertically is turned on)
 *
 * If not specified, it will be "Screen", but if the filename
 * starts with "! at the beginning of the file name,
 * it will be treated as a "Tile".
 *
 * You can also set other numbers
 * by changing to text mode when entering.
 * For example, if you set 2,
 * it will scroll twice as fast as the tile.
 *
 * ◆Options > NoLoopX, NoLoopY
 * Displays images that do not loop like pictures.
 *
 * -------------------------------------------------------------------
 * [Behavior during battle]
 * -------------------------------------------------------------------
 * It behaves much the same as the map scene,
 * but with the following caveats.
 *
 * ◆Z
 * Setting Z-coordinates does not work by default.
 * Must be used in conjunction with a plugin that enables
 * Z-coordinate sorting (display priority change),
 * such as NRP_DynamicMotionMZ.js.
 *
 * Also, by default, Parallax cannot be displayed
 * behind the battle background.
 * If necessary, turn on the plugin parameter "UseBattlebackSort".
 *
 * ◆MapX, MapY
 * The behavior is almost the same as in the map scene.
 * During battle, there are no tiles, so 1 square = 48 pixels.
 *
 * -------------------------------------------------------------------
 * [Terms]
 * -------------------------------------------------------------------
 * There are no restrictions.
 * Modification, redistribution freedom, commercial availability,
 * and rights indication are also optional.
 * The author is not responsible,
 * but will deal with defects to the extent possible.
 *
 * @------------------------------------------------------------------
 * @ [Plugin Commands]
 * @------------------------------------------------------------------
 *
 * @command AddParallax
 * @desc Add Parallax to the current map or battle screen.
 *
 * @arg Id
 * @desc ID to manage Parallax.
 * Can be omitted if no further operations are performed.
 *
 * @arg Image
 * @type file
 * @dir img/parallaxes/
 * @desc Parallax image file to be displayed.
 *
 * @arg Z
 * @default -1
 * @desc Priority. 0:Lower tile, 1:Lower character, 3:Normal character,
 * 4:Upper tile, 5:Upper character, 7:Balloon, 8:Animation
 *
 * @arg ParallaxTile
 * @type boolean
 * @desc When scrolling the screen, link Parallax to the tiles.
 * If not specified, the file name ! in the file name.
 *
 * @arg ScrollX
 * @type string
 * @desc Horizontal scrolling speed. Formula available.
 *
 * @arg ScrollY
 * @type string
 * @desc Vertical scrolling speed. Formula available.
 *
 * @arg MapX
 * @desc X-coordinate of the map where the image will be placed.
 * 1 square = 48 pixels, even in battle. Formula available.
 *
 * @arg MapY
 * @desc Y-coordinate of the map where the image will be placed.
 * 1 square = 48 pixels, even in battle. Formula available.
 *
 * @arg Width
 * @desc Width to display Parallax. Formula available.
 *
 * @arg Height
 * @desc Height to display Parallax. Formula available.
 *
 * @arg Opacity
 * @type number
 * @max 255
 * @default 255
 * @desc The opacity of the image; 255 makes it completely opaque.
 *
 * @arg Options
 * @type struct<Option>
 *
 * @------------------------------------------------------------------
 *
 * @command ChangeParallax
 * @desc Manipulate & change Parallax information for the specified ID.
 * Unspecified items inherit the settings at the time of creation.
 *
 * @arg Id
 * @desc ID of the Parallax to be operated.
 *
 * @arg Image
 * @type file
 * @dir img/parallaxes/
 * @desc Parallax image file to be displayed.
 *
 * @arg Z
 * @desc Priority. 0:Lower tile, 1:Lower character, 3:Normal character,
 * 4:Upper tile, 5:Upper character, 7:Balloon, 8:Animation
 *
 * @arg ParallaxTile
 * @type boolean
 * @desc When scrolling the screen, link Parallax to the tiles.
 * If not specified, the file name ! in the file name.
 *
 * @arg ScrollX
 * @type string
 * @desc Horizontal scrolling speed. Formula available.
 *
 * @arg ScrollY
 * @type string
 * @desc Vertical scrolling speed. Formula available.
 *
 * @arg MapX
 * @desc X-coordinate of the map where the image will be placed.
 * 1 square = 48 pixels, even in battle. Formula available.
 *
 * @arg MapY
 * @desc Y-coordinate of the map where the image will be placed.
 * 1 square = 48 pixels, even in battle. Formula available.
 *
 * @arg Width
 * @desc Width to display Parallax. Formula available.
 *
 * @arg Height
 * @desc Height to display Parallax. Formula available.
 *
 * @arg Opacity
 * @type number
 * @max 255
 * @desc The opacity of the image; 255 makes it completely opaque.
 *
 * @arg Options
 * @type struct<Option>
 *
 * @------------------------------------------------------------------
 *
 * @command RemoveParallax
 * @desc Removes the Parallax with the specified ID.
 * If ID is not specified, all Parallaxes will be removed.
 *
 * @arg Id
 * @desc ID of the Parallax to be removed.
 *
 * @------------------------------------------------------------------
 * @ [Plugin Parameters]
 * @------------------------------------------------------------------
 * @param UseBattlebackSort
 * @type boolean
 * @default false
 * @desc Activate the display priority (Z-sort) of the battleback.
 * Be sure to use in conjunction with a plugin that performs Z-sort.
 *
 * @param Battleback1Z
 * @parent UseBattlebackSort
 * @type number @min -99999 @max 99999 @decimals 2
 * @default 0
 * @desc Display priority for Battle Background 1 (below).
 *
 * @param Battleback2Z
 * @parent UseBattlebackSort
 * @type number @min -99999 @max 99999 @decimals 2
 * @default 0.5
 * @desc Display priority for Battle Background 2 (above).
 */
//-----------------------------------------------------------------------------
// Option
//-----------------------------------------------------------------------------
/*~struct~Option:
 * @param ShiftX
 * @desc Adjustment value for the X-coordinate at which the image is displayed. Formula available.
 *
 * @param ShiftY
 * @desc Adjustment value for the Y-coordinate at which the image is displayed. Formula available.
 *
 * @param ParallaxX
 * @type select
 * @option @value
 * @option Screen @value 0
 * @option Tile @value 1
 * @option 1/2 Speed @value 0.5
 * @desc Sets the parallax in the horizontal direction when scrolling the screen.
 *
 * @param ParallaxY
 * @type select
 * @option @value
 * @option Screen @value 0
 * @option Tile @value 1
 * @option 1/2 Speed @value 0.5
 * @desc Sets the parallax in the vertical direction when scrolling the screen.
 *
 * @param NoLoopX
 * @type boolean
 * @desc Disables the parallax horizontal loop to match the image width.
 * Takes precedence over the width specification.
 *
 * @param NoLoopY
 * @type boolean
 * @desc Disables the parallax vertical loop to match the image width.
 * Takes precedence over the height specification.
 *
 * @param BlendMode
 * @type select
 * @option 0:Normal @value 0
 * @option 1:Add @value 1
 * @option 2:Multiply @value 2
 * @option 3:Screen @value 3
 * @desc This is a method of blending images.
 */

/*:ja
 * @target MZ
 * @plugindesc v1.002 自在に遠景（近景）を表示します。
 * @author 砂川赳（http://newrpg.seesaa.net/）
 * @url http://newrpg.seesaa.net/article/488413806.html
 *
 * @help 自在に遠景（近景）を表示する機能を提供します。
 * 好きな座標、好きな範囲、好きな表示優先度で、
 * 好きなだけ遠景を表示できます。
 * また、戦闘時にも使用可能です。
 *
 * 『遠景』という言葉を使用していますが、
 * 表示優先度を変更すれば、近景として表示することもできます。
 * ※例：マップの上に表示する雲など。
 *
 * 一度表示した遠景の設定を変更することもできます。
 * スクロール速度や表示座標を自由に変更してください。
 *
 * -------------------------------------------------------------------
 * ■使用方法
 * -------------------------------------------------------------------
 * 必要に応じてプラグインコマンドを呼び出してください。
 *
 * なお、マップの設定自体に反映させる機能はありません。
 * 並列処理（＋イベントの一時消去）などを利用して、
 * マップ開始直後に表示すればよいと思います。
 *
 * -------------------------------------------------------------------
 * ■プラグインコマンド（ＭＺ）
 * -------------------------------------------------------------------
 * ◆遠景を追加
 * 遠景（近景）を現在のマップまたは戦闘画面に作成＆追加します。
 * 詳細は『設定項目』をご覧ください。
 *
 * ◆遠景を変更
 * 指定ＩＤの遠景（近景）情報を操作＆変更します。
 * 未指定の項目は作成時の設定を引き継ぎます。
 *
 * ◆遠景を削除
 * 指定したＩＤの遠景（近景）を削除します。
 * ＩＤ未指定なら全削除します。
 *
 * -------------------------------------------------------------------
 * ■スクリプト（ＭＶ）
 * -------------------------------------------------------------------
 * 当プラグインはＭＶ用のプラグインコマンドに対応していませんが、
 * 外部プラグインを経由すれば、ＭＶから呼び出すことも可能です。
 *
 * 以下はcallPluginCommandMZ.js（うなぎおおとろ様）を使用した例です。
 * https://raw.githubusercontent.com/unagiootoro/RPGMZ/master/callPluginCommandMZ.js
 *
 * プラグインコマンドではなく、スクリプトで実行することに注意してください。
 * ※項目名、コマンド名は自力でJSファイル内の定義を確認してください。
 * -------------------------------------------------------------------
 * // 基本項目
 * const args = {};
 * args.Image = "StarlitSky"; // parallaxesのファイル
 * args.Z = 0.5;
 * args.MapX = 2;
 * args.MapY = 2;
 * args.Width = 240;
 * args.Height= 240;
 * args.ParallaxTile = true;
 *
 * // オプション項目
 * args.Options = {};
 * args.Options.BlendMode = 1;
 *
 * // 実行
 * callPluginCommand(this, "NRP_ParallaxesPlus", "AddParallax", args);
 *
 * -------------------------------------------------------------------
 * ■設定項目
 * -------------------------------------------------------------------
 * プラグインコマンド（遠景を追加・変更）で使用できる項目です。
 * 基本的な項目は通常の遠景に準じますが、一部を解説します。
 *
 * ◆Ｚ座標
 * 表示する優先度です。
 * Ｚ座標の意味は以下の通りです。
 *
 * 0 : 下層タイル
 * 1 : 通常キャラの下
 * 3 : 通常キャラ
 * 4 : 上層タイル
 * 5 : 通常キャラの上
 * 6 : 飛行船の影
 * 7 : 吹き出し
 * 8 : アニメーション
 * 9 : タッチ操作の移動先
 *
 * 例えば『下層タイル』と『通常キャラの下』の間に表示をしたい場合は
 * 『z = 0.5』などの値を設定できます。
 * 初期値は-1としていますが、これは下層タイルよりも下に表示するためです。
 *
 * なお、ツクール標準の遠景より下に表示することはできません。
 *
 * ◆視差をタイルに連動
 * 画面スクロール時に遠景をタイルと同じようにスクロールさせます。
 * （ファイル名の先頭に!を付けた時の動作と同じ）
 *
 * さらに詳細な設定を行う場合は、
 * 『オプション　＞　Ｘ、Ｙ方向の視差』をご覧ください。
 *
 * ◆マップＸ、Ｙ座標
 * マップ上の指定した座標に遠景を配置します。
 * 指定した座標が始点（左上）になります。
 * 終点は『横幅』『縦幅』で制御してください。
 *
 * ◆オプション　＞　Ｘ、Ｙ方向の視差
 * 画面スクロール時の連動方法を詳細に設定します。
 * 設定は『視差をタイルに連動』よりも優先されます。
 *
 * 『画面固定』はスクロールの影響を一切受けません。
 * 『タイル』はタイルと同じようにスクロールします。
 * （視差をタイルに連動と同じ）
 * 『1/2倍速』はタイルの1/2倍速でスクロールします。
 * （横／縦方向にループをオンにした時の動作と同じ）
 *
 * 未指定の場合は『画面固定』になりますが、
 * ファイル名の先頭が『!』ならば『タイル』として扱います。
 *
 * また、入力時にテキストモードへ変更すれば、
 * それ以外の数値も設定できます。
 * 例えば、2を設定すればタイルの２倍速でスクロールします。
 *
 * ◆オプション　＞　ループなし（横／縦）
 * ピクチャのようにループしない画像表示を行います。
 *
 * -------------------------------------------------------------------
 * ■戦闘中の挙動について
 * -------------------------------------------------------------------
 * マップ画面とほぼ同じ挙動ですが、以下の注意点があります。
 *
 * ◆Ｚ座標
 * 標準ではＺ座標を設定しても機能しません。
 * NRP_DynamicMotionMZ.jsなどのＺ座標ソート（表示優先度変更）を
 * 有効にするプラグインと併用する必要があります。
 *
 * また、初期状態では戦闘背景より後ろに遠景を表示することはできません。
 * 必要な場合はプラグインパラメータの
 * 『戦闘背景の表示優先度を設定』をオンにしてください。
 *
 * ◆マップＸ、Ｙ座標
 * マップ画面とほぼ同じ挙動になります。
 * 戦闘中はタイルが存在しませんので、1マス=48ピクセルとして計算します。
 *
 * -------------------------------------------------------------------
 * ■利用規約
 * -------------------------------------------------------------------
 * 特に制約はありません。
 * 改変、再配布自由、商用可、権利表示も任意です。
 * 作者は責任を負いませんが、不具合については可能な範囲で対応します。
 *
 * @------------------------------------------------------------------
 * @ プラグインコマンド
 * @------------------------------------------------------------------
 *
 * @command AddParallax
 * @text 遠景を追加
 * @desc 遠景（近景）を現在のマップまたは戦闘画面に追加します。
 *
 * @arg Id
 * @text ＩＤ
 * @desc 遠景を管理するＩＤです。
 * 以降の操作を行わない場合は省略可能です。
 *
 * @arg Image
 * @text 画像
 * @type file
 * @dir img/parallaxes/
 * @desc 表示する遠景の画像ファイルです。
 *
 * @arg Z
 * @text Ｚ座標
 * @default -1
 * @desc 表示優先度。0:下層, 1:キャラ下, 3:キャラ, 4:上層
 * 5:キャラ上, 6:飛行船影, 7:フキダシ, 8:アニメ, 9:目的地
 *
 * @arg ParallaxTile
 * @text 視差をタイルに連動
 * @type boolean
 * @desc 画面スクロール時、遠景をタイルに連動させます。
 * 未指定の場合はファイル名の!で判定します。
 *
 * @arg ScrollX
 * @text Ｘ方向のスクロール
 * @type string
 * @desc 横方向へのスクロール速度です。数式可。
 *
 * @arg ScrollY
 * @text Ｙ方向のスクロール
 * @type string
 * @desc 縦方向へのスクロール速度です。数式可。
 *
 * @arg MapX
 * @text マップＸ座標
 * @desc 画像を配置するマップのＸ座標です。数式可。
 * 戦闘時も1マス=48ピクセルで計算。
 *
 * @arg MapY
 * @text マップＹ座標
 * @desc 画像を配置するマップのＹ座標です。数式可。
 * 戦闘時も1マス=48ピクセルで計算。
 *
 * @arg Width
 * @text 横幅
 * @desc 遠景を表示する横幅です。数式可。
 *
 * @arg Height
 * @text 縦幅
 * @desc 遠景を表示する縦幅です。数式可。
 *
 * @arg Opacity
 * @text 不透明度
 * @type number
 * @max 255
 * @default 255
 * @desc 画像の不透明度です。0～255が有効。
 *
 * @arg Options
 * @text オプション
 * @type struct<Option>
 *
 * @------------------------------------------------------------------
 *
 * @command ChangeParallax
 * @text 遠景を変更
 * @desc 指定ＩＤの遠景（近景）情報を操作＆変更します。
 * 未指定の項目は作成時の設定を引き継ぎます。
 *
 * @arg Id
 * @text ＩＤ
 * @desc 操作対象とする遠景のＩＤです。
 *
 * @arg Image
 * @text 画像
 * @type file
 * @dir img/parallaxes/
 * @desc 表示する遠景の画像ファイルです。
 *
 * @arg Z
 * @text Ｚ座標
 * @desc 表示優先度。0:下層, 1:キャラ下, 3:キャラ, 4:上層
 * 5:キャラ上, 6:飛行船影, 7:フキダシ, 8:アニメ, 9:目的地
 *
 * @arg ParallaxTile
 * @text 視差をタイルに連動
 * @type boolean
 * @desc 画面スクロール時、遠景をタイルに連動させます。
 * 未指定の場合はファイル名の!で判定します。
 *
 * @arg ScrollX
 * @text Ｘ方向のスクロール
 * @type string
 * @desc 横方向へのスクロール速度です。数式可。
 *
 * @arg ScrollY
 * @text Ｙ方向のスクロール
 * @type string
 * @desc 縦方向へのスクロール速度です。数式可。
 *
 * @arg MapX
 * @text マップＸ座標
 * @desc 画像を配置するマップのＸ座標です。数式可。
 * 戦闘時も1マス=48ピクセルで計算。
 *
 * @arg MapY
 * @text マップＹ座標
 * @desc 画像を配置するマップのＹ座標です。数式可。
 * 戦闘時も1マス=48ピクセルで計算。
 *
 * @arg Width
 * @text 横幅
 * @desc 遠景を表示する横幅です。数式可。
 *
 * @arg Height
 * @text 縦幅
 * @desc 遠景を表示する縦幅です。数式可。
 *
 * @arg Opacity
 * @text 不透明度
 * @type number
 * @max 255
 * @desc 画像の不透明度です。0～255が有効。
 *
 * @arg Options
 * @text オプション
 * @type struct<Option>
 *
 * @------------------------------------------------------------------
 *
 * @command RemoveParallax
 * @text 遠景を削除
 * @desc 指定したＩＤの遠景（近景）を削除します。
 * ＩＤ未指定なら全削除します。
 *
 * @arg Id
 * @text ＩＤ
 * @desc 削除対象とする遠景のＩＤです。
 *
 * @------------------------------------------------------------------
 * @ プラグインパラメータ
 * @------------------------------------------------------------------
 * @param UseBattlebackSort
 * @text 戦闘背景の表示優先度を設定
 * @type boolean
 * @default false
 * @desc 戦闘背景の表示優先度（Ｚ座標ソート）を有効化します。
 * 必ずＺ座標ソートを行うプラグインと併用してください。
 *
 * @param Battleback1Z
 * @parent UseBattlebackSort
 * @text 戦闘背景１のＺ座標
 * @type number @min -99999 @max 99999 @decimals 2
 * @default 0
 * @desc 戦闘背景１（下）の表示優先度です。
 *
 * @param Battleback2Z
 * @parent UseBattlebackSort
 * @text 戦闘背景２のＺ座標
 * @type number @min -99999 @max 99999 @decimals 2
 * @default 0.5
 * @desc 戦闘背景１（上）の表示優先度です。
 */
//-----------------------------------------------------------------------------
// Option
//-----------------------------------------------------------------------------
/*~struct~Option:ja
 * @param ShiftX
 * @text シフトＸ
 * @desc 画像を表示するＸ座標の調整値です。数式可。
 *
 * @param ShiftY
 * @text シフトＹ
 * @desc 画像を表示するＹ座標の調整値です。数式可。
 *
 * @param ParallaxX
 * @text Ｘ方向の視差
 * @type select
 * @option @value
 * @option 画面固定 @value 0
 * @option タイル @value 1
 * @option 1/2倍速 @value 0.5
 * @desc 画面スクロール時、横方向の視差を設定します。
 *
 * @param ParallaxY
 * @text Ｙ方向の視差
 * @type select
 * @option @value
 * @option 画面固定 @value 0
 * @option タイル @value 1
 * @option 1/2倍速 @value 0.5
 * @desc 画面スクロール時、縦方向の視差を設定します。
 *
 * @param NoLoopX
 * @text ループなし（横）
 * @type boolean
 * @desc 遠景の横ループを無効にして、画像幅に合わせます。
 * 横幅の指定より優先されます。
 *
 * @param NoLoopY
 * @text ループなし（縦）
 * @type boolean
 * @desc 遠景の縦ループを無効にして、画像幅に合わせます。
 * 縦幅の指定より優先されます。
 *
 * @param BlendMode
 * @text 合成方法
 * @type select
 * @option 0:通常 @value 0
 * @option 1:加算 @value 1
 * @option 2:乗算 @value 2
 * @option 3:スクリーン @value 3
 * @desc 画像の合成方法です。
 */

(function() {
"use strict";

function toBoolean(str, def) {
    if (str === true || str === "true") {
        return true;
    } else if (str === false || str === "false") {
        return false;
    }
    return def;
}
function toNumber(str, def) {
    if (str == undefined || str == "") {
        return def;
    }
    return isNaN(str) ? def : +(str || def);
}
function setDefault(str, def) {
    if (str == undefined || str == "") {
        return def;
    }
    return str;
}

const PLUGIN_NAME = "NRP_ParallaxesPlus";
const parameters = PluginManager.parameters(PLUGIN_NAME);
const pUseBattlebackSort = toBoolean(parameters["UseBattlebackSort"], false);
const pBattleback1Z = toNumber(parameters["Battleback1Z"], 0);
const pBattleback2Z = toNumber(parameters["Battleback2Z"], 0.5);

//-----------------------------------------------------------------------------
// ＭＺ用プラグインコマンド
//-----------------------------------------------------------------------------

// MVには存在しないため、空で定義しておかないとエラーになる。
if (!PluginManager.registerCommand) {
    PluginManager.registerCommand = function() {}
}

/**
 * ●遠景の追加
 */
PluginManager.registerCommand(PLUGIN_NAME, "AddParallax", function(args) {
    const params = {};
    params.id = setDefault(args.Id);
    params.name = setDefault(args.Image);
    params.scrollX = setDefault(args.ScrollX, 0);
    params.scrollY = setDefault(args.ScrollY, 0);
    params.mapX = eval(args.MapX);
    params.mapY = eval(args.MapY);
    params.width = eval(args.Width);
    params.height = eval(args.Height);
    params.z = eval(setDefault(args.Z, -1));
    params.parallaxTile = toBoolean(args.ParallaxTile);

    // 視差をタイルに連動
    if (params.parallaxTile === true) {
        params.parallaxX = 1;
        params.parallaxY = 1;
    // 標準（画面固定）
    } else if (params.parallaxTile === false) {
        params.parallaxX = 0;
        params.parallaxY = 0;
    // 視差の指定がない場合はファイル名で判定
    } else {
        params.parallaxX = ImageManager.isZeroParallax(params.name) ? 1 : 0;
        params.parallaxY = params.parallaxX;
    }
    params.opacity = setDefault(args.Opacity, 255);
    params.blendMode = 0;

    // オプション項目の設定
    if (args.Options) {
        const option = JSON.parse(args.Options);
        params.shiftX = eval(option.ShiftX);
        params.shiftY = eval(option.ShiftY);
        if (isNotBlank(option.ParallaxX)) {
            params.parallaxX = eval(option.ParallaxX);
        }
        if (isNotBlank(option.ParallaxY)) {
            params.parallaxY = eval(option.ParallaxY);
        }
        params.noLoopX = toBoolean(option.NoLoopX, false);
        params.noLoopY = toBoolean(option.NoLoopY, false);
        params.blendMode = toNumber(option.BlendMode, 0);
    }

    // 遠景オブジェクトを生成
    const parallax = createParallaxPlus(params);

    const spriteset = getSpriteset();
    // 追加の遠景リストに登録
    spriteset._parallaxPlus.push(parallax);
    // 戦闘とマップで異なる場所に登録
    // ※それぞれＺソート対象になる要素
    if ($gameParty.inBattle()) {
        spriteset._battleField.addChild(parallax);
    } else {
        spriteset._tilemap.addChild(parallax);
        $gameMap.setParallaxPlus();
    }
});

/**
 * ●追加背景の作成
 */
function createParallaxPlus(params) {
    const parallax = new ParallaxPlus();
    setParallaxData(parallax, params);
    return parallax;
}

/**
 * ●背景データの設定
 * ※セーブ保存用のデータとも共有
 */
function setParallaxData(parallax, params) {
    parallax.id = params.id;
    parallax.name = params.name;
    parallax.scrollX = params.scrollX;
    parallax.scrollY = params.scrollY;
    parallax.z = params.z;
    parallax.opacity = eval(params.opacity);
    parallax.blendMode = params.blendMode;
    parallax.parallaxX = params.parallaxX;
    parallax.parallaxY = params.parallaxY;
    parallax.shiftX = setDefault(params.shiftX, 0);
    parallax.shiftY = setDefault(params.shiftY, 0);
    parallax.noLoopX = params.noLoopX;
    parallax.noLoopY = params.noLoopY;

    // 引き継ぎ項目
    if (params.origin) {
        parallax.originalWidth = params.originalWidth;
        parallax.originalHeight = params.originalHeight;
        parallax.origin.x = params.origin.x;
        parallax.origin.y = params.origin.y;
        parallax.mapX = params.mapX;
        parallax.mapY = params.mapY;
        parallax.x = params.x;
        parallax.y = params.y;
        parallax.isLimitX = params.isLimitX;
        parallax.isLimitY = params.isLimitY;

    // 初回用の項目
    } else {
        // 元の幅
        parallax.originalWidth = setDefault(params.width);
        parallax.originalHeight = setDefault(params.height);
        parallax.mapX = params.mapX;
        parallax.mapY = params.mapY;
        parallax.x = parallax.shiftX;
        parallax.y = parallax.shiftY;

        // 戦闘時、battleFieldの座標分を補正
        if ($gameParty.inBattle()) {
            const spriteset = getSpriteset();
            parallax.x -= spriteset._battleField.x;
            parallax.y -= spriteset._battleField.y;
        }

        // 幅が指定されているかどうか？
        // ※指定がある場合はズームアウト処理時の補正を行わない。
        if (parallax.noLoopX || params.width != null) {
            parallax.isLimitX = true;
        }
        if (parallax.noLoopY || params.height != null) {
            parallax.isLimitY = true;
        }
    }
}

/**
 * ●遠景情報の変更
 */
PluginManager.registerCommand(PLUGIN_NAME, "ChangeParallax", function(args) {
    const id = setDefault(args.Id);

    const params = {};
    params.name = setDefault(args.Image);
    params.scrollX = setDefault(args.ScrollX);
    params.scrollY = setDefault(args.ScrollY);
    params.mapX = eval(args.MapX);
    params.mapY = eval(args.MapY);
    params.width = eval(args.Width);
    params.height = eval(args.Height);
    params.z = eval(args.Z);
    params.opacity = eval(args.Opacity);
    params.parallaxTile = toBoolean(args.ParallaxTile);

    // 視差をタイルに連動
    if (params.parallaxTile === true) {
        params.parallaxX = 1;
        params.parallaxY = 1;
    // 標準（画面固定）
    } else if (params.parallaxTile === false) {
        params.parallaxX = 0;
        params.parallaxY = 0;
    }

    // オプション項目の設定
    if (args.Options) {
        const option = JSON.parse(args.Options);
        params.shiftX = eval(option.ShiftX);
        params.shiftY = eval(option.ShiftY);
        params.parallaxX = eval(option.ParallaxX);
        params.parallaxY = eval(option.ParallaxY);
        params.noLoopX = toBoolean(option.NoLoopX);
        params.noLoopY = toBoolean(option.NoLoopY);
        params.blendMode = setDefault(option.BlendMode);
    }

    const spriteset = getSpriteset();
    // 対象の遠景を取得
    const targetParallaxes = spriteset._parallaxPlus.filter(p => id == null || p.id == id);
    // 変更を反映
    for (const parallax of targetParallaxes) {
        // 基本項目
        parallax.name = changeValue(parallax.name, params.name);
        parallax.scrollX = changeValue(parallax.scrollX, params.scrollX);
        parallax.scrollY = changeValue(parallax.scrollY, params.scrollY);
        parallax.mapX = changeValue(parallax.mapX, params.mapX);
        parallax.mapY = changeValue(parallax.mapY, params.mapY);
        parallax.z = changeValue(parallax.z, params.z);
        parallax.opacity = changeValue(parallax.opacity, params.opacity);
        parallax.parallaxTile = changeValue(parallax.parallaxTile, params.parallaxTile);

        // 特殊な調整をする項目
        parallax.originalWidth = changeValue(parallax.originalWidth, params.width);
        parallax.originalHeight = changeValue(parallax.originalHeight, params.height);

        // オプション項目
        parallax.shiftX = changeValue(parallax.shiftX, params.shiftX);
        parallax.shiftY = changeValue(parallax.shiftY, params.shiftY);
        parallax.parallaxX = changeValue(parallax.parallaxX, params.parallaxX);
        parallax.parallaxY = changeValue(parallax.parallaxY, params.parallaxY);
        parallax.noLoopX = changeValue(parallax.noLoopX, params.noLoopX);
        parallax.noLoopY = changeValue(parallax.noLoopY, params.noLoopY);
        parallax.blendMode = changeValue(parallax.blendMode, params.blendMode);
    }

    // $gameMapに反映
    if (!$gameParty.inBattle()) {
        $gameMap.setParallaxPlus();
    }
});

/**
 * ●新しい値がある場合のみ反映する。
 */
function changeValue(current, newValue) {
    if (newValue != null) {
        return newValue;
    }
    return current;
}

/**
 * ●遠景の削除
 */
PluginManager.registerCommand(PLUGIN_NAME, "RemoveParallax", function(args) {
    const id = setDefault(args.Id);
    const spriteset = getSpriteset();

    // 遠景を削除
    // ※ＩＤが未指定の場合は全てが対象
    const deleteParallaxes = spriteset._parallaxPlus.filter(p => id == null || p.id == id);
    for (const parallax of deleteParallaxes) {
        spriteset._parallaxPlus.remove(parallax);

        // 戦闘とマップで異なる場所に登録されている
        if ($gameParty.inBattle()) {
            spriteset._battleField.removeChild(parallax);
        } else {
            spriteset._tilemap.removeChild(parallax);
        }
    }

    // $gameMapに反映
    if (!$gameParty.inBattle()) {
        $gameMap.setParallaxPlus();
    }
});

//-----------------------------------------------------------------------------
// ParallaxPlus
//
// 追加の遠景を定義するクラス

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

ParallaxPlus.prototype = Object.create(TilingSprite.prototype);
ParallaxPlus.prototype.constructor = ParallaxPlus;

ParallaxPlus.prototype.initialize = function() {
    TilingSprite.prototype.initialize.call(this);
};

/**
 * ●サイズを設定する。
 */
ParallaxPlus.prototype.setSize = function() {
    const bmp = this.bitmap;

    //-------------------------------------------------
    // 基本サイズの設定
    //-------------------------------------------------
    // 横幅が設定されていない場合→初期設定を行う
    if (this.originalWidth == null) {
        // ループしない場合は画像幅に合わせる。
        if (this.noLoopX) {
            this.originalWidth = bmp.width;
        // それ以外は画像幅と画面幅の大きなほう。
        } else {
            this.originalWidth = Math.max(bmp.width, Graphics.width);
        }
    }
    // 縦幅が設定されていない場合→初期設定を行う
    if (this.originalHeight == null) {
        // ループしない場合は画像幅に合わせる。
        if (this.noLoopY) {
            this.originalHeight = bmp.height;
        // それ以外は画像幅と画面幅の大きなほう。
        } else {
            this.originalHeight = Math.max(bmp.height, Graphics.height);
        }
    }

    //-------------------------------------------------
    // 基本サイズを元に表示サイズを設定
    //-------------------------------------------------
    if (this.isLimitX) {
        this.width = this.originalWidth;
    } else {
        // 指定の幅がない場合はズーム対応
        // ※ズームアウト時に画面全体まで引き伸ばす
        this.width = this.originalWidth / $gameScreen.zoomScale();
    }
    if (this.isLimitY) {
        this.height = this.originalHeight;
    } else {
        // 指定の幅がない場合はズーム対応
        this.height = this.originalHeight / $gameScreen.zoomScale();
    }
};

/**
 * ●マップ座標に配置する際の補正を行う
 */
ParallaxPlus.prototype.setMapPosition = function(diffX, diffY) {
    // マップＸ座標の指定がある場合は補正
    if (this.mapX != null) {
        // 表示座標 = 配置座標 - 現在の画面座標
        this.x = (this.mapX - $gameMap.displayX()) * $gameMap.tileWidth() + this.shiftX;
        // 横ループマップの場合
        if (!$gameParty.inBattle() && $gameMap.isLoopHorizontal()) {
            const mapWidth = $gameMap.width() * $gameMap.tileWidth();
            // 画像が画面外（左）に位置している場合、画面右へ表示されるよう補正
            if (this.x + this.width < 0) {
                this.x += mapWidth;
            }
        }
        // 画像のスクロールを戻す
        this.origin.x -= diffX;
    }
    // マップＹ座標の指定がある場合は補正
    if (this.mapY != null) {
        // 表示座標 = 配置座標 - 現在の画面座標
        this.y = (this.mapY - $gameMap.displayY()) * $gameMap.tileHeight() + this.shiftY;
        // 縦ループマップの場合
        if (!$gameParty.inBattle() && $gameMap.isLoopVertical()) {
            const mapHeight = $gameMap.height() * $gameMap.tileHeight();
            // 画像が画面外（上）に位置している場合、画面下へ表示されるよう補正
            if (this.y + this.height < 0) {
                this.y += mapHeight;
            }
        }
        // 画像のスクロールを戻す
        this.origin.y -= diffY;
    }
}

//-----------------------------------------------------------------------------
// Spriteset_Base
//-----------------------------------------------------------------------------

/**
 * ●更新
 */
const _Spriteset_Base_update = Spriteset_Base.prototype.update;
Spriteset_Base.prototype.update = function() {
    _Spriteset_Base_update.apply(this, arguments);

    // 追加遠景の更新
    this.updateParallaxPlus();
}

/**
 * ●追加遠景の更新
 */
Spriteset_Base.prototype.updateParallaxPlus = function() {
    // 存在しない場合は処理しない。
    if (!this._parallaxPlus || this._parallaxPlus.length == 0) {
        return;
    }

    // スクロール差分を取得
    const diffX = moveScreenX.bind($gameMap)();
    const diffY = moveScreenY.bind($gameMap)();

    for (const parallax of this._parallaxPlus) {
        // ロードしたファイル名と指示されているファイル名が異なる場合
        // ※ロードがまだ、もしくは画像が変更されたと判断
        if (parallax.loadName !== parallax.name) {
            // ロード処理を実行する。
            parallax.loadName = parallax.name;
            parallax.bitmap = ImageManager.loadParallax(parallax.name);
        }

        const bmp = parallax.bitmap;
        // 画像の幅を取得できない場合は終了
        if (!bmp.width) {
            continue;
        }

        // 幅が設定されていない場合に初期設定を行う
        parallax.setSize();

        // 視差に応じて画面スクロール分を加算
        if (parallax.parallaxX) {
            parallax.origin.x += diffX * parallax.parallaxX;
        }
        if (parallax.parallaxY) {
            parallax.origin.y += diffY * parallax.parallaxY;
        }

        // 遠景自体のスクロール値を加算
        parallax.origin.x += eval(parallax.scrollX);
        parallax.origin.y += eval(parallax.scrollY);

        // マップ座標の指定がある場合は補正
        parallax.setMapPosition(diffX, diffY);
    }
};

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

/**
 * ●下層スプライトの作成
 */
const _Spriteset_Map_createLowerLayer = Spriteset_Map.prototype.createLowerLayer;
Spriteset_Map.prototype.createLowerLayer = function() {
    _Spriteset_Map_createLowerLayer.apply(this, arguments);

    this.createParallaxPlus();
};

/**
 * ●追加遠景の作成
 */
Spriteset_Map.prototype.createParallaxPlus = function() {
    this._parallaxPlus = [];

    // 保存データが存在する場合は復元
    const gameMapParallax = $gameMap._parallaxPlus;
    if (gameMapParallax) {
        for (const params of gameMapParallax) {
            const parallax = createParallaxPlus(params);
            // 追加の遠景リストに登録
            this._parallaxPlus.push(parallax);
            // 表示対象に追加（tilemapの子要素はＺソート対象になる）
            this._tilemap.addChild(parallax);
        }
    }
};

/**
 * 【独自】遠景維持用の一時データを保存する。
 */
Spriteset_Map.prototype.saveParallaxPlusTempData = function() {
    // 遠景情報を$gameMapに保持しておく
    $gameMap.setParallaxPlus(this._parallaxPlus);
};

/**
 * ●セーブ用データの作成
 */
function createSaveParallax(params) {
    // 不要なデータを保存しないため、TilingSpriteではない単なる構造体に変換。
    const parallax = {};
    parallax.origin = {};
    setParallaxData(parallax, params);
    return parallax;
}

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

/**
 * ●下層スプライトの作成
 */
const _Spriteset_Battle_createLowerLayer = Spriteset_Battle.prototype.createLowerLayer;
Spriteset_Battle.prototype.createLowerLayer = function() {
    _Spriteset_Battle_createLowerLayer.apply(this, arguments);

    this.createParallaxPlus();
};

/**
 * ●追加遠景の作成
 */
Spriteset_Battle.prototype.createParallaxPlus = function() {
    this._parallaxPlus = [];
};

//-----------------------------------------------------------------------------
// 戦闘背景の表示優先度変更
//-----------------------------------------------------------------------------

// 使用する場合のみ有効化
if (pUseBattlebackSort) {
    /**
     * ●戦闘背景の作成
     */
    const _Spriteset_Battle_createBattleback = Spriteset_Battle.prototype.createBattleback;
    Spriteset_Battle.prototype.createBattleback = function() {
        _Spriteset_Battle_createBattleback.apply(this, arguments);

        // ※removeしなくても動作するようなので、とりあえずそのまま
        // this._baseSprite.removeChild(this._back1Sprite);
        // this._baseSprite.removeChild(this._back2Sprite);

        // Ｚ座標を設定
        this._back1Sprite.z = pBattleback1Z;
        this._back2Sprite.z = pBattleback2Z;
    };

    /**
     * ●下層の作成
     */
    const _Spriteset_Battle_createLowerLayer = Spriteset_Battle.prototype.createLowerLayer;
    Spriteset_Battle.prototype.createLowerLayer = function() {
        _Spriteset_Battle_createLowerLayer.apply(this, arguments);

        // デフォルトのthis._baseSprite以下ではＺソートの対象にならないので、
        // this._battleField以下に移動
        this._battleField.addChild(this._back1Sprite);
        this._battleField.addChild(this._back2Sprite);

        // this._battleFieldの座標分を補正
        this._back1Sprite.x = -this._battleField.x;
        this._back1Sprite.y = -this._battleField.y;
    };
}

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

let mBeforeDisplayScreenX = 0;
let mBeforeDisplayScreenY = 0;

/**
 * ●初期化
 */
const _Game_Map_initialize = Game_Map.prototype.initialize;
Game_Map.prototype.initialize = function() {
    _Game_Map_initialize.apply(this, arguments);

    // 画面座標を保持
    mBeforeDisplayScreenX = this.displayX() * this.tileWidth();
    mBeforeDisplayScreenY = this.displayY() * this.tileHeight();
};

/**
 * ●更新処理
 */
const _Game_Map_update = Game_Map.prototype.update;
Game_Map.prototype.update = function(sceneActive) {
    // 画面座標を保持
    mBeforeDisplayScreenX = this.displayX() * this.tileWidth();
    mBeforeDisplayScreenY = this.displayY() * this.tileHeight();

    _Game_Map_update.apply(this, arguments);
};

/**
 * 【独自】追加の遠景データをセットする。
 */
Game_Map.prototype.setParallaxPlus = function() {
    const spriteParallaxPlus = getSpriteset()._parallaxPlus;

    // 遠景情報を$gameMapに保持しておく
    this._parallaxPlus = [];
    for (const parallax of spriteParallaxPlus) {
        // 保存用の形式に変換
        const saveParallax = createSaveParallax(parallax);
        this._parallaxPlus.push(saveParallax);
    }
};

/**
 * 【独自】１フレームでスクロールしたスクリーンＸ座標
 * ※NRP_DynamicAnimationMapMZとほぼ同じ関数
 */
function moveScreenX() {
    // 戦闘中は無効
    if ($gameParty.inBattle()) {
        return 0;
    }

    // 現在の座標と前回の座標を比較し差分を求める。
    const displayScreenX = this.displayX() * this.tileWidth();
    let moveScreenX = displayScreenX - mBeforeDisplayScreenX;

    // マップ全体の横幅（ピクセル）
    const mapWidth = this.width() * this.tileWidth();
    // 全体座標の半分以上を移動した（ループ）
    if (moveScreenX > mapWidth / 2) {
        moveScreenX -= mapWidth;
    } else if (moveScreenX < mapWidth / 2 * -1) {
        moveScreenX += mapWidth;
    }

    return moveScreenX;
};

/**
 * 【独自】１フレームでスクロールしたスクリーンＹ座標
 * ※NRP_DynamicAnimationMapMZとほぼ同じ関数
 */
function moveScreenY() {
    // 戦闘中は無効
    if ($gameParty.inBattle()) {
        return 0;
    }

    // 現在の座標と前回の座標を比較し差分を求める。
    const displayScreenY = this.displayY() * this.tileHeight();
    let moveScreenY = displayScreenY - mBeforeDisplayScreenY;

    // マップ全体の縦幅（ピクセル）
    const mapHeight = this.height() * this.tileHeight();
    // 全体座標の半分以上を移動した（ループ）
    if (moveScreenY > mapHeight / 2) {
        moveScreenY -= mapHeight;
    } else if (moveScreenY < mapHeight / 2 * -1) {
        moveScreenY += mapHeight;
    }

    return moveScreenY;
};

//-----------------------------------------------------------------------------
// シーン切替時の情報保持
//-----------------------------------------------------------------------------

/**
 * ●場所移動
 */
const _Scene_Map_updateTransferPlayer = Scene_Map.prototype.updateTransferPlayer;
Scene_Map.prototype.updateTransferPlayer = function() {
    if ($gamePlayer.isTransferring()) {
        // 場所移動したので$gameMapのデータをクリア
        clearParallaxData();
    }
    _Scene_Map_updateTransferPlayer.apply(this, arguments);
};

/**
 * ●シーン変更
 */
const _SceneManager_changeScene = SceneManager.changeScene;
SceneManager.changeScene = function() {
    if (this.isSceneChanging() && !this.isCurrentSceneBusy()) {
        // Scene_Mapから移動する場合
        if (this._scene && this._scene instanceof Scene_Map) {
            // 場所移動時
            if ($gamePlayer.isTransferring()) {
                // 同一マップの場合は遠景状態を保持
                if ($gamePlayer.newMapId() == $gameMap.mapId()) {
                    $gameMap.setParallaxPlus();
                // マップが変化した場合は$gameMapのデータクリア
                } else {
                    clearParallaxData();
                }

            // 遠景状態を保持
            } else {
                $gameMap.setParallaxPlus();
            }
        }
    }
    _SceneManager_changeScene.apply(this, arguments);
};

/**
 * ●$gameMapの遠景データをクリアする。
 */
function clearParallaxData() {
    $gameMap._parallaxPlus = undefined;
}

//-----------------------------------------------------------------------------
// 共通
//-----------------------------------------------------------------------------

/**
 * ●空白チェック
 */
function isNotBlank(str) {
    return str != "" && str != null;
}

/**
 * ●現在の画面のSpritesetを取得する。
 */
function getSpriteset() {
    return SceneManager._scene._spriteset;
}

})();

repo_name: onms/sister

license: unknown


code:
//=============================================================================
// NRP_WindowBattleLogLayout.js
//=============================================================================
/*:
 * @target MV MZ
 * @plugindesc v1.04 Change the layout of the battle log.
 * @author Takeshi Sunagawa (http://newrpg.seesaa.net/)
 * @orderAfter SimpleMsgSideViewMZ
 * @url http://newrpg.seesaa.net/article/474864758.html
 *
 * @help Change the layout of the battle log.
 * You can change the position and size of the window.
 *
 * [Main features]
 * - You can use the official SimpleMsgSideView plugin together.
 * - You can use gradations.
 * - Switch to normal window.
 * - You can change the background color and transparency.
 * - When the message is long, it shrinks to fit the width of the window.
 * - There is also a function to adjust the window width to the string length.
 *
 * [Described in the skills note]
 * <NoName>
 * Hide the skill name when using it.
 *
 * For more information, please see below.
 * http://newrpg.seesaa.net/article/474864758.html
 *
 * [Terms]
 * There are no restrictions.
 * Modification, redistribution freedom, commercial availability,
 * and rights indication are also optional.
 * The author is not responsible,
 * but we will respond to defects as far as possible.
 *
 * @param <Window Position>
 * @desc Set up the position of the window.
 *
 * @param x
 * @parent <Window Position>
 * @type text
 * @default 0
 * @desc The X coordinate of the window.
 *
 * @param y
 * @parent <Window Position>
 * @type text
 * @default 0
 * @desc The Y coordinate of the window.
 *
 * @param showFront
 * @parent <Window Position>
 * @type boolean
 * @default false
 * @desc Show the window in the front.
 * However, it's not guaranteed for windows generated by the following plugins.
 *
 * @param <Window Size>
 * @desc Configure the window size settings.
 *
 * @param width
 * @parent <Window Size>
 * @type text
 * @default this.windowWidth()
 * @desc The width of the window.
 * The initial value is "this.windowWidth()". This will fit the width of the screen.
 *
 * @param autoWidth
 * @parent <Window Size>
 * @type boolean
 * @default false
 * @desc Automatically adjusts the width of the window according to the number of characters.
 *
 * @param lineHeight
 * @parent <Window Size>
 * @type number
 * @default 36
 * @desc The height of one line.
 * The default value is 36.
 *
 * @param <Window Message>
 * @desc Configure the window messages.
 *
 * @param fontSize
 * @parent <Window Message>
 * @type number
 * @default 28
 * @desc Specify the size of the font.
 * The default value is 28.
 *
 * @param padding
 * @parent <Window Message>
 * @type number
 * @default 18
 * @desc Specify the padding of the message.
 * The default value is 18.
 *
 * @param <Window Background>
 * @desc Set the background of the window.
 *
 * @param normalWindow
 * @parent <Window Background>
 * @type boolean
 * @default false
 * @desc Change to the same window as the normal message.
 *
 * @param backColor
 * @parent <Window Background>
 * @type text
 * @default #000000
 * @desc The background color. (RGB value in hex, Default: #000000)
 * This doesn't make sense in the normal window.
 *
 * @param backPaintOpacity
 * @parent <Window Background>
 * @type number
 * @default 64
 * @desc The opacity of background. (Default: 64)
 * This doesn't make sense in the normal window.
 *
 * @param gradientType
 * @parent <Window Background>
 * @type select
 * @option 0:none @value 0
 * @option 1:horizontal @value 1
 * @option 2:vertical @value 2
 * @default 0
 * @desc This is the gradation type of the window.
 * This doesn't make sense in the normal window.
 *
 * @param startGradientSize
 * @parent <Window Background>
 * @type text
 * @default 18
 * @desc The gradient width of the start side.
 * (Default: 18)
 *
 * @param endGradientSize
 * @parent <Window Background>
 * @type text
 * @default 18
 * @desc The gradient width of the end side.
 * (Default: 18)
 */

/*:ja
 * @target MV MZ
 * @plugindesc v1.04 戦闘メッセージのレイアウトを変更します。
 * @author 砂川赳（http://newrpg.seesaa.net/）
 * @orderAfter SimpleMsgSideViewMZ
 * @url http://newrpg.seesaa.net/article/474864758.html
 *
 * @help 戦闘メッセージのレイアウトを変更します。
 * ウィンドウの配置や大きさを変更可能です。
 *
 * ■主な特徴
 * ・公式プラグインのSimpleMsgSideViewに対応。
 * ・グラデーションに対応。
 * ・通常ウィンドウに切替可能。
 * ・背景色や透明度を変更可能。
 * ・メッセージが長い場合、ウィンドウ幅に合わせて縮小。
 * ・反対に文字列長にウィンドウ幅を合わせる機能も有。
 *
 * ■スキルのメモ欄に記述
 * <NoName>
 * スキル使用時、技名を非表示にします。
 *
 * その他、詳細は以下をご覧ください。
 * http://newrpg.seesaa.net/article/474864758.html
 *
 * ■利用規約
 * 特に制約はありません。
 * 改変、再配布自由、商用可、権利表示も任意です。
 * 作者は責任を負いませんが、不具合については可能な範囲で対応します。
 *
 * @param <Window Position>
 * @text ＜配置関連＞
 * @desc 配置関連の設定を行います。
 *
 * @param x
 * @text Ｘ座標
 * @parent <Window Position>
 * @type text
 * @default 0
 * @desc ウィンドウのＸ座標です。
 *
 * @param y
 * @text Ｙ座標
 * @parent <Window Position>
 * @type text
 * @default 0
 * @desc ウィンドウのＹ座標です。
 *
 * @param showFront
 * @text 前面表示する
 * @parent <Window Position>
 * @type boolean
 * @default false
 * @desc ウィンドウを前面表示します。
 * ※下位のプラグインのウィンドウに対しては未保証。
 *
 * @param <Window Size>
 * @text ＜サイズ関連＞
 * @desc ウィンドウのサイズ関連の設定を行います。
 *
 * @param width
 * @text 横幅
 * @parent <Window Size>
 * @type text
 * @default this.windowWidth()
 * @desc ウィンドウの横幅です。
 * 初期値はthis.windowWidth()で画面横幅に合わせます。
 *
 * @param autoWidth
 * @text 横幅を文字数に合わせる
 * @parent <Window Size>
 * @type boolean
 * @default false
 * @desc ウィンドウの横幅を文字数に合わせて自動調整します。
 *
 * @param lineHeight
 * @text 一行の縦幅
 * @parent <Window Size>
 * @type number
 * @default 36
 * @desc 一行の縦幅です。
 * 初期値は36です。
 *
 * @param <Window Message>
 * @text ＜メッセージ関連＞
 * @desc ウィンドウのメッセージ関連の設定を行います。
 *
 * @param fontSize
 * @text フォントサイズ
 * @parent <Window Message>
 * @type number
 * @default 28
 * @desc フォントの大きさを指定します。
 * 初期値は28です。
 *
 * @param padding
 * @text メッセージの余白
 * @parent <Window Message>
 * @type number
 * @default 18
 * @desc メッセージの余白を指定します。
 * 初期値は18です。
 *
 * @param <Window Background>
 * @text ＜背景関連＞
 * @desc ウィンドウの背景関連の設定を行います。
 *
 * @param normalWindow
 * @text 通常ウィンドウにする
 * @parent <Window Background>
 * @type boolean
 * @default false
 * @desc 通常メッセージと同様のウィンドウに変更します。
 *
 * @param backColor
 * @text 背景色
 * @parent <Window Background>
 * @type text
 * @default #000000
 * @desc 背景色を指定します。（16進数のRGB値、初期値:#000000）
 * 通常ウィンドウでは意味がありません。
 *
 * @param backPaintOpacity
 * @text 背景不透明度
 * @parent <Window Background>
 * @type number
 * @default 64
 * @desc 背景の不透明度を指定します。（初期値:64）
 * 通常ウィンドウでは意味がありません。
 *
 * @param gradientType
 * @text グラデーション方式
 * @parent <Window Background>
 * @type select
 * @option 0:なし @value 0
 * @option 1:横 @value 1
 * @option 2:縦 @value 2
 * @default 0
 * @desc ウィンドウのグラデーション方式です。
 * 通常ウィンドウでは意味がありません。
 *
 * @param startGradientSize
 * @text 開始グラデーション幅
 * @parent <Window Background>
 * @type text
 * @default 18
 * @desc 開始側のグラデーション幅です。
 * 初期値は18です。
 *
 * @param endGradientSize
 * @text 終了グラデーション幅
 * @parent <Window Background>
 * @type text
 * @default 18
 * @desc 終了側のグラデーション幅です。
 * 初期値は18です。
 */
(function() {
"use strict";

function toNumber(str, def) {
    return isNaN(str) ? def : +(str || def);
}
function toBoolean(str) {
    if (str == true) {
        return true;
    }
    return (str == "true") ? true : false;
}

const parameters = PluginManager.parameters("NRP_WindowBattleLogLayout");
const pX = parameters["x"];
const pY = parameters["y"];
const pWidth = parameters["width"];
const pAutoWidth = toBoolean(parameters["autoWidth"]);
const pLineHeight = toNumber(parameters["lineHeight"]);
const pNormalWindow = toBoolean(parameters["normalWindow"]);
const pShowFront = toBoolean(parameters["showFront"]);
const pFontSize = toNumber(parameters["fontSize"]);
const pPadding = toNumber(parameters["padding"]);
const pBackColor = parameters["backColor"];
const pBackPaintOpacity = toNumber(parameters["backPaintOpacity"]);
const pGradientType = parameters["gradientType"];
const pStartGradientSize = parameters["startGradientSize"];
const pEndGradientSize = parameters["endGradientSize"];

if (pShowFront) {
    /**
     * ●全ウィンドウ作成
     */
    const _Scene_Battle_createAllWindows = Scene_Battle.prototype.createAllWindows;
    Scene_Battle.prototype.createAllWindows = function() {
        _Scene_Battle_createAllWindows.apply(this, arguments);

        // 一旦削除して再追加（前面表示）
        this._windowLayer.removeChild(this._logWindow);
        this.createLogWindow();
    };
}

/**
 * ●アクション表示
 */
const _Window_BattleLog_displayAction = Window_BattleLog.prototype.displayAction;
Window_BattleLog.prototype.displayAction = function(subject, item) {
    // eval参照用
    var a = getBattlerSprite(subject);

    // 横幅設定
    var width;
    if (pWidth) {
        width = eval(pWidth);
    } else {
        width = this.windowWidth();
    }
    // 自動調整用に最大幅として保持しておく。
    this._maxWidth = width;
    // ウィンドウ幅自動調整以外の場合
    if (!pAutoWidth) {
        // 横幅を反映
        this.width = width;
    }

    // <NoName>の指定があれば非表示
    if (item.meta.NoName) {
        return;
    }

    _Window_BattleLog_displayAction.apply(this, arguments);
}

/**
 * ●ウィンドウ描画の更新
 */
const _Window_BattleLog_refresh = Window_BattleLog.prototype.refresh;
Window_BattleLog.prototype.refresh = function() {
    // ウィンドウ幅自動調整
    if (pAutoWidth) {
        // 各行の中で最大幅を取得
        var maxWidth = 0;

        for (var line of this._lines) {
            var textWidth = this.textWidth(this.convertEscapeCharacters(line));
            var textPaddingWidth = textWidth + this.padding * 2 + this.textPadding() * 2;

            // SimpleMsgSideViewMZのアイコン分を考慮
            if (this._actionIconIndex) {
                textPaddingWidth += ImageManager.iconWidth;
            }

            if (textPaddingWidth > maxWidth) {
                maxWidth = textPaddingWidth;
            }
        }

        // 最大幅を超えた場合は調整
        if (maxWidth > this._maxWidth) {
            maxWidth = this._maxWidth;
        }

        this.width = maxWidth;
    }

    // eval参照用
    var subject = BattleManager._subject;
    if (subject) {
        var a = getBattlerSprite(subject);

        var x;
        if (pX) {
            x = eval(pX);
        } else {
            x = this.x;
        }

        var y;
        if (pY) {
            y = eval(pY);
        } else {
            y = this.y;
        }

        // 位置変更
        this.x = x;
        this.y = y;
    }

    _Window_BattleLog_refresh.apply(this, arguments);
};

/**
 * MVの場合のみ
 */
if (Utils.RPGMAKER_NAME == "MV") {
    /**
     * 【独自実装】文章表示
     */
    Window_BattleLog.prototype.drawTextEx = function(text, x, y) {
        if (text) {
            var textState = { index: 0, x: x, y: y, left: x };
            textState.text = this.convertEscapeCharacters(text);
            textState.height = this.lineHeight();

            this.resetFontSettings();

            // 文字列長がウィンドウの表示領域を超えた場合は縮小
            var textWidth = this.textWidth(textState.text);
            var textSpace = this._maxWidth - this.padding * 2;
            if (textWidth > textSpace) {
                this.contents.fontSize = Math.floor(this.standardFontSize() * textSpace / textWidth);
                textWidth = textSpace;
            }

            while (textState.index < textState.text.length) {
                this.processCharacter(textState);
            }
            return textState.x - x;
        } else {
            return 0;
        }
    };
}

/**
 * ●背景描画
 */
Window_BattleLog.prototype.drawBackground = function() {
    this.getBack().clear();

    // 表示するメッセージがなければ処理しない
    if (this.numLines() == 0) {
        this.opacity = 0;
        this.hide();
        return;
    }

    var rect = this.backRect();
    var w = rect.width;
    var h = rect.height;

    this.show();

    // 行数に応じて縦幅変更
    this.height = h + this.padding * 2;

    // 通常ウィンドウ表示の場合
    if (pNormalWindow) {
        this.opacity = 255;
        return;
    }

    this.getBack().paintOpacity = this.backPaintOpacity();

    var m1 = this.startGradientSize();
    var m2 = this.endGradientSize();

    // 横のグラデーション領域を確保
    if (pGradientType == 1) {
        w -= m1 + m2;

    // 縦のグラデーション領域を確保
    } else if (pGradientType == 2) {
        h -= m1 + m2;
    }

    // var c1 = this.dimColor1();
    var c1 = this.backColor();

    // MZ対応
    if (Utils.RPGMAKER_NAME == "MV") {
        var c2 = this.dimColor2();
    } else {
        var c2 = ColorManager.dimColor2();
    }

    // 非グラデーション部分
    this.getBack().fillRect(rect.x, rect.y, w, h, c1);

    // 横のグラデーション
    if (pGradientType == 1) {
        // 左
        this.getBack().gradientFillRect(rect.x - m1, rect.y, m1, h, c2, c1, false);
        // 右
        this.getBack().gradientFillRect(rect.x + w, rect.y, m2, h, c1, c2, false);

    // 縦のグラデーション
    } else if (pGradientType == 2) {
        // 上
        this.getBack().gradientFillRect(rect.x, rect.y - m1, w, m1, c2, c1, true);
        // 下
        this.getBack().gradientFillRect(rect.x, rect.y + h, w, m2, c1, c2, true);
    }

    this.getBack().paintOpacity = 255;
};

/**
 * 【独自】背景取得
 * MVとMZで変数名が異なるため共通化
 */
Window_BattleLog.prototype.getBack = function() {
    // MV
    if (Utils.RPGMAKER_NAME == "MV") {
        return this._backBitmap;
    // MZ
    } else {
        return this.contentsBack;
    }
}

/**
 * ●背景領域の確保
 */
Window_BattleLog.prototype.backRect = function() {
    var x = 0;
    var padding;
    var width = this.width;

    // MVの場合
    if (Utils.RPGMAKER_NAME == "MV") {
        padding = this.padding;
    // MZの場合
    } else {
        // 計算方法が異なるため余白分を減算
        padding = 0;
        width -= this.padding * 2
    }
    var y = padding;

    // 横グラデーションの場合、領域を確保
    if (pGradientType == 1) {
        x += this.startGradientSize();

    // 縦グラデーションの場合、領域を確保
    } else if (pGradientType == 2) {
        var gradientSize = this.startGradientSize();
        // 初期値の余白より開始グラデーション幅が広い場合のみ設定
        if (gradientSize > padding) {
            y += this.startGradientSize();
        }
    }

    return {
        x: x,
        y: y,
        width: width,
        height: this.numLines() * this.lineHeight()
    };
};

/**
 * 【独自実装】開始側のグラデーションサイズを取得
 */
Window_BattleLog.prototype.startGradientSize = function() {
    if (pStartGradientSize != undefined) {
        return eval(pStartGradientSize);
    }

    // 指定がなければ余白を取得
    return this.padding;
};

/**
 * 【独自実装】終了側のグラデーションサイズを取得
 */
Window_BattleLog.prototype.endGradientSize = function() {
    if (pEndGradientSize != undefined) {
        return eval(pEndGradientSize);
    }

    // 指定がなければ余白を取得
    return this.padding;
};

if (pLineHeight != undefined) {
    /**
     * ●一行の縦幅
     */
    Window_BattleLog.prototype.lineHeight = function() {
        return pLineHeight;
    };
}

if (pFontSize != undefined) {
    /**
     * ●フォントサイズ
     */
    Window_BattleLog.prototype.standardFontSize = function() {
        return pFontSize;
    };
}

if (pPadding != undefined) {
    /**
     * ●ウィンドウの余白
     */
    Window_BattleLog.prototype.standardPadding = function() {
        return pPadding;
    };

    /**
     * ●MZではこちらが参照される。
     */
    if (Utils.RPGMAKER_NAME != "MV") {
        Window_BattleLog.prototype.updatePadding = function() {
            this.padding = pPadding;
        };
    }
}

if (pBackColor != undefined) {
    /**
     * ●背景色
     */
    Window_BattleLog.prototype.backColor = function() {
        return pBackColor;
    };
}

if (pBackPaintOpacity != undefined) {
    /**
     * ●背景不透明度
     */
    Window_BattleLog.prototype.backPaintOpacity = function() {
        return pBackPaintOpacity;
    };
}

/**
 * 指定したバトラーのスプライトを取得する。
 */
function getBattlerSprite(battler) {
    if (!battler) {
        return undefined;
    }

    var sprite;
    var sprites;

    if (battler.isActor()) {
        sprites = BattleManager._spriteset._actorSprites;
    } else {
        sprites = BattleManager._spriteset._enemySprites;
    }

    for (var i = 0; i < sprites.length; i++) {
        var s = sprites[i];
        if (s._battler == battler) {
            sprite = s;
            break;
        }
    }

    // Sprite_Actorのサイズ設定
    setActorSpriteSize(sprite);

    return sprite;
}

/**
 * 指定したアクタースプライトのサイズを設定する。
 */
function setActorSpriteSize(sprite) {
    if (sprite && sprite._battler.isActor()) {
        // Sprite_Actorのサイズが取れないのでeffectTargetのものをセットする。
        // やや強引かも……。
        if (Utils.RPGMAKER_NAME == "MV") {
            sprite.width = sprite._effectTarget.width;
            sprite.height = sprite._effectTarget.height;
        }
    }
}

/**
 * MZ対応
 */
if (Utils.RPGMAKER_NAME == "MZ") {
    Window_BattleLog.prototype.windowWidth = function() {
        return Graphics.boxWidth;
    };

    Window_Base.prototype.textPadding = function() {
        return 6;
    };

    /**
     * SimpleMsgSideViewMZが登録されている場合
     */
    const isSimpleMsgSideViewMZ = PluginManager._scripts.some(function(scriptName) {
        return scriptName == "SimpleMsgSideViewMZ";
    });
    if (isSimpleMsgSideViewMZ) {
        /**
         * ●スキル名の表示
         */
        Window_BattleLog.prototype.drawLineText = function(index) {
            const text = this._lines[index];
            const rect = this.lineRect(index);
            this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);

            let textX = rect.x;
            // 描画可能領域の幅（rect.width）を参照する
            let textDrawWidth = rect.width;

            if (this._actionIconIndex) {
                // 描画可能領域からアイコン幅を減算
                textDrawWidth = rect.width - ImageManager.iconWidth;
                // 実際に描画される文字列長を求める。
                const textWidth = Math.min(this.textWidth(text), textDrawWidth);

                // 中央から文字列長分左へ調整
                const x = (rect.width - textWidth) / 2 - 10;
                this.drawIcon(this._actionIconIndex, x, rect.y + 2);

                // アイコン分、右にずらす
                textX += ImageManager.iconWidth;
            }

            this.drawText(text, textX, rect.y, textDrawWidth, 'center');
        };
    }
}

})();


code:
//=============================================================================
// NYA_InfoMenuWindow2.js
//
// Version
// 2.2.0 2018/09/25 プラグインパラメータで位置や幅などが調整可能になりました。
// 2.1.0 2018/08/01 AltWindowFrameに対応しました。
// 2.0.0 2018/08/31 マップ名とプレイ時間とでウィンドウを分けてみた＆ウィンドウ背景を透明化しました。
// 1.0.0 2018/08/31 試作版完成
//=============================================================================

/*:
 * @plugindesc メニュー画面にマップ名とプレイ時間を追加します。
 * @author Nyatama
 *
 *
 * @param MapName
 * @text マップ名ウィンドウ
 * @default ================================
 *
 * @param InfoVisible_MapName
 * @text 表示する
 * @desc マップ名のウィンドウを表示します
 * @type boolean
 * @on 表示する
 * @off 表示しない
 * @default true
 * @parent MapName
 *
 * @param PosX_MapName
 * @text X軸
 * @desc マップ名のウィンドウのX位置を指定します
 * @type number
 * @default 0
 * @parent MapName
 *
 * @param PosY_MapName
 * @text Y軸
 * @desc マップ名のウィンドウのY位置を指定します
 * @type number
 * @default 462
 * @parent MapName
 *
 * @param Width_MapName
 * @text 幅
 * @desc マップ名のウィンドウの幅を指定します
 * @type number
 * @default 240
 * @parent MapName
 *
 * @param Align_MapName
 * @text 行揃え
 * @desc マップ名の行揃えを指定します
 * @type combo
 * @option right
 * @option center
 * @option left
 * @default center
 * @parent MapName
 *
 * @param Title_MapName
 * @text タイトル
 * @desc マップ名のタイトルを指定します
 * @type string
 * @default ＭＡＰ
 * @parent MapName
 *
 * @param TitleColor_MapName
 * @text タイトルカラー
 * @desc マップ名のタイトルカラーを指定します
 * 例：rgb(132, 170, 255)  #84aaff  white  system
 * @type string
 * @default system
 * @parent MapName
 *
 * @param FrameOpacity_MapName
 * @text 枠の透明度
 * @desc マップ名の枠(背景画像)の透明度を指定します【255:不透明】
 * @type number
 * @min 0
 * @max 255
 * @default 255
 * @parent MapName
 *
 * @param FrameMado_MapName
 * @text MADOのファイル名
 * @desc マップ名のMADOのフレームのファイル名を指定します
 * 空欄の場合MADOが無効になります●オススメ:Window_Status
 * @type combo
 * @option Window_Talk
 * @option Window_Battle
 * @option Window_Status
 * @option Window_Other
 * @default
 * @parent MapName
 *
 * @param PlayTime
 * @text プレイ時間ウィンドウ
 * @default ================================
 *
 * @param InfoVisible_PlayTime
 * @text 表示する
 * @desc プレイ時間のウィンドウを表示します
 * @type boolean
 * @on 表示する
 * @off 表示しない
 * @default true
 * @parent PlayTime
 *
 * @param PosX_PlayTime
 * @text X軸
 * @desc プレイ時間のウィンドウのX位置を指定します
 * @type number
 * @default 0
 * @parent PlayTime
 *
 * @param PosY_PlayTime
 * @text Y軸
 * @desc プレイ時間のウィンドウのY位置を指定します
 * @type number
 * @default 507
 * @parent PlayTime
 *
 * @param Width_PlayTime
 * @text 幅
 * @desc プレイ時間のウィンドウの幅を指定します
 * @type number
 * @default 240
 * @parent PlayTime
 *
 * @param Align_PlayTime
 * @text 行揃え
 * @desc プレイ時間の行揃えを指定します
 * @type combo
 * @option right
 * @option center
 * @option left
 * @default center
 * @parent PlayTime
 *
 * @param Title_PlayTime
 * @text タイトル
 * @desc プレイ時間のタイトルを指定します
 * @type string
 * @default ＴＩＭＥ
 * @parent PlayTime
 *
 * @param TitleColor_PlayTime
 * @text タイトルカラー
 * @desc プレイ時間のタイトルカラーを指定します
 * 例：rgb(132, 170, 255)  #84aaff  white  system
 * @type string
 * @default system
 * @parent PlayTime
  *
 * @param FrameOpacity_PlayTime
 * @text 枠の透明度
 * @desc プレイ時間の枠(背景画像)の透明度を指定します【255:不透明】
 * @type number
 * @min 0
 * @max 255
 * @default 255
 * @parent PlayTime
 *
 * @param FrameMado_PlayTime
 * @text MADOのファイル名
 * @desc プレイ時間のMADOのフレームのファイル名を指定します
 * 空欄の場合MADOが無効になります●オススメ:Window_Status
 * @type combo
 * @option Window_Talk
 * @option Window_Battle
 * @option Window_Status
 * @option Window_Other
 * @default
 * @parent PlayTime
 *
 * @help このプラグインには、プラグインコマンドはありません。

 メニュー画面に、インフォメーションウィンドウを追加します。
 ・現在のマップ名
 ・現在のプレイ時間

 ※フォントサイズを変えたり細かな調整はソースコードを編集してください

 ※MADOを使用する場合AltWindowFrameを有効にする必要があります。
*/

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

(function() {

	var parameters = PluginManager.parameters('NYA_InfoMenuWindow2');
	var InfoVisible_MapName = eval(parameters['InfoVisible_MapName']);
    var PosX_MapName = Number(parameters['PosX_MapName']);
    var PosY_MapName = Number(parameters['PosY_MapName']);
    var Width_MapName = Number(parameters['Width_MapName']);
    var Align_MapName = String(parameters['Align_MapName']);
    var Title_MapName = String(parameters['Title_MapName']);
    var TitleColor_MapName = String(parameters['TitleColor_MapName']);
    var FrameOpacity_MapName = Number(parameters['FrameOpacity_MapName']);
    var FrameMado_MapName = String(parameters['FrameMado_MapName']);

    var InfoVisible_PlayTime = eval(parameters['InfoVisible_PlayTime']);
    var PosX_PlayTime = Number(parameters['PosX_PlayTime']);
    var PosY_PlayTime = Number(parameters['PosY_PlayTime']);
    var Width_PlayTime = Number(parameters['Width_PlayTime']);
    var Align_PlayTime = String(parameters['Align_PlayTime']);
    var Title_PlayTime = String(parameters['Title_PlayTime']);
    var TitleColor_PlayTime = String(parameters['TitleColor_PlayTime']);
    var FrameOpacity_PlayTime = Number(parameters['FrameOpacity_PlayTime']);
    var FrameMado_PlayTime = String(parameters['FrameMado_PlayTime']);

	var _Scene_Menu_create = Scene_Menu.prototype.create;
    Scene_Menu.prototype.create = function() {
        _Scene_Menu_create.call(this);
        // インフォメーションウィンドウの追加
        this.createInformationWindow();
    };

    Scene_Menu.prototype.createInformationWindow = function() {
        if(InfoVisible_MapName){
            this._informationWindowMapName = new Window_InformationMapName();
            this._informationWindowMapName.padding = 0;
            this._informationWindowMapName.opacity = FrameOpacity_MapName;
            this.addWindow(this._informationWindowMapName);
        }

        if(InfoVisible_PlayTime){
            this._informationWindowPlayTime = new Window_InformationPlayTime();
            this._informationWindowPlayTime.padding = 0;
            this._informationWindowPlayTime.opacity = FrameOpacity_PlayTime;
            this.addWindow(this._informationWindowPlayTime);
        }
	};

    var _Scene_Menu_update = Scene_Menu.prototype.update;
    Scene_Menu.prototype.update = function() {
        _Scene_Menu_update.call(this);
        // インフォメーションウィンドウの更新
        if(InfoVisible_MapName) this._informationWindowMapName.refresh();
        if(InfoVisible_PlayTime) this._informationWindowPlayTime.refresh();
    };

    //-----------------------------------------------------------------------------
	// Window_InformationMapName
	//

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

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

	Window_InformationMapName.prototype.initialize = function() {
        var pos_x = PosX_MapName;   // X位置
        var pos_y = PosY_MapName  // Y位置
	    var width = Width_MapName; // 幅
        //var height = this.fittingHeight(1); // 高さ 表示が崩れる為48以上である必要あり
        var height = 208;
        //全体は254
	    Window_Base.prototype.initialize.call(this, pos_x, pos_y, width, height);
	};

	Window_InformationMapName.prototype.refresh = function() {
        this.contents.clear();
        // マップ名
        if(TitleColor_MapName.toUpperCase() == 'SYSTEM'){
            this.changeTextColor(this.systemColor());
        }else{
            this.changeTextColor(TitleColor_MapName);
        }
        this.contents.fontSize = 10;
        this.drawText(Title_MapName, this.standardPadding() + this.textPadding(), -12, 56, 'left');
        this.resetTextColor();
        /* this.contents.fontSize = 28;
        this.drawText($gameMap.displayName(), this.standardPadding() + 5, this.standardPadding(), this._width - 20, Align_MapName); */
        this.contents.fontSize = 22;
        /* this.drawText('ソース内編集,上下254幅', this.standardPadding() + 5, this.standardPadding() +40, this._width - 20, Align_MapName);
        this.drawText('スキルポイント：$gameVariables.value(19)', this.standardPadding() + 5, this.standardPadding() +30, this._width - 20, Align_MapName); */

        this.drawText(" 経過日数：" + $gameVariables.value(20) + "日", this.standardPadding() + 5, this.standardPadding() +105, this._width - 20, 'left');
        this.drawText(" chapter：" + $gameVariables.value(18), this.standardPadding() + 5, this.standardPadding() +145, this._width - 20, 'left');
        //this.drawText(" ----------------", this.standardPadding() + 5, this.standardPadding() +82, this._width - 20, 'left');
        this.drawText(" スキルP：" + $gameActors.actor(1).stsSp(), this.standardPadding() + 5, this.standardPadding() +20, this._width - 20, 'left');
        this.drawText(" 淫欲結晶：" + $gameVariables.value(101) + "個", this.standardPadding() + 5, this.standardPadding() +60, this._width - 20, 'left');
	};

    //以下をコメントアウトすると余白をありにできます。つまり枠を追加できます。
    //余白を入れる場合、MADO(ウィンドウビルダー)によりウィンドウの見た目を変えることができます。
    Window_InformationMapName.prototype.standardPadding = function() {
        return 5;
    };
    //コメントアウトここまで

    //-----------------------------------------------------------------------------
	// Window_InformationPlayTime
	//

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

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

	Window_InformationPlayTime.prototype.initialize = function() {
        var pos_x = PosX_PlayTime;   // X位置
        var pos_y = PosY_PlayTime  // Y位置
	    var width = Width_PlayTime; // 幅
        var height = this.fittingHeight(1); // 高さ 表示が崩れる為48以上である必要あり
	    Window_Base.prototype.initialize.call(this, pos_x, pos_y, width, height);
	};

	Window_InformationPlayTime.prototype.refresh = function() {
        this.contents.clear();
        // プレイ時間
        if(TitleColor_PlayTime.toUpperCase() == 'SYSTEM'){
            this.changeTextColor(this.systemColor());
        }else{
            this.changeTextColor(TitleColor_PlayTime);
        }
        this.contents.fontSize = 10;
        this.drawText(Title_PlayTime, this.standardPadding() + this.textPadding(), -12, 56, 'left');
        this.resetTextColor();
        this.contents.fontSize = 28;
        this.drawText($gameSystem.playtimeText(), this.standardPadding() + 5,this.standardPadding(), this._width - 20, Align_PlayTime);
	};

    //以下をコメントアウトすると余白をありにできます。つまり枠を追加できます。
    //余白を入れる場合、MADO(ウィンドウビルダー)によりウィンドウの見た目を変えることができます。
    Window_InformationPlayTime.prototype.standardPadding = function() {
        return 5;
    };
    //コメントアウトここまで

    //-----------------------------------------------------------------------------
	// AltWindowFrame対応
	//
    var _Scene_Menu_Create = Scene_Menu.prototype.create;
    Scene_Menu.prototype.create = function() {
        _Scene_Menu_Create.call(this);

        if(FrameMado_MapName){
            var _image = ImageManager.loadSystem(FrameMado_MapName);
            this._informationWindowMapName._windowskin = _image;
            this._informationWindowMapName._refreshAllParts();
        }
        if(FrameMado_PlayTime){
            var _image = ImageManager.loadSystem(FrameMado_PlayTime);
            this._informationWindowPlayTime._windowskin = _image;
            this._informationWindowPlayTime._refreshAllParts();
        }
    };

})();


code:
//
// 二つ名ステートエネミー ver1.00
//
// author yana
//

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

/*:
 * @plugindesc ver1.00/二つ名ステートの付いたエネミーをランダムで出現させることができます。
 * @author Yana
 *
 * @param AddNameNum
 * @desc 一度に二つ名ステートをいくつつけられるかの設定です。evalを使用している為、$gameVariablesや計算式が使用できます。
 * @default 0
 *
 * @param AddNameRate
 * @desc 二つ名付与率の補正値を決める変数のIDです。ここで指定した変数の数値%が、各二つ名の付与率に乗算されます。
 * @default 0
 *
 * @param AddNameAnime
 * @desc 二つ名付与されたエネミーに再生されるアニメのIDです。
 * @default 0
 *
 * @help------------------------------------------------------
 * 使い方
 * ------------------------------------------------------
 * エネミーのメモ欄に
 * <二つ名:id,rate%[,Ix:drop%…]>
 * または、
 * <Nickname:id,rate%[,Ix:drop%…]>
 * と記述します。
 *
 * エネミーのメモに
 * <二つ名:21,100%,I1:100%,A1:100%,W1:100%>
 * と記述されていた場合、
 * 100%の確率で21番のステートが付与されたエネミーが出現します。
 * エネミーはステートの名前が通常の名前の前に追加され、このエネミーを倒したとき、
 * 1番のアイテム(I1)、1番の武器(W1)、1番の武器(A1)を100%の確率でドロップします。
 *
 * ステートのメモに
 * <経験値獲得率:x%>
 * または、
 * <ExpRate:x%>
 * と記述すると、そのステートが二つ名ステートとして付与されているエネミーの経験値がx%になります。
 *
 * 同じように、
 * <ゴールド獲得率:x%>
 * または、
 * <GoldRate:x%>
 * と記述すると、そのステ―トが二つ名ステートとして付与されているエネミーのゴールドがx%になります。
 *
 * ※二つ名はメモの上から順に処理されます。
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 */

(function(){

    var parameters = PluginManager.parameters('NamedEnemy');
    var addNameNum = parameters['AddNameNum'];
    var addNameRate = parameters['AddNameRate'];
    var addNameAnime = Number(parameters['AddNameAnime']) || 0;

    var __GEnemy_setup = Game_Enemy.prototype.setup;
    Game_Enemy.prototype.setup = function(enemyId, x, y) {
        this._nicknameStateId = [];
        this._nicknameDrop = [];
        __GEnemy_setup.call(this,enemyId,x,y);
        this.initNickname();
        this.recoverAll();
    };

    Game_Enemy.prototype.initNickname = function() {
        var texts = this.enemy().note.split('\n');
        var num = 0;
        var rate = 1.0;
        if (addNameNum) num = eval(addNameNum);
        if (addNameRate) rate = $gameVariables.value(addNameRate) * 0.01 + 1.0;
        var n = 0;
        for (var i=0,max=texts.length;i<max;i++) {
            if (texts[i].match(/<(?:二つ名|Nickname)[:：](\d+),(\d+)[%％]?,?(.+)?>/)){
                if (Math.random() <= (Number(RegExp.$2) * 0.01) * rate) {
                    this._nicknameStateId.push(parseInt(RegExp.$1, 10));
                    this._nicknameDrop.concat(RegExp.$3.split(','));
                    n++;
                    if (num && num <= n) break;
                }
            }
        }
        if (n > 0 && addNameAnime) this.startAnimation(addNameAnime,false,30);
    };

    var __GEnemy_traitObjects = Game_Enemy.prototype.traitObjects;
    Game_Enemy.prototype.traitObjects = function() {
        var objects = __GEnemy_traitObjects.call(this);
        if (this._nicknameStateId !== []) {
            this._nicknameStateId.forEach(function(stateId){
                objects.push($dataStates[stateId]);
            }.bind(this));
        }
        return objects;
    };

    var __GEnemy_name = Game_Enemy.prototype.name;
    Game_Enemy.prototype.name = function() {
        var name = __GEnemy_name.call(this);
        if (this._nicknameStateId !== []){
            this._nicknameStateId.forEach(function(stateId){
                name = $dataStates[stateId].name + name;
            }.bind(this));
        }
        return name;
    };

    var __GEnemy_makeDropItems = Game_Enemy.prototype.makeDropItems;
    Game_Enemy.prototype.makeDropItems = function() {
        var dropItems = __GEnemy_makeDropItems.call(this);
        this._nicknameDrop.forEach(function(drop){
            if (drop) {
                var di = drop.split(':');
                di[1] = di[1].replace(/[%％]/, '');
                if (Math.random() <= Number(di[1]) * this.dropItemRate() * 0.01) {
                    var item = null;
                    var type = di[0].slice(0, 1);
                    var id = parseInt(di[0].slice(1), 10);
                    if (type === 'I') item = $dataItems[id];
                    if (type === 'W') item = $dataWeapons[id];
                    if (type === 'A') item = $dataArmors[id];
                    dropItems.push(item);
                }
            }
        }.bind(this));
        return dropItems;
    };

    var __GEnemy_exp = Game_Enemy.prototype.exp;
    Game_Enemy.prototype.exp = function() {
        var exp = __GEnemy_exp.call(this);
        var exr = 1.0;
        if (this._nicknameStateId !== []){
            this._nicknameStateId.forEach(function(stateId){
                var state = $dataStates[stateId];
                if (state.meta['経験値獲得率']) exr *= Number(state.meta['経験値獲得率'].replace(/[%％]/,'')) * 0.01;
                if (state.meta['ExpRate']) exr *= Number(state.meta['ExpRate'].replace(/[%％]/,'')) * 0.01;
            }.bind(this));
        }
        exp *= exr;
        return exp;
    };

    var __GEnemy_gold = Game_Enemy.prototype.gold;
    Game_Enemy.prototype.gold = function() {
        var gold = __GEnemy_gold.call(this);
        var gdr = 1.0;
        if (this._nicknameStateId !== []){
            this._nicknameStateId.forEach(function(stateId){
                var state = $dataStates[stateId];
                if (state.meta['ゴールド獲得率']) gdr *= Number(state.meta['ゴールド獲得率'].replace(/[%％]/,'')) * 0.01;
                if (state.meta['GoldRate']) gdr *= Number(state.meta['GoldRate'].replace(/[%％]/,'')) * 0.01;
            }.bind(this));
        }
        gold *= gdr;
        return gold;
    };

}());


code:
//=============================================================================
// NearEventSensor.js
// ----------------------------------------------------------------------------
// (C) 2015 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 3.1.1 2020/07/05 3.1.0の修正をイベント開始時にも適用できるよう変更
// 3.1.0 2020/07/05 イベントから離れたらエフェクトを即時消去できる設定を追加
// 3.0.0 2020/05/26 センサーエフェクトをイベントではなくプレイヤーに適用できる機能を追加。パラメータの再設定が必要です。
// 2.2.0 2018/11/05 フキダシの表示完了までウェイトするかどうかの設定を追加
// 2.1.1 2018/11/05 マップ移動時にすでに検知範囲内に入っていたイベントについて、一度範囲外に出ないと反応しない問題を修正
// 2.1.0 2017/10/23 特定のスイッチもしくはセルフスイッチが有効なときのみ感知エフェクトを出す機能を追加
//                  パラメータの型指定機能に対応
// 2.0.0 2016/08/27 フラッシュの代わりにフキダシアイコンを利用できる機能を追加
//                  パラメータ名等に一部破壊的な変更が加わっています。
// 1.1.0 2016/07/14 各種パラメータとメモ欄で感知可否の設定を追加
// 1.0.1 2015/11/01 既存コードの再定義方法を修正（内容に変化なし）
// 1.0.0 2015/10/31 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc 周辺イベント感知プラグイン
 * @author トリアコンタン
 *
 * @param DefaultFlash
 * @text デフォルトフラッシュ
 * @desc 感知時にイベントを指定色でフラッシュさせます。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param DefaultBalloon
 * @text デフォルトフキダシ
 * @desc 感知時にイベントに自動でフキダシアイコンを出します。
 * (1:びっくり 2:はてな 3:音符 4:ハート 5:怒り....)
 * @default 0
 * @type select
 * @option なし
 * @value 0
 * @option びっくり
 * @value 1
 * @option はてな
 * @value 2
 * @option 音符
 * @value 3
 * @option ハート
 * @value 4
 * @option 怒り
 * @value 5
 * @option 汗
 * @value 6
 * @option くしゃくしゃ
 * @value 7
 * @option 沈黙
 * @value 8
 * @option 電球
 * @value 9
 * @option Zzz
 * @value 10
 * @option ユーザ定義1
 * @value 11
 * @option ユーザ定義2
 * @value 12
 * @option ユーザ定義3
 * @value 13
 * @option ユーザ定義4
 * @value 14
 * @option ユーザ定義5
 * @value 15
 *
 * @param DisableEmpty
 * @text 空イベントは無効
 * @desc イベント内容が空の場合、感知しなくなります。(ON/OFF)
 * @default true
 * @type boolean
 *
 * @param SensorDistance
 * @text 感知距離
 * @desc イベントを関知する距離です。
 * @default 2
 * @type number
 *
 * @param FlashColor
 * @text フラッシュカラー
 * @desc 感知時のフラッシュ色です。R(赤),G(緑),B(青),A(強さ)の順番で指定してください。
 * @default {"Red":"255","Green":"255","Blue":"255","Alpha":"255"}
 * @type struct<Color>
 *
 * @param FlashDuration
 * @text フラッシュ時間
 * @desc フラッシュさせるフレーム数です。
 * @default 60
 * @type number
 *
 * @param BalloonInterval
 * @text フキダシ間隔
 * @desc フキダシを表示する間隔のフレーム数です。
 * @default 15
 * @type number
 *
 * @param WaitForBalloon
 * @text フキダシ完了までウェイト
 * @desc 範囲内に居続けた場合の連続フキダシ表示で、フキダシの表示が終わるのを待ってから次のフキダシの表示します。
 * @default true
 * @type boolean
 *
 * @param ConsiderationDir
 * @text 向きを考慮
 * @desc プレイヤーがイベントの方を向いている場合のみエフェクトを有効にします。(ON/OFF)
 * @default false
 * @type boolean
 *
 * @param ApplyPlayer
 * @text プレイヤーに適用
 * @desc 感知時のエフェクトを対象イベントではなくプレイヤーに対して適用します。
 * @default false
 * @type boolean
 *
 * @param EraseWhenAway
 * @text 離れたら消去
 * @desc イベントから離れたらエフェクトを消去します。
 * @default false
 * @type boolean
 *
 * @help 周囲に存在するイベントを感知してイベントにエフェクトを発生させます。
 * 実行可能なイベントをプレイヤーに伝えてユーザビリティを向上させます。
 * 使用できるエフェクトはフラッシュとフキダシアイコン（およびその両方）です。
 *
 * 各エフェクトの有効可否は、プラグインパラメータによる一括設定と
 * イベントのメモ欄による個別設定があり、個別設定が優先されます。
 *
 * 感知時のエフェクトをフラッシュにしたい場合は、
 * メモ欄を以下の通り指定してください。
 * <NESフラッシュ対象:ON>  # 対象イベントのフラッシュを有効にします。
 * <NESフラッシュ対象:OFF> # 対象イベントのフラッシュを無効にします。
 *
 * 感知時のエフェクトをフキダシアイコンにしたい場合は、
 * メモ欄を以下の通り指定してください。
 * <NESフキダシ対象:1> # 対象イベントのフキダシを(1:びっくり)にします。
 * <NESフキダシ対象:0> # 対象イベントのフキダシを無効にします。
 *
 * 特定のスイッチもしくはセルフスイッチがONのときのみ感知エフェクトを
 * 表示したい場合は、メモ欄を以下の通り指定してください。
 * <NESスイッチ:1>       # スイッチ[1]がONのときのみエフェクトを出します。
 * <NESSwitch:1>         # 同上
 * <NESセルフスイッチ:A> # セルフスイッチ[A]がONのときのみエフェクトを出します。
 * <NESSelfSwitch:1>     # 同上
 *
 * 注意！
 * モバイル端末では、フラッシュを使用すると動作が
 * 少し重くなるようです。ご利用の際はご注意ください。
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~Color:
 * @param Red
 * @desc 赤色の情報です。(0-255)
 * @type number
 * @min 0
 * @max 255
 * @default 255
 *
 * @param Green
 * @desc 緑色の情報です。(0-255)
 * @type number
 * @min 0
 * @max 255
 * @default 255
 *
 * @param Blue
 * @desc 青色の情報です。(0-255)
 * @type number
 * @min 0
 * @max 255
 * @default 255
 *
 * @param Alpha
 * @desc 強さの情報です。(0-255)
 * @type number
 * @min 0
 * @max 255
 * @default 255
 */

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

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

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

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

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

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

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var createPluginParameter = function(pluginName) {
        var paramReplacer = function(key, value) {
            if (value === 'null') {
                return value;
            }
            if (value[0] === '"' && value[value.length - 1] === '"') {
                return value;
            }
            try {
                return JSON.parse(value);
            } catch (e) {
                return value;
            }
        };
        var parameter     = JSON.parse(JSON.stringify(PluginManager.parameters(pluginName), paramReplacer));
        PluginManager.setParameters(pluginName, parameter);
        return parameter;
    };
    var param = createPluginParameter('NearEventSensor');
    param.FlashColorArray = [param.FlashColor.Red, param.FlashColor.Green, param.FlashColor.Blue, param.FlashColor.Alpha];

    //=============================================================================
    // Sprite_Character
    //  キャラクターのフラッシュ機能を追加定義します。
    //=============================================================================
    var _Sprite_CharacterUpdate       = Sprite_Character.prototype.update;
    Sprite_Character.prototype.update = function() {
        _Sprite_CharacterUpdate.call(this);
        this.updateFlash();
    };

    Sprite_Character.prototype.updateFlash = function() {
        if (this._character.isFlash()) {
            this.setBlendColor(this._character._flashColor);
        }
    };

    var _Sprite_Character_updateBalloon = Sprite_Character.prototype.updateBalloon;
    Sprite_Character.prototype.updateBalloon = function() {
        if (this._character.isBalloonCancel()) {
            this.endBalloon();
        }
        _Sprite_Character_updateBalloon.apply(this, arguments);
    };

    //=============================================================================
    // Game_CharacterBase
    //  キャラクターのフラッシュ機能を追加定義します。
    //=============================================================================
    var _Game_CharacterBaseInitMembers       = Game_CharacterBase.prototype.initMembers;
    Game_CharacterBase.prototype.initMembers = function() {
        _Game_CharacterBaseInitMembers.call(this);
        this._flashColor    = null;
        this._flashDuration = 0;
    };

    var _Game_CharacterBaseUpdate       = Game_CharacterBase.prototype.update;
    Game_CharacterBase.prototype.update = function() {
        _Game_CharacterBaseUpdate.call(this);
        this.updateFlash();
    };

    Game_CharacterBase.prototype.startFlash = function(flashColor, flashDuration) {
        this._flashColor    = flashColor;
        this._flashDuration = flashDuration;
    };

    Game_CharacterBase.prototype.clearFlash = function() {
        this._flashColor = [0,0,0,0];
    };

    Game_CharacterBase.prototype.isFlash = function() {
        return this._flashDuration > 0;
    };

    Game_CharacterBase.prototype.updateFlash = function() {
        if (this.isFlash()) {
            this._flashColor[3] = this._flashColor[3] * (this._flashDuration - 1) / this._flashDuration;
            this._flashDuration--;
        }
    };

    Game_CharacterBase.prototype.applySensorEffect = function(targetEvent) {
        if (!this.isFlash() && targetEvent.isFlashEvent()) {
            this.startFlash(param.FlashColorArray.clone(), param.FlashDuration);
        }
        var balloonId = targetEvent.getSensorBalloonId();
        if (balloonId && (!param.WaitForBalloon || !this.isBalloonPlaying())) {
            if (this._balloonInterval <= 0 || isNaN(this._balloonInterval)) {
                this.requestBalloon(balloonId);
                this._balloonInterval = param.BalloonInterval;
            } else {
                this._balloonInterval--;
            }
        }
        this._sensorApply = true;
    };

    Game_CharacterBase.prototype.eraseSensorEffect = function() {
        if (!this._sensorApply || !param.EraseWhenAway) {
            return;
        }
        this.clearFlash();
        this._balloonCancel = true;
        this._sensorApply = false;
    };

    Game_CharacterBase.prototype.isBalloonCancel = function() {
        var cancel = this._balloonCancel;
        this._balloonCancel = false;
        return cancel;
    };

    //=============================================================================
    // Game_Event
    //  プレイヤーとの距離を測り、必要な場合にエフェクトさせる機能を追加定義します。
    //=============================================================================
    var _Game_Event_initialize = Game_Event.prototype.initialize;
    Game_Event.prototype.initialize = function(mapId, eventId) {
        _Game_Event_initialize.apply(this, arguments);
        this._balloonInterval = 0;
    };

    var _Game_EventUpdate       = Game_Event.prototype.update;
    Game_Event.prototype.update = function() {
        _Game_EventUpdate.apply(this, arguments);
        if (this.page()) {
            this.updateSensorEffect();
        }
    };

    var _Game_Event_start = Game_Event.prototype.start;
    Game_Event.prototype.start = function() {
        _Game_Event_start.apply(this, arguments);
        this.eraseSensorEffect();
    };

    Game_Event.prototype.updateSensorEffect = function() {
        var subject = this.findNearEffectSubject();
        if (this.isSensorOn()) {
            subject.applySensorEffect(this);
        } else {
            subject.eraseSensorEffect(this);
            this._balloonInterval = 0;
        }
    };

    Game_Event.prototype.isSensorOn = function() {
        return this.isEmptyValidate() && this.isVeryNearThePlayer() &&
            !$gameMap.isEventRunning() && this.isValidSensor();
    };

    Game_Event.prototype.findNearEffectSubject = function() {
        return param.ApplyPlayer ? $gamePlayer : this;
    };

    Game_Event.prototype.isEmptyValidate = function() {
        var list = this.list();
        return (list && list.length > 1) || !param.DisableEmpty;
    };

    Game_Event.prototype.isFlashEvent = function() {
        var useFlash = getMetaValues(this.event(), ['フラッシュ対象', 'FlashEvent']);
        return useFlash ? getArgBoolean(useFlash) : param.DefaultFlash;
    };

    Game_Event.prototype.isValidSensor = function() {
        return this.isValidSensorSwitch() && this.isValidSensorSelfSwitch();
    };

    Game_Event.prototype.isValidSensorSwitch = function() {
        var switchId = getMetaValues(this.event(), ['スイッチ', 'Switch']);
        return switchId ? $gameSwitches.value(getArgNumber(switchId, 1)) : true;
    };

    Game_Event.prototype.isValidSensorSelfSwitch = function() {
        var selfSwitchType = getMetaValues(this.event(), ['セルフスイッチ', 'SelfSwitch']);
        return selfSwitchType ? $gameSelfSwitches.value([this._mapId, this._eventId, selfSwitchType.toUpperCase()]) : true;
    };

    Game_Event.prototype.getSensorBalloonId = function() {
        var balloonId = getMetaValues(this.event(), ['フキダシ対象', 'BalloonEvent']);
        return balloonId ? getArgNumber(balloonId, 0) : param.DefaultBalloon;
    };

    Game_Event.prototype.isVeryNearThePlayer = function() {
        var sx = this.deltaXFrom($gamePlayer.x);
        var sy = this.deltaYFrom($gamePlayer.y);
        var ax = Math.abs(sx);
        var ay = Math.abs(sy);
        var result = (ax + ay <= param.SensorDistance);
        if (result && param.ConsiderationDir) {
            if (ax > ay) {
                return $gamePlayer.direction() === (sx > 0 ? 6 : 4);
            } else if (sy !== 0) {
                return $gamePlayer.direction() === (sy > 0 ? 2 : 8);
            } else {
                return true;
            }
        }
        return result;
    };
})();


code:
//=============================================================================
// NumbStates.js
//=============================================================================

/*:
 * @plugindesc make the state that numb.
 *  numb is the state that one sometimes(using random) cannot execute action.
 * @author Sasuke KANNAZUKI
 *
 * @param NumbMsg
 * @desc text to display when one cannot move by numb.
 * @default  cannot move by the numb!
 *
 * @help This plugin does not provide plugin commands.
 *
 * State Note:
 * to invoke this state, write down the state's note as follows.
 *   <numb_rate:35> # cannot execute action by 35%
 *
 * prefer that restriction (= action constraint) of the state is 0
 * (= command inputtable).
 */

/*:ja
 * @plugindesc 一定確率で行動できないステート
 * @author 神無月サスケ
 *
 * @param NumbMsg
 * @desc 身体が痺れて動けない場合に表示する文章
 * @default は身体がしびれて動けない！
 *
 * @help このプラグインにプラグインコマンドはありません。
 *  痺れ(numb)は、入力は常に受け付けるものの特定の確率で動けなくなる状態で
 * ツクール標準の眠り/麻痺とは異なります。
 *
 * 書式:
 * 「ステート」のメモに以下のように書いてください。
 *   <numb_rate:35>
 *  この場合、このステートになったら 35% の確率で行動できなくなります。
 *
 * 注意：
 * ステートの「行動制約」は「なし（＝入力可）」にするのが望ましいです。
 */

(function() {

  Game_BattlerBase.prototype.numb_occur = function() {
    for (var id = 0; id < this._states.length; id++) {
      var stateId = this._states[id];
      var result = $dataStates[stateId].meta.numb_rate;
      if (result) {
        if(Math.randomInt(100) < Number(result)) {
          return true;
        }
      }
    }
    return false;
  };

  var _BattleManager_processTurn = BattleManager.processTurn;
  BattleManager.processTurn = function() {
    var subject = this._subject;
    if ( subject.numb_occur() ){
      subject.clearActions();
      this._logWindow.displayNumbOccur(subject);
    }
    _BattleManager_processTurn.call(this);
  };

  Window_BattleLog.prototype.displayNumbOccur = function(subject){
    var parameters = PluginManager.parameters('NumbState');
    var NumbText = String(parameters['NumbMsg'] ||
     " cannot move by the numb!");
    this.push('addText', subject.name() + NumbText);
    this.push('clear');
  };

})();


code:
"use strict";
/*:
 * @plugindesc 自作の一枚画像をウィンドウに適用します。
 * @author ei1chi
 *
 * @help このプラグインにはプラグインコマンドはありません。
 *
 * ============================================================
 *  OriginalWindowSkin.js
 *  v0.1.0
 * ============================================================
 * 自作の一枚画像をウィンドウの見た目に適用するプラグインです。
 * ツクールの標準機能では不可能だった、自由な見た目のウィンドウを作ることができます。
 * 代わりにウィンドウの開閉動作がフェードイン・アウトに置き換わっていますので、ご了承ください。
 *
 * ※現在はメッセージウィンドウのみ対応。
 * 　今後、対応ウィンドウを追加予定。
 *
 * ------------------------------------------------------------
 *  使い方
 * ------------------------------------------------------------
 * ウィンドウとして使いたい画像を、img/pictures/内に
 * "Window_Original.png"として追加します。※今後変更される可能性があります
 *
 * メッセージウィンドウのサイズは標準で"816x180"ピクセルです。
 * このサイズでの画像作成をお勧めします。
 *
 * ------------------------------------------------------------
 *  注意点
 * ------------------------------------------------------------
 * ・デプロイメント時「未使用ファイルを含まない」オプションを有効にすると
 * 　スキン画像が出力されません！
 * 　手動でデプロイメント先にコピーする必要があります。
 * ・公式ツール"MADO"によるウィンドウ拡張との併用は未検証です（検証予定）。
 * ・その他、ウィンドウ系プラグインと併用すると問題が発生する可能性があります。
 *
 * ------------------------------------------------------------
 *  使用許諾
 * ------------------------------------------------------------
 * ・使用の際に連絡およびクレジット表記は不要です。
 * ・自由に改変して利用して構いません。
*/
(function (_) {
    // 画像ファイル読み込み（キャッシュに投入）
    Window_Base.prototype.loadWindowskin = function () {
        this.originalSkin = ImageManager.loadPicture("Window_Original");
        this.windowskin = ImageManager.loadSystem("Window");
    };
    var __initialize = Window_Message.prototype.initialize;
    Window_Message.prototype.initialize = function () {
        __initialize.call(this);
        this._refreshAllParts();
    };
    // 背景画像の処理を削除
    Window_Message.prototype._refreshBack = function () { };
    // 画像更新処理を変更
    Window_Message.prototype._refreshFrame = function () {
        var w = this._width;
        var h = this._height;
        var bitmap = new Bitmap(w, h);
        this._windowFrameSprite.bitmap = bitmap;
        this._windowFrameSprite.setFrame(0, 0, w, h);
        if (this.originalSkin !== null) {
            bitmap.blt(this.originalSkin, 0, 0, w, h, 0, 0);
        }
    };
    // openness設定時の挙動を変更（重要ポイント）
    Object.defineProperty(Window_Message.prototype, "openness", {
        get: function () {
            return this._openness;
        },
        set: function (value) {
            if (this._openness !== value) {
                this._openness = value.clamp(0, 255);
                this._windowFrameSprite.opacity = value;
            }
        },
        configurable: true
    });
})();


code:
//=============================================================================
// PD_DelayTitle.js
//=============================================================================

/*:
 * @plugindesc タイトル画面の各画像の表示にディレイとフェードイン機能を追加します。
 * @author Shio_inu
 *
 *
 * @param Delay BG1
 * @desc 背景1を表示開始するフレーム数です。
 * @default 0
 *
 * @param Fade BG1
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay BG2
 * @desc 背景1を表示開始するフレーム数です。
 * @default 60
 *
 * @param Fade BG2
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Title
 * @desc タイトルを表示開始するフレーム数です。
 * @default 120
 *
 * @param Fade Title
 * @desc タイトルのフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Command
 * @desc コマンドを表示するフレーム数です。
 * @default 180
 *
 * @param Pass To Decide
 * @desc 決定キーで演出をスキップできるかの設定です。1:スキップ出来る　0:スキップ出来ない
 * @default 1
 *
 * @help last update : 26th Jun 2017 v1.01
 *
 */

/*:ja
 * @plugindesc タイトル画面の各画像の表示にディレイとフェードイン機能を追加します。
 * @author しおいぬ
 *
 * @param Delay BG1
 * @desc 背景1を表示開始するフレーム数です。
 * @default 0
 *
 * @param Fade BG1
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay BG2
 * @desc 背景1を表示開始するフレーム数です。
 * @default 60
 *
 * @param Fade BG2
 * @desc 背景1のフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Title
 * @desc タイトルを表示開始するフレーム数です。
 * @default 120
 *
 * @param Fade Title
 * @desc タイトルのフェードインにかかるフレーム数です。
 * @default 60
 *
 * @param Delay Command
 * @desc コマンドを表示するフレーム数です。
 * @default 180
 *
 * @param Pass To Decide
 * @desc 決定キーで演出をスキップできるかの設定です。1:スキップ出来る　0:スキップ出来ない
 * @default 1
 * @help last update : 2017/06/26 v1.01
 *
 */
(function(){

    var parameters = PluginManager.parameters('PD_DelayTitle');
    var delayBG1 = Number(parameters['Delay BG1'] || 0);
    var fadeBG1 = Number(parameters['Fade BG1'] || 60);
    var delayBG2 = Number(parameters['Delay BG2'] || 0);
    var fadeBG2 = Number(parameters['Fade BG2'] || 60);
    var delayTitle = Number(parameters['Delay Title'] || 120);
    var fadeTitle = Number(parameters['Fade Title'] || 60);
    var delayCommand = Number(parameters['Delay Command'] || 180);
    var passToDecide = Number(parameters['Pass To Decide'] || 0);

    var endFrame = Math.max(delayBG1 + fadeBG1, delayBG2 + fadeBG2, delayTitle + fadeTitle, delayCommand);

Scene_Title.prototype.create = function() {
    Scene_Base.prototype.create.call(this);
    this.createBackground();
    this.createForeground();
    this.createWindowLayer();
    this.createCommandWindow();
    this._frame = 0;
};

Scene_Title.prototype.update = function(){
    Scene_Base.prototype.update.call(this);
    //スキップ
    if (passToDecide == 1 && (Input.isTriggered('ok') || TouchInput.isPressed ()) && this._frame < endFrame) {
        this.skip();
    }
    //フェード開始確認
    if(this._frame === delayBG1){
        if(fadeBG1 === 0){
            this._backSprite1.opacity = 255;
        } else {
            this._backSprite1.opacity = 1;
        }
    }
    if(this._frame === delayBG2){
        if(fadeBG2 === 0){
            this._backSprite2.opacity = 255;
        } else {
            this._backSprite2.opacity = 1;
        }
    }
    if($dataSystem.optDrawTitle && this._frame === delayTitle){
        if(fadeTitle === 0){
            this._gameTitleSprite.opacity = 255;
        } else {
            this._gameTitleSprite.opacity = 1;
        }
    }
    if(this._frame === delayCommand){
        this._commandWindow.open();
    }
    //フェード処理
    if(this._backSprite1.opacity > 0 && this._backSprite1.opacity < 255){
        this._backSprite1.opacity += 255 / fadeBG1;
    }
    if(this._backSprite2.opacity > 0 && this._backSprite2.opacity < 255){
        this._backSprite2.opacity += 255 / fadeBG2;
    }
    if($dataSystem.optDrawTitle && this._gameTitleSprite.opacity > 0 && this._gameTitleSprite.opacity < 255){
        this._gameTitleSprite.opacity += 255 / fadeTitle;
    }

    this._frame ++ ;
}
Scene_Title.prototype.createBackground = function() {
    this._spritebutton = new Sprite
    this._backSprite1 = new Sprite(ImageManager.loadTitle1($dataSystem.title1Name));
    this._backSprite2 = new Sprite(ImageManager.loadTitle2($dataSystem.title2Name));
    this._backSprite1.opacity = 0;
    this._backSprite2.opacity = 0;
    this.addChild(this._backSprite1);
    this.addChild(this._backSprite2);
};

Scene_Title.prototype.drawGameTitle = function() {
    var x = 20;
    var y = Graphics.height / 4;
    var maxWidth = Graphics.width - x * 2;
    var text = $dataSystem.gameTitle;
    this._gameTitleSprite.bitmap.outlineColor = 'black';
    this._gameTitleSprite.bitmap.outlineWidth = 8;
    this._gameTitleSprite.bitmap.fontSize = 72;
    this._gameTitleSprite.bitmap.drawText(text, x, y, maxWidth, 48, 'center');
    this._gameTitleSprite.opacity = 0;
};

    Scene_Title.prototype.skip = function() {
        this._backSprite1.opacity = 255;
        this._backSprite2.opacity = 255;
        if($dataSystem.optDrawTitle){
            this._gameTitleSprite.opacity = 255;
        }
        this._commandWindow.open();
        this._frame = endFrame + 1;
    };
})();