code:
//=============================================================================
// PictureCallCommon.js
// ----------------------------------------------------------------------------
// (C)2015 Triacontane
// This plugin is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.13.0 2019/12/22 ピクチャコモンを並列処理として実行する設定を追加。
// 1.12.2 2019/03/31 キーバインドで追加でキーを指定した場合に、ボタン名称が小文字でないと反応しない仕様を変更
// 1.12.1 2019/03/19 コミュニティ版コアスクリプト1.3以降でピクチャコモンから移動ルートの設定を実行するとエラーになっていた問題を修正
// 1.12.0 2018/11/02 すべてのピクチャタッチを無効にできるスイッチを追加
// 1.11.0 2018/08/10 なでなで機能に透過設定が正しく適用されない問題を修正
//                   なでなで機能にもプラグインコマンドから透過設定を変更できる機能を追加
// 1.10.8 2018/06/16 Boolean型のパラメータが一部正常に取得できていなかった問題を修正
// 1.10.7 2018/06/01 イベント「戦闘の処理」による戦闘の場合、「戦闘中に常にコモン実行」の機能が使えない問題を修正
// 1.10.6 2018/04/12 ヘルプの記述を微修正
// 1.10.5 2017/12/17 コモンイベントを実行するタイプのボタンは、イベント実行中に無効になるよう仕様変更
// 1.10.4 2017/11/01 ピクチャコモンが呼ばれる瞬間に対象ピクチャが表示されていない場合はイベントを呼ばない仕様に変更
// 1.10.3 2017/10/28 ピクチャタッチイベントの呼び出し待機中に戦闘に突入すると、戦闘画面表示後に実行されてしまう問題を修正
// 1.10.2 2017/10/21 戦闘画面に突入する際のエフェクトで、マウスオーバーイベントが予期せず発生する場合がある問題を修正
// 1.10.1 2017/05/27 動的文字列ピクチャプラグインのウィンドウフレームクリックをピクチャクリックに対応
// 1.9.3 2017/05/27 競合の可能性のある記述（Objectクラスへのプロパティ追加）をリファクタリング（by liplyさん）
// 1.9.2 2017/03/16 1.9.0で戦闘中にコモンイベント実行が正しく動作していなかった問題を修正
// 1.9.1 2017/03/16 透明色を考慮する場合、不透明度が0のピクチャは一切反応しなくなるように仕様変更
// 1.9.0 2017/03/13 戦闘中常にピクチャクリックイベントを実行できる機能を追加
// 1.8.2 2017/02/14 1.8.0の修正により、ピクチャクリック時に変数に値を格納する機能が無効化されていたのを修正
// 1.8.1 2017/02/07 端末依存の記述を削除
// 1.8.0 2017/02/03 ピクチャクリックを任意のボタンにバインドできる機能を追加
// 1.7.0 2017/02/02 マップのズームおよびシェイク中でも正確にピクチャをクリックできるようになりました。
//                  マウスポインタがピクチャ内にあるかどうかをスクリプトで判定できる機能を追加。
// 1.6.0 2016/12/29 ピクチャクリックでイベントが発生したらマップタッチを無効化するよう仕様修正
// 1.5.1 2016/11/20 1.5.0で混入した不要なコードを削除
// 1.5.0 2016/11/19 ピクチャクリック時にコモンイベントではなくスイッチをONにできる機能を追加
// 1.4.0 2016/08/20 ピクチャごとに透明色を考慮するかどうかを設定できる機能を追加
//                  プラグインを適用していないセーブデータをロードした場合に発生するエラーを修正
// 1.3.5 2016/04/20 リファクタリングによりピクチャの優先順位が逆転していたのをもとに戻した
// 1.3.4 2016/04/08 ピクチャが隣接する状態でマウスオーバーとマウスアウトが正しく機能しない場合がある問題を修正
// 1.3.3 2016/03/19 トリガー条件を満たした場合に以後のタッチ処理を抑制するパラメータを追加
// 1.3.2 2016/02/28 処理の負荷を少し軽減
// 1.3.1 2016/02/21 トリガーにマウスを押したまま移動を追加
// 1.3.0 2016/01/24 ピクチャをなでなでする機能を追加
//                  トリガーにマウスムーブを追加
//                  ピクチャが回転しているときに正しく位置を補足できるよう修正
// 1.2.1 2016/01/21 呼び出すコモンイベントの上限を100から1000（DB上の最大値）に修正
//                  競合対策（YEP_MessageCore.js）
// 1.2.0 2016/01/14 ホイールクリック、ダブルクリックなどトリガーを10種類に拡充
// 1.1.3 2016/01/02 競合対策（TDDP_BindPicturesToMap.js）
// 1.1.2 2015/12/20 長押しイベント発生時に1秒間のインターバルを設定するよう仕様変更
// 1.1.1 2015/12/10 ピクチャを消去後にマウスオーバーするとエラーになる現象を修正
// 1.1.0 2015/11/23 コモンイベントを呼び出した対象のピクチャ番号を特定する機能を追加
//                  設定で透明色を考慮する機能を追加
//                  トリガーとして「右クリック」や「長押し」を追加
// 1.0.0 2015/11/14 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:ja
 * @plugindesc ピクチャのボタン化プラグイン
 * @author トリアコンタン
 *
 * @param 透明色を考慮
 * @desc クリックされた箇所が透明色だった場合は、クリックを無効にする。
 * @default true
 * @type boolean
 *
 * @param ピクチャ番号の変数番号
 * @desc ピクチャクリック時にピクチャ番号を格納するゲーム変数の番号。
 * @default 0
 * @type variable
 *
 * @param ポインタX座標の変数番号
 * @desc マウスカーソルもしくはタッチした位置のX座標を常に格納するゲーム変数の番号
 * @default 0
 * @type variable
 *
 * @param ポインタY座標の変数番号
 * @desc マウスカーソルもしくはタッチした位置のY座標を常に格納するゲーム変数の番号
 * @default 0
 * @type variable
 *
 * @param タッチ操作抑制
 * @desc トリガー条件を満たした際にタッチ情報をクリアします。(ON/OFF)
 * 他のタッチ操作と動作が重複する場合にONにします。
 * @default false
 * @type boolean
 *
 * @param 戦闘中常にコモン実行
 * @desc 戦闘中にピクチャをクリックしたとき、常にコモンイベントを実行します。(ON/OFF)
 * @default false
 * @type boolean
 *
 * @param 並列処理として実行
 * @desc ピクチャクリックによるコモンイベント実行を並列処理扱いで実行します。
 * @default false
 * @type boolean
 *
 * @param 無効スイッチ
 * @desc 指定した番号のスイッチがONになっている場合、すべてのピクチャタッチが無効になります。
 * @default 0
 * @type switch
 *
 * @help ピクチャをクリックすると、指定したコモンイベントが
 * 呼び出される、もしくは任意のスイッチをONにするプラグインコマンドを提供します。
 * このプラグインを利用すれば、JavaScriptの知識がなくても
 * 誰でも簡単にクリックやタッチを主体にしたゲームを作れます。
 *
 * 戦闘中でも実行可能ですが、ツクールMVの仕様により限られたタイミングでしか
 * イベントは実行されません。パラメータ「戦闘中常にコモン実行」を有効にすると
 * 常にイベントが実行されるようになりますが、
 * 一部イベントコマンドは正しく動作しない制約があります。
 *
 * 注意！
 * 一度関連づけたピクチャとコモンイベントはピクチャを消去しても有効です。
 * ピクチャが存在しなければどこをクリックしても反応しませんが、
 * 同じ番号で再度、ピクチャの表示を行うと反応するようになります。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （引数の間は半角スペースで区切る）
 *
 *  ピクチャのボタン化 or
 *  P_CALL_CE [ピクチャ番号] [コモンイベントID] [トリガー] [透明色を考慮]:
 *      ピクチャの領域内でトリガー条件を満たした場合に呼び出されるコモンイベントを関連づけます。
 *  　　トリガーは以下の通りです。(省略すると 1 になります)
 *      1  : クリックした場合
 *      2  : 右クリックした場合
 *      3  : 長押しした場合
 *      4  : マウスをピクチャに重ねた場合
 *      5  : マウスをピクチャから放した場合
 *      6  : クリックを解放（リリース）した場合
 *      7  : クリックした場合（かつ長押しの際の繰り返しを考慮）
 *      8  : クリックしている間ずっと
 *      9  : ホイールクリックした場合（PCの場合のみ有効）
 *      10 : ダブルクリックした場合
 *      11 : マウスをピクチャ内で移動した場合
 *      12 : マウスを押しつつピクチャ内で移動した場合
 *
 *      透明色を考慮のパラメータ(ON/OFF)を指定するとピクチャごとに透明色を考慮するかを
 *      設定できます。何も設定しないとプラグインパラメータの設定が適用されます。(従来の仕様)
 *
 *  例：P_CALL_CE 1 3 7 ON
 *  　：ピクチャのボタン化 \v[1] \v[2] \v[3] OFF
 *
 *  ピクチャのスイッチ化 or
 *  P_CALL_SWITCH [ピクチャ番号] [スイッチID] [トリガー] [透明色を考慮]
 *  　　ピクチャの領域内でトリガー条件を満たした場合に、任意のスイッチをONにします。
 *  　　トリガーの設定などは、ピクチャのボタン化と同一です。
 *
 *  ピクチャのキーバインド or
 *  P_CALL_KEY_BIND [ピクチャ番号] [ボタン名称] [トリガー] [透明色を考慮]
 *  　　ピクチャの領域内でトリガー条件を満たした場合に、任意のボタンを押したことにします。
 *  　　ボタン名の設定は以下の通りです。(Windows基準)
 *  ok      : Enter,Z
 *  shift   : Shift
 *  control : Ctrl,Alt
 *  escape  : Esc,X
 *  left    : ←
 *  up      : ↑
 *  right   : →
 *  down    : ↓
 *
 *  ピクチャのボタン化解除 or
 *  P_CALL_CE_REMOVE [ピクチャ番号] :
 *      ピクチャとコモンイベントもしくはスイッチの関連づけを解除します。
 *      全てのトリガーが削除対象です。
 *
 *  例：P_CALL_CE_REMOVE 1
 *  　：ピクチャのボタン化解除 \v[1]
 *
 *  ピクチャのなでなで設定 or
 *  P_STROKE [ピクチャ番号] [変数番号] [透明色を考慮]
 *  　　指定したピクチャの上でマウスやタッチを動かすと、
 *  　　速さに応じた値が指定した変数に値が加算されるようになります。
 *  　　この設定はピクチャを差し替えたり、一時的に非表示にしても有効です。
 *  　　10秒でだいたい1000くらいまで溜まります。
 *
 *  例：P_STROKE 1 2 ON
 *  　：ピクチャのなでなで設定 \v[1] \v[2] OFF
 *
 *  ピクチャのなでなで解除 or
 *  P_STROKE_REMOVE [ピクチャ番号]
 *  　　指定したピクチャのなでなで設定を解除します。
 *
 *  例：P_STROKE_REMOVE 1
 *  　：ピクチャのなでなで解除 \v[1]
 *
 *  ピクチャのポインタ化 or
 *  P_POINTER [ピクチャ番号]
 *  　　指定したピクチャがタッチ座標を自動で追従するようになります。
 *  　　タッチしていないと自動で非表示になります。
 *
 *  例：P_POINTER 1
 *  　：ピクチャのポインタ化 \v[1]
 *
 *  ピクチャのポインタ化解除 or
 *  P_POINTER_REMOVE [ピクチャ番号]
 *  　　指定したピクチャのポインタ化を解除します。
 *
 *  例：P_POINTER_REMOVE 1
 *  　：ピクチャのポインタ化解除 \v[1]
 *
 *  ・スクリプト（上級者向け）
 *  $gameScreen.isPointerInnerPicture([ID]);
 *
 *  指定した[ID]のピクチャ内にマウスポインタもしくはタッチ座標が存在する場合に
 *  trueを返します。このスクリプトは[P_CALL_CE]を使用していなくても有効です。
 *
 *  例：$gameScreen.isPointerInnerPicture(5);
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */
/*:
 * @plugindesc Clickable picture plugin
 * @author triacontane
 *
 * @param TransparentConsideration
 * @desc if click position is transparent, click is disabled.
 * @default true
 * @type boolean
 *
 * @param GameVariablePictureNum
 * @desc Game variable number that stores the picture number when common event called.
 * @default 0
 * @type variable
 *
 * @param GameVariableTouchX
 * @desc Game variable number that stores touch x position
 * @default 0
 * @type variable
 *
 * @param GameVariableTouchY
 * @desc Game variable number that stores touch y position
 * @default 0
 * @type variable
 *
 * @param SuppressTouch
 * @desc Suppress touch event for others(ON/OFF)
 * @default false
 * @type boolean
 *
 * @param AlwaysCommonInBattle
 * @desc Always execute common event in battle(ON/OFF)
 * @default false
 * @type boolean
 *
 * @param AsParallelCommon
 * @desc ピクチャクリックによるコモンイベント実行を並列処理扱いで実行します。
 * @default false
 * @type boolean
 *
 * @param InvalidSwitchId
 * @desc 指定した番号のスイッチがONになっている場合、すべてのピクチャタッチが無効になります。
 * @default 0
 * @type switch
 *
 * @help When clicked picture, call common event.
 *
 * Plugin Command
 *
 *  P_CALL_CE [Picture number] [Common event ID] [Trigger] [TransparentConsideration]:
 *      When picture was clicked, assign common event id.
 *  　　Trigger are As below(if omit, It is specified to 1)
 *      1  : Left click
 *      2  : Right click
 *      3  : Long click
 *      4  : Mouse over
 *      5  : Mouse out
 *      6  : Mouse release
 *      7  : Mouse repeat click
 *      8  : Mouse press
 *      9  : Wheel click
 *      10 : Double click
 *      11 : Mouse move
 *      12 : Mouse move and press
 *
 *  P_CALL_CE_REMOVE [Picture number] :
 *      break relation from picture to common event.
 *
 *  - Script
 *  $gameScreen.isPointerInnerPicture([ID]);
 *
 *  If mouse pointer inner the picture, return true.
 *
 *  ex：$gameScreen.isPointerInnerPicture(5);
 *
 *  This plugin is released under the MIT License.
 */
(function () {
  "use strict";
  var pluginName = "PictureCallCommon";

  var getParamOther = function (paramNames) {
    if (!Array.isArray(paramNames)) paramNames = [paramNames];
    for (var i = 0; i < paramNames.length; i++) {
      var name = PluginManager.parameters(pluginName)[paramNames[i]];
      if (name) return name;
    }
    return null;
  };

  var getParamBoolean = function (paramNames) {
    var value = getParamOther(paramNames);
    return (
      (value || "").toUpperCase() === "ON" ||
      (value || "").toUpperCase() === "TRUE"
    );
  };

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

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

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

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

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

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

  //=============================================================================
  // パラメータの取得とバリデーション
  //=============================================================================
  var paramGameVariableTouchX = getParamNumber(
    ["GameVariableTouchX", "ポインタX座標の変数番号"],
    0
  );
  var paramGameVariableTouchY = getParamNumber(
    ["GameVariableTouchY", "ポインタY座標の変数番号"],
    0
  );
  var paramGameVariablePictNum = getParamNumber(
    ["GameVariablePictureNum", "ピクチャ番号の変数番号"],
    0
  );
  var paramTransparentConsideration = getParamBoolean([
    "TransparentConsideration",
    "透明色を考慮",
  ]);
  var paramSuppressTouch = getParamBoolean(["SuppressTouch", "タッチ操作抑制"]);
  var paramAlwaysCommonInBattle = getParamBoolean([
    "AlwaysCommonInBattle",
    "戦闘中常にコモン実行",
  ]);
  var paramInvalidSwitchId = getParamNumber(
    ["InvalidSwitchId", "無効スイッチ"],
    0
  );
  var paramAsParallelCommon = getParamBoolean([
    "AsParallelCommon",
    "並列処理として実行",
  ]);

  //=============================================================================
  // Game_Interpreter
  //  プラグインコマンド[P_CALL_CE]などを追加定義します。
  //=============================================================================
  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.apply(this, arguments);
    var pictureId, touchParam, trigger, variableNum, transparent;
    switch (getCommandName(command)) {
      case "P_CALL_CE":
      case "ピクチャのボタン化":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        touchParam = getArgNumber(args[1], 1, $dataCommonEvents.length - 1);
        trigger = getArgNumber(args[2], 1);
        transparent = args.length > 3 ? getArgBoolean(args[3]) : null;
        $gameScreen.setPictureCallCommon(
          pictureId,
          touchParam,
          trigger,
          transparent
        );
        break;
      case "P_CALL_SWITCH":
      case "ピクチャのスイッチ化":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        touchParam = getArgNumber(args[1], 1);
        trigger = getArgNumber(args[2], 1);
        transparent = args.length > 3 ? getArgBoolean(args[3]) : null;
        $gameScreen.setPictureCallCommon(
          pictureId,
          touchParam * -1,
          trigger,
          transparent
        );
        break;
      case "P_CALL_KEY_BIND":
      case "ピクチャのキーバインド":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        touchParam = convertEscapeCharacters(args[1]);
        trigger = getArgNumber(args[2], 1);
        transparent = args.length > 3 ? getArgBoolean(args[3]) : null;
        $gameScreen.setPictureCallCommon(
          pictureId,
          touchParam,
          trigger,
          transparent
        );
        break;
      case "P_CALL_CE_REMOVE":
      case "ピクチャのボタン化解除":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        $gameScreen.setPictureRemoveCommon(pictureId);
        break;
      case "P_STROKE":
      case "ピクチャのなでなで設定":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        variableNum = getArgNumber(
          args[1],
          1,
          $dataSystem.variables.length - 1
        );
        transparent = args.length > 2 ? getArgBoolean(args[2]) : null;
        $gameScreen.setPictureStroke(pictureId, variableNum, transparent);
        break;
      case "P_STROKE_REMOVE":
      case "ピクチャのなでなで解除":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        $gameScreen.removePictureStroke(pictureId);
        break;
      case "P_POINTER":
      case "ピクチャのポインタ化":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        $gameScreen.setPicturePointer(pictureId);
        break;
      case "P_POINTER_REMOVE":
      case "ピクチャのポインタ化解除":
        pictureId = getArgNumber(args[0], 1, $gameScreen.maxPictures());
        $gameScreen.removePicturePointer(pictureId);
        break;
    }
  };

  var _Game_Interpreter_terminate = Game_Interpreter.prototype.terminate;
  Game_Interpreter.prototype.terminate = function () {
    _Game_Interpreter_terminate.apply(this, arguments);
    this._setupFromPicture = false;
  };

  Game_Interpreter.prototype.setupFromPicture = function (eventList, commonId) {
    this.setup(eventList, null);
    if (this.setEventInfo) {
      this.setEventInfo({ eventType: "common_event", commonEventId: commonId });
    }
    this._setupFromPicture = true;
  };

  Game_Interpreter.prototype.isSetupFromPicture = function () {
    return this._setupFromPicture;
  };

  //=============================================================================
  // Game_Temp
  //  呼び出し予定のコモンイベントIDのフィールドを追加定義します。
  //=============================================================================
  var _Game_Temp_initialize = Game_Temp.prototype.initialize;
  Game_Temp.prototype.initialize = function () {
    _Game_Temp_initialize.call(this);
    this.clearPictureCallInfo();
  };

  Game_Temp.prototype.clearPictureCallInfo = function () {
    this._pictureCommonId = 0;
    this._touchPictureId = 0;
  };

  Game_Temp.prototype.setPictureCallInfo = function (pictureCommonId) {
    this._pictureCommonId = pictureCommonId;
  };

  Game_Temp.prototype.pictureCommonId = function () {
    if (!$gameScreen.picture(this._touchPictureId)) {
      this.clearPictureCallInfo();
    }
    return this._pictureCommonId;
  };

  Game_Temp.prototype.onTouchPicture = function (param, pictureId) {
    this._touchPictureParam = param;
    if (this.isTouchPictureSetSwitch()) {
      $gameSwitches.setValue(param * -1, true);
    }
    if (this.isTouchPictureCallCommon()) {
      if (
        !paramAsParallelCommon &&
        $gameMap.isEventRunning() &&
        !$gameParty.inBattle()
      ) {
        this._touchPictureParam = null;
        return;
      }
      this.setPictureCallInfo(param);
    }
    if (this.isTouchPictureButtonTrigger()) {
      Input.bindKeyState(param);
    }
    if (paramGameVariablePictNum > 0) {
      $gameVariables.setValue(paramGameVariablePictNum, pictureId);
    }
    this._touchPictureId = pictureId;
  };

  Game_Temp.prototype.isTouchPictureButtonTrigger = function () {
    return isNaN(this._touchPictureParam);
  };

  Game_Temp.prototype.isTouchPictureSetSwitch = function () {
    return !isNaN(this._touchPictureParam) && this._touchPictureParam < 0;
  };

  Game_Temp.prototype.isTouchPictureCallCommon = function () {
    return !isNaN(this._touchPictureParam) && this._touchPictureParam > 0;
  };

  //=============================================================================
  // Game_System
  //  ロード時にピクチャ関連メンバを初期化します。
  //=============================================================================
  var _Game_System_onAfterLoad = Game_System.prototype.onAfterLoad;
  Game_System.prototype.onAfterLoad = function () {
    _Game_System_onAfterLoad.apply(this, arguments);
    $gameScreen.initPictureArray();
  };

  //=============================================================================
  // Game_Map
  //  ピクチャがタッチされたときのコモンイベント呼び出し処理を追加定義します。
  //=============================================================================
  var _Game_Map_setupStartingEvent = Game_Map.prototype.setupStartingEvent;
  Game_Map.prototype.setupStartingEvent = function () {
    var result = _Game_Map_setupStartingEvent.call(this);
    return result || this.setupPictureCommonEvent();
  };

  var _Game_Map_updateInterpreter = Game_Map.prototype.updateInterpreter;
  Game_Map.prototype.updateInterpreter = function () {
    _Game_Map_updateInterpreter.apply(this, arguments);
    this.setupPictureParallelCommonEvent();
  };

  Game_Map.prototype.setupPictureParallelCommonEvent = function () {
    if (!paramAsParallelCommon) {
      return;
    }
    var commonId = $gameTemp.pictureCommonId();
    var event = $dataCommonEvents[commonId];
    if (event) {
      if (!this._pictureCommonEvents) {
        this._pictureCommonEvents = [];
      }
      var interpreter = new Game_Interpreter();
      interpreter.setupFromPicture(event.list, commonId);
      this._pictureCommonEvents.push(interpreter);
      $gameTemp.clearPictureCallInfo();
    }
  };

  Game_Map.prototype.setupPictureCommonEvent = function () {
    if (paramAsParallelCommon) {
      return false;
    }
    var commonId = $gameTemp.pictureCommonId();
    var event = $dataCommonEvents[commonId];
    var result = false;
    if (!this.isEventRunning() && event) {
      this._interpreter.setupFromPicture(event.list, commonId);
      result = true;
    }
    $gameTemp.clearPictureCallInfo();
    return result;
  };

  var _Game_Map_updateEvents = Game_Map.prototype.updateEvents;
  Game_Map.prototype.updateEvents = function () {
    _Game_Map_updateEvents.apply(this, arguments);
    if (this._pictureCommonEvents && this._pictureCommonEvents.length > 0) {
      this.updatePictureCommonEvents();
    }
  };

  Game_Map.prototype.updatePictureCommonEvents = function () {
    this._pictureCommonEvents.forEach(function (event) {
      event.update();
    });
    this._pictureCommonEvents = this._pictureCommonEvents.filter(function (
      event
    ) {
      return event.isRunning();
    });
  };

  //=============================================================================
  // Game_Troop
  //  ピクチャがタッチされたときのコモンイベント呼び出し処理を追加定義します。
  //=============================================================================
  Game_Troop.prototype.setupPictureCommonEvent =
    Game_Map.prototype.setupPictureCommonEvent;

  Game_Troop.prototype.isExistPictureCommon = function () {
    return this._interpreter.isSetupFromPicture();
  };

  //=============================================================================
  // Game_Screen
  //  ピクチャに対応するコモンイベント呼び出し用のID配列を追加定義します。
  //=============================================================================
  var _Game_Screen_initialize = Game_Screen.prototype.initialize;
  Game_Screen.prototype.initialize = function () {
    _Game_Screen_initialize.apply(this, arguments);
    this.initPictureArray();
  };

  Game_Screen.prototype.initPictureArray = function () {
    this._pictureCidArray = this._pictureCidArray || [];
    this._pictureSidArray = this._pictureSidArray || [];
    this._picturePidArray = this._picturePidArray || [];
    this._pictureTransparentArray = this._pictureTransparentArray || [];
  };

  var _Game_Screen_update = Game_Screen.prototype.update;
  Game_Screen.prototype.update = function () {
    _Game_Screen_update.apply(this, arguments);
    this.updatePointer();
  };

  Game_Screen.prototype.updatePointer = function () {
    if (paramGameVariableTouchX)
      $gameVariables._data[paramGameVariableTouchX] = TouchInput.x;
    if (paramGameVariableTouchY)
      $gameVariables._data[paramGameVariableTouchY] = TouchInput.y;
  };

  Game_Screen.prototype.setPictureCallCommon = function (
    pictureId,
    touchParameter,
    trigger,
    transparent
  ) {
    var realPictureId = this.realPictureId(pictureId);
    if (this._pictureCidArray[realPictureId] == null)
      this._pictureCidArray[realPictureId] = [];
    this._pictureCidArray[realPictureId][trigger] = touchParameter;
    this._pictureTransparentArray[realPictureId] = transparent;
  };

  Game_Screen.prototype.setPictureRemoveCommon = function (pictureId) {
    this._pictureCidArray[this.realPictureId(pictureId)] = [];
  };

  Game_Screen.prototype.setPictureStroke = function (
    pictureId,
    variableNum,
    transparent
  ) {
    var realPictureId = this.realPictureId(pictureId);
    this._pictureSidArray[realPictureId] = variableNum;
    this._pictureTransparentArray[realPictureId] = transparent;
  };

  Game_Screen.prototype.removePictureStroke = function (pictureId) {
    this._pictureSidArray[this.realPictureId(pictureId)] = null;
  };

  Game_Screen.prototype.setPicturePointer = function (pictureId) {
    this._picturePidArray[this.realPictureId(pictureId)] = true;
  };

  Game_Screen.prototype.removePicturePointer = function (pictureId) {
    this._picturePidArray[this.realPictureId(pictureId)] = null;
  };

  Game_Screen.prototype.getPictureCid = function (pictureId) {
    return this._pictureCidArray[this.realPictureId(pictureId)];
  };

  Game_Screen.prototype.getPictureSid = function (pictureId) {
    return this._pictureSidArray[this.realPictureId(pictureId)];
  };

  Game_Screen.prototype.getPicturePid = function (pictureId) {
    return this._picturePidArray[this.realPictureId(pictureId)];
  };

  Game_Screen.prototype.getPictureTransparent = function (pictureId) {
    return this._pictureTransparentArray[this.realPictureId(pictureId)];
  };

  Game_Screen.prototype.disConvertPositionX = function (x) {
    return Math.round((x + this.zoomX() - this.shake()) / this.zoomScale());
  };

  Game_Screen.prototype.disConvertPositionY = function (y) {
    return Math.round((y + this.zoomY()) / this.zoomScale());
  };

  Game_Screen.prototype.disConvertPositionY = function (y) {
    return Math.round((y + this.zoomY()) / this.zoomScale());
  };

  Game_Screen.prototype.isPointerInnerPicture = function (pictureId) {
    var picture = SceneManager.getPictureSprite(pictureId);
    return picture ? picture.isIncludePointer() : false;
  };

  //=============================================================================
  // SceneManager
  //  ピクチャスプライトを取得します。
  //=============================================================================
  SceneManager.getPictureSprite = function (pictureId) {
    return this._scene.getPictureSprite(pictureId);
  };

  //=============================================================================
  // BattleManager
  //  ピクチャコモンを常に実行できるようにします。
  //=============================================================================
  BattleManager.updatePictureCommon = function () {
    if ($gameTroop.isExistPictureCommon() && paramAlwaysCommonInBattle) {
      this.updateEventMain();
      return true;
    }
    return false;
  };

  //=============================================================================
  // Scene_Base
  //  ピクチャに対する繰り返し処理を追加定義します。
  //=============================================================================
  Scene_Base.prototype.updateTouchPictures = function () {
    if (paramInvalidSwitchId && $gameSwitches.value(paramInvalidSwitchId)) {
      return;
    }
    this._spriteset.iteratePictures(function (picture) {
      if (typeof picture.callTouch === "function") picture.callTouch();
      return $gameTemp.pictureCommonId() === 0;
    });
  };

  Scene_Base.prototype.getPictureSprite = function (pictureId) {
    var result = null;
    this._spriteset.iteratePictures(function (picture) {
      if (picture.isIdEquals(pictureId)) {
        result = picture;
        return false;
      }
      return true;
    });
    return result;
  };

  //=============================================================================
  // Scene_Map
  //  ピクチャのタッチ状態からのコモンイベント呼び出し予約を追加定義します。
  //=============================================================================
  var _Scene_Map_update = Scene_Map.prototype.update;
  Scene_Map.prototype.update = function () {
    this.updateTouchPictures();
    _Scene_Map_update.apply(this, arguments);
  };

  var _Scene_Map_processMapTouch = Scene_Map.prototype.processMapTouch;
  Scene_Map.prototype.processMapTouch = function () {
    _Scene_Map_processMapTouch.apply(this, arguments);
    if ($gameTemp.isDestinationValid() && $gameTemp.pictureCommonId() > 0) {
      $gameTemp.clearDestination();
    }
  };

  var _Scene_Map_terminate = Scene_Map.prototype.terminate;
  Scene_Map.prototype.terminate = function () {
    _Scene_Map_terminate.apply(this, arguments);
    $gameTemp.clearPictureCallInfo();
  };

  //=============================================================================
  // Scene_Battle
  //  ピクチャのタッチ状態からのコモンイベント呼び出し予約を追加定義します。
  //=============================================================================
  var _Scene_Battle_update = Scene_Battle.prototype.update;
  Scene_Battle.prototype.update = function () {
    this.updateTouchPictures();
    $gameTroop.setupPictureCommonEvent();
    _Scene_Battle_update.apply(this, arguments);
  };

  var _Scene_Battle_updateBattleProcess =
    Scene_Battle.prototype.updateBattleProcess;
  Scene_Battle.prototype.updateBattleProcess = function () {
    var result = BattleManager.updatePictureCommon();
    if (result) return;
    _Scene_Battle_updateBattleProcess.apply(this, arguments);
  };

  var _Scene_Battle_terminate = Scene_Battle.prototype.terminate;
  Scene_Battle.prototype.terminate = function () {
    _Scene_Battle_terminate.apply(this, arguments);
    $gameTemp.clearPictureCallInfo();
  };

  //=============================================================================
  // Spriteset_Base
  //  ピクチャに対するイテレータを追加定義します。
  //=============================================================================
  Spriteset_Base.prototype.iteratePictures = function (callBackFund) {
    var containerChildren = this._pictureContainer.children;
    if (!Array.isArray(containerChildren)) {
      iterate(
        this._pictureContainer,
        function (property) {
          if (this._pictureContainer[property].hasOwnProperty("children")) {
            containerChildren = this._pictureContainer[property].children;
            this._iteratePicturesSub(containerChildren, callBackFund);
          }
        }.bind(this)
      );
    } else {
      this._iteratePicturesSub(containerChildren, callBackFund);
    }
  };

  Spriteset_Base.prototype._iteratePicturesSub = function (
    containerChildren,
    callBackFund
  ) {
    for (var i = containerChildren.length - 1; i >= 0; i--) {
      if (!callBackFund(containerChildren[i])) {
        break;
      }
    }
  };

  //=============================================================================
  // Sprite_Picture
  //  ピクチャのタッチ状態からのコモンイベント呼び出し予約を追加定義します。
  //=============================================================================
  var _Sprite_Picture_initialize = Sprite_Picture.prototype.initialize;
  Sprite_Picture.prototype.initialize = function (pictureId) {
    _Sprite_Picture_initialize.call(this, pictureId);
    this._triggerHandler = [];
    this._triggerHandler[1] = this.isTriggered;
    this._triggerHandler[2] = this.isCancelled;
    this._triggerHandler[3] = this.isLongPressed;
    this._triggerHandler[4] = this.isOnFocus;
    this._triggerHandler[5] = this.isOutFocus;
    this._triggerHandler[6] = this.isReleased;
    this._triggerHandler[7] = this.isRepeated;
    this._triggerHandler[8] = this.isPressed;
    this._triggerHandler[9] = this.isWheelTriggered;
    this._triggerHandler[10] = this.isDoubleTriggered;
    this._triggerHandler[11] = this.isMoved;
    this._triggerHandler[12] = this.isMovedAndPressed;
    this._onMouse = false;
    this._outMouse = false;
    this._wasOnMouse = false;
  };

  var _Sprite_update = Sprite_Picture.prototype.update;
  Sprite_Picture.prototype.update = function () {
    _Sprite_update.apply(this, arguments);
    this.updateTouch();
  };

  Sprite_Picture.prototype.updateTouch = function () {
    this.updateMouseMove();
    this.updateStroke();
    this.updatePointer();
  };

  Sprite_Picture.prototype.updateMouseMove = function () {
    if (this.isIncludePointer()) {
      if (!this._wasOnMouse) {
        this._onMouse = true;
        this._wasOnMouse = true;
      }
    } else if (this._wasOnMouse) {
      this._outMouse = true;
      this._wasOnMouse = false;
    }
  };

  Sprite_Picture.prototype.isIncludePointer = function () {
    return (
      this.isTouchable() && this.isTouchPosInRect() && !this.isTransparent()
    );
  };

  Sprite_Picture.prototype.updateStroke = function () {
    var strokeNum = $gameScreen.getPictureSid(this._pictureId);
    if (strokeNum > 0 && TouchInput.isPressed() && this.isIncludePointer()) {
      var value = $gameVariables.value(strokeNum);
      $gameVariables.setValue(strokeNum, value + TouchInput.pressedDistance);
    }
  };

  Sprite_Picture.prototype.updatePointer = function () {
    var strokeNum = $gameScreen.getPicturePid(this._pictureId);
    if (strokeNum > 0) {
      this.opacity = TouchInput.isPressed() ? 255 : 0;
      this.x = TouchInput.x;
      this.y = TouchInput.y;
      this.anchor.x = 0.5;
      this.anchor.y = 0.5;
    }
  };

  Sprite_Picture.prototype.callTouch = function () {
    var commandIds = $gameScreen.getPictureCid(this._pictureId);
    if (!commandIds || SceneManager.isNextScene(Scene_Battle)) {
      return;
    }
    for (var i = 0, n = this._triggerHandler.length; i < n; i++) {
      var handler = this._triggerHandler[i];
      if (
        handler &&
        commandIds[i] &&
        handler.call(this) &&
        (this.triggerIsFocus(i) || !this.isTransparent())
      ) {
        this.fireTouchEvent(commandIds, i);
      }
    }
  };

  Sprite_Picture.prototype.fireTouchEvent = function (commandIds, i) {
    if (paramSuppressTouch) TouchInput.suppressEvents();
    if (this.triggerIsLongPressed(i)) TouchInput._pressedTime = -60;
    if (this.triggerIsOnFocus(i)) this._onMouse = false;
    if (this.triggerIsOutFocus(i)) this._outMouse = false;
    $gameTemp.onTouchPicture(commandIds[i], this._pictureId);
  };

  Sprite_Picture.prototype.triggerIsLongPressed = function (triggerId) {
    return triggerId === 3;
  };

  Sprite_Picture.prototype.triggerIsOnFocus = function (triggerId) {
    return triggerId === 4;
  };

  Sprite_Picture.prototype.triggerIsOutFocus = function (triggerId) {
    return triggerId === 5;
  };

  Sprite_Picture.prototype.triggerIsFocus = function (triggerId) {
    return (
      this.triggerIsOnFocus(triggerId) || this.triggerIsOutFocus(triggerId)
    );
  };

  Sprite_Picture.prototype.isTransparent = function () {
    if (this.isTouchPosInFrameWindow()) return false;
    if (!this.isValidTransparent()) return false;
    if (this.opacity === 0) return true;
    var dx = this.getTouchScreenX() - this.x;
    var dy = this.getTouchScreenY() - this.y;
    var sin = Math.sin(-this.rotation);
    var cos = Math.cos(-this.rotation);
    var bx =
      Math.floor(dx * cos + dy * -sin) / this.scale.x +
      this.anchor.x * this.width;
    var by =
      Math.floor(dx * sin + dy * cos) / this.scale.y +
      this.anchor.y * this.height;
    return this.bitmap.getAlphaPixel(bx, by) === 0;
  };

  Sprite_Picture.prototype.isValidTransparent = function () {
    var transparent = $gameScreen.getPictureTransparent(this._pictureId);
    return transparent !== null ? transparent : paramTransparentConsideration;
  };

  Sprite_Picture.prototype.screenWidth = function () {
    return (this.width || 0) * this.scale.x;
  };

  Sprite_Picture.prototype.screenHeight = function () {
    return (this.height || 0) * this.scale.y;
  };

  Sprite_Picture.prototype.screenX = function () {
    return (this.x || 0) - this.anchor.x * this.screenWidth();
  };

  Sprite_Picture.prototype.screenY = function () {
    return (this.y || 0) - this.anchor.y * this.screenHeight();
  };

  Sprite_Picture.prototype.minX = function () {
    return Math.min(this.screenX(), this.screenX() + this.screenWidth());
  };

  Sprite_Picture.prototype.minY = function () {
    return Math.min(this.screenY(), this.screenY() + this.screenHeight());
  };

  Sprite_Picture.prototype.maxX = function () {
    return Math.max(this.screenX(), this.screenX() + this.screenWidth());
  };

  Sprite_Picture.prototype.maxY = function () {
    return Math.max(this.screenY(), this.screenY() + this.screenHeight());
  };

  Sprite_Picture.prototype.isTouchPosInRect = function () {
    if (this.isTouchPosInFrameWindow()) return true;
    var dx = this.getTouchScreenX() - this.x;
    var dy = this.getTouchScreenY() - this.y;
    var sin = Math.sin(-this.rotation);
    var cos = Math.cos(-this.rotation);
    var rx = this.x + Math.floor(dx * cos + dy * -sin);
    var ry = this.y + Math.floor(dx * sin + dy * cos);
    return (
      rx >= this.minX() &&
      rx <= this.maxX() &&
      ry >= this.minY() &&
      ry <= this.maxY()
    );
  };

  Sprite_Picture.prototype.isTouchPosInFrameWindow = function () {
    if (!this._frameWindow) return false;
    var frame = this._frameWindow;
    var x = this.getTouchScreenX();
    var y = this.getTouchScreenY();
    return (
      frame.x <= x &&
      frame.x + frame.width >= x &&
      frame.y <= y &&
      frame.y + frame.height >= y
    );
  };

  Sprite_Picture.prototype.isTouchable = function () {
    return (
      this.bitmap && this.visible && this.scale.x !== 0 && this.scale.y !== 0
    );
  };

  Sprite_Picture.prototype.isTriggered = function () {
    return this.isTouchEvent(TouchInput.isTriggered);
  };

  Sprite_Picture.prototype.isCancelled = function () {
    return this.isTouchEvent(TouchInput.isCancelled);
  };

  Sprite_Picture.prototype.isLongPressed = function () {
    return this.isTouchEvent(TouchInput.isLongPressed);
  };

  Sprite_Picture.prototype.isPressed = function () {
    return this.isTouchEvent(TouchInput.isPressed);
  };

  Sprite_Picture.prototype.isReleased = function () {
    return this.isTouchEvent(TouchInput.isReleased);
  };

  Sprite_Picture.prototype.isRepeated = function () {
    return this.isTouchEvent(TouchInput.isRepeated);
  };

  Sprite_Picture.prototype.isOnFocus = function () {
    return this._onMouse;
  };

  Sprite_Picture.prototype.isOutFocus = function () {
    return this._outMouse;
  };

  Sprite_Picture.prototype.isMoved = function () {
    return this.isTouchEvent(TouchInput.isMoved);
  };

  Sprite_Picture.prototype.isMovedAndPressed = function () {
    return this.isTouchEvent(TouchInput.isMoved) && TouchInput.isPressed();
  };

  Sprite_Picture.prototype.isWheelTriggered = function () {
    return this.isTouchEvent(TouchInput.isWheelTriggered);
  };

  Sprite_Picture.prototype.isDoubleTriggered = function () {
    return this.isTouchEvent(TouchInput.isDoubleTriggered);
  };

  Sprite_Picture.prototype.isTouchEvent = function (triggerFunc) {
    return (
      this.isTouchable() &&
      triggerFunc.call(TouchInput) &&
      this.isTouchPosInRect()
    );
  };

  Sprite_Picture.prototype.getTouchScreenX = function () {
    return $gameScreen.disConvertPositionX(TouchInput.x);
  };

  Sprite_Picture.prototype.getTouchScreenY = function () {
    return $gameScreen.disConvertPositionY(TouchInput.y);
  };

  Sprite_Picture.prototype.isIdEquals = function (pictureId) {
    return this._pictureId === pictureId;
  };

  //=============================================================================
  // Input
  //  ピクチャクリックをキー入力に紐付けます。
  //=============================================================================
  Input._bindKeyStateFrames = new Map();
  Input.bindKeyState = function (name) {
    this._currentState[name] = true;
    this._bindKeyStateFrames.set(name, 5);
  };

  var _Input_update = Input.update;
  Input.update = function () {
    _Input_update.apply(this, arguments);
    this._updateBindKeyState();
  };

  Input._updateBindKeyState = function () {
    this._bindKeyStateFrames.forEach(function (frame, keyName) {
      frame--;
      if (frame === 0 || !this._currentState[keyName]) {
        this._currentState[keyName] = false;
        this._bindKeyStateFrames.delete(keyName);
      } else {
        this._bindKeyStateFrames.set(keyName, frame);
      }
    }, this);
  };

  //=============================================================================
  // TouchInput
  //  ホイールクリック、ダブルクリック等を実装
  //=============================================================================
  TouchInput.keyDoubleClickInterval = 300;
  TouchInput._pressedDistance = 0;
  TouchInput._prevX = -1;
  TouchInput._prevY = -1;

  Object.defineProperty(TouchInput, "pressedDistance", {
    get: function () {
      return this._pressedDistance;
    },
    configurable: true,
  });

  TouchInput.suppressEvents = function () {
    this._triggered = false;
    this._cancelled = false;
    this._released = false;
    this._wheelTriggered = false;
    this._doubleTriggered = false;
  };

  TouchInput._onMouseMove = function (event) {
    var x = Graphics.pageToCanvasX(event.pageX);
    var y = Graphics.pageToCanvasY(event.pageY);
    this._onMove(x, y);
  };

  var _TouchInput_clear = TouchInput.clear;
  TouchInput.clear = function () {
    _TouchInput_clear.apply(this, arguments);
    this._events.wheelTriggered = false;
    this._events.doubleTriggered = false;
  };

  var _TouchInput_update = TouchInput.update;
  TouchInput.update = function () {
    _TouchInput_update.apply(this, arguments);
    this._wheelTriggered = this._events.wheelTriggered;
    this._doubleTriggered = this._events.doubleTriggered;
    this._events.wheelTriggered = false;
    this._events.doubleTriggered = false;
  };

  TouchInput.isWheelTriggered = function () {
    return this._wheelTriggered;
  };

  TouchInput.isDoubleTriggered = function () {
    return this._doubleTriggered;
  };

  var _TouchInput_onMiddleButtonDown = TouchInput._onMiddleButtonDown;
  TouchInput._onMiddleButtonDown = function (event) {
    _TouchInput_onMiddleButtonDown.apply(this, arguments);
    var x = Graphics.pageToCanvasX(event.pageX);
    var y = Graphics.pageToCanvasY(event.pageY);
    if (Graphics.isInsideCanvas(x, y)) {
      this._onWheelTrigger(x, y);
    }
  };

  TouchInput._onWheelTrigger = function (x, y) {
    this._events.wheelTriggered = true;
    this._x = x;
    this._y = y;
  };

  var _TouchInput_onTrigger = TouchInput._onTrigger;
  TouchInput._onTrigger = function (x, y) {
    if (this._date && Date.now() - this._date < this.keyDoubleClickInterval)
      this._events.doubleTriggered = true;
    this._pressedDistance = 0;
    this._prevX = x;
    this._prevY = y;
    _TouchInput_onTrigger.apply(this, arguments);
  };

  var _TouchInput_onMove = TouchInput._onMove;
  TouchInput._onMove = function (x, y) {
    if (this.isPressed())
      this._pressedDistance =
        Math.abs(this._prevX - x) + Math.abs(this._prevY - y);
    this._prevX = x;
    this._prevY = y;
    _TouchInput_onMove.apply(this, arguments);
  };

  var _TouchInput_onRelease = TouchInput._onRelease;
  TouchInput._onRelease = function (x, y) {
    this._pressedDistance = 0;
    this._prevX = x;
    this._prevY = y;
    _TouchInput_onRelease.apply(this, arguments);
  };
})();


code:
//============================================================================
// PictureLoop.js
//============================================================================

/*:
 * @plugindesc ピクチャをランダム間隔で表示させます
 * @author riru
 *
 * @param Pictureloop Count1
 * @desc まばたき用ベース間隔。
 * @default 60
 *
 * @param Pictureloop Count2
 * @desc まばたき用ランダム間隔。ベース間隔＋この数値までのランダムで出た間隔でまばたきします
 * @default 100
 *
 * @help
 *
 * まばたきプラグイン ver 1.02
 *
 * ＜使い方＞
 * イベントコマンド「スクリプト」で以下のように記述してください
 * LoopPicture(ピクチャ番号,閉じかけ目ピクチャネーム,閉じ目ピクチャネーム,
 * 原点, x, y, X拡大率, Y拡大率, 不透明度, 合成方法);
 *
 * ピクチャ番号…イベントコマンド「ピクチャの表示」の番号と同じです。
 * 数字が多いほど上に表示されます。通常のピクチャと共有なので、
 * 同時に表示させたいピクチャと番号が被らないようにしてください
 * 原点…〃表示位置と同じです。0で左上、1で中心が原点になります。
 * 拡大率…100で原寸です。-をつけると反転します。
 * 不透明度…0～255で設定できます。数字が低いほど透明になります。
 * 合成方法…ピクチャの表示の合成方法と同じです。
 * 0で通常、1で加算、2で乗算になります
 * ※数字の場所は
 *
 * 例：
 *  LoopPicture(1,"actor1tojikake","actortoji", 0, 10, 80, -100, 100, 255, 0);
 * ピクチャ名が長い場合は代入してもOKです
 * name = "actor1tojikake";
 * name2 = "actor1tojikake";
 * x = $gameVariables.value(5);
 * y = $gameVariables.value(6);
 * LoopPicture(7,name,name2, 0, x, y, 100, 100, 255, 0);
 *
 * 瞬きをとめる場合は同じくイベントコマンドスクリプトで以下を記入
 * EraseLoopPicture(瞬きしているピクチャ番号);
 * 例：EraseLoopPicture(7);
 *  ＜規約＞
 *  有償無償問わず使用できます。改変もご自由にどうぞ。使用報告もいりません。
 * ２次配布は作成者を偽らなければOKです
 * （ただし素材単品を有償でやりとりするのはNG）。
 * 著作権は放棄していません。
 * 使用する場合は以下の作者とURLをreadmeなどどこかに記載してください
 *
 *  ＜作者情報＞
 * 作者：riru
 * HP：ガラス細工の夢幻
 * URL：http://garasuzaikunomugen.web.fc2.com/index.html
 *
 * ＜更新情報＞
 * 2015/11/21  1.00公開。
 * 2015/12/23  1.01。バトル中では反映されない不具合を修正。
 * 2019/6/3  1.02。まばたきを止める時に条件によってどのピクチャ番号を入れても
 * 止まってしまう不具合を修正。
 */

var parameters = PluginManager.parameters("PictureLoop");
var PictureloopCount1 = Number(parameters["Pictureloop Count1"] || 60);
var PictureloopCount2 = Number(parameters["Pictureloop Count2"] || 100);

function LoopPicture(
  layer,
  name,
  name2,
  origin,
  x,
  y,
  scaleX,
  scaleY,
  opacity,
  blendMode
) {
  $gameScreen.CreateLoopPictureCount(layer);
  $gameScreen.CreateLoopPicture(
    layer,
    name,
    name2,
    origin,
    x,
    y,
    scaleX,
    scaleY,
    opacity,
    blendMode
  );
}
LoopPictures = new Array(100);
LoopPictureCount_rand = new Array(100);
LoopPicture_v = 0; //現在瞬きしている数
//まばたき用ピクチャの消去
function EraseLoopPicture(layer) {
  if (typeof !LoopPictures[layer] == null) LoopPicture_v -= 1;
  LoopPictureCount[layer] = null;
  LoopPictures[layer] = null;
  var realPictureId = $gameScreen.realPictureId(layer);
  if ($gameScreen._pictures[realPictureId] != null)
    $gameScreen.erasePicture(layer);
}
//ループピクチャの情報作成
Game_Screen.prototype.CreateLoopPicture = function (
  layer,
  name,
  name2,
  origin,
  x,
  y,
  scaleX,
  scaleY,
  opacity,
  blendMode
) {
  LoopPictures[layer] = [
    layer,
    name,
    name2,
    origin,
    x,
    y,
    scaleX,
    scaleY,
    opacity,
    blendMode,
  ];
  LoopPicture_v += 1;
  LoopPictureCount_rand[layer] = [];
  LoopPictureCount_rand[layer] = Math.floor(
    Math.random() * PictureloopCount2 + 1 + PictureloopCount1
  ); //瞬きの間隔を作成
};
var picture_loop_flug = false; //まばたきしているか？

//ループピクチャの情報作成
var LoopPictureCount = []; //new Array();
Game_Screen.prototype.CreateLoopPictureCount = function (layer) {
  LoopPictureCount[layer] = 0;
  picture_loop_flug = true; //まばたきしているか？
};
//まばたき用ピクチャループ
Game_Screen.prototype.LoopPicture = function (
  layer,
  name,
  name2,
  origin,
  x,
  y,
  scaleX,
  scaleY,
  opacity,
  blendMode
) {
  switch (LoopPictureCount[layer]) {
    case LoopPictureCount_rand[layer]:
      //閉じかけ目表示
      //  alert(layer);
      $gameScreen.showPicture(
        layer,
        name,
        origin,
        x,
        y,
        scaleX,
        scaleY,
        opacity,
        blendMode
      );
      break;
    case LoopPictureCount_rand[layer] + 10:
      //閉じかけ目表示
      $gameScreen.showPicture(
        layer,
        name,
        origin,
        x,
        y,
        scaleX,
        scaleY,
        opacity,
        blendMode
      );
      break;
    case LoopPictureCount_rand[layer] + 5:
      //閉じ目表示
      $gameScreen.showPicture(
        layer,
        name2,
        origin,
        x,
        y,
        scaleX,
        scaleY,
        opacity,
        blendMode
      );
      break;
    case LoopPictureCount_rand[layer] + 15:
      $gameScreen.erasePicture(layer);
      LoopPictureCount[layer] = 0;
      LoopPictureCount_rand[layer] = Math.floor(
        Math.random() * PictureloopCount2 + 1 + PictureloopCount1
      ); //瞬きの間隔を作成
      break;
    default:
      break;
  }
};

//フレーム更新
var RiruPictureloop_Update = Game_Screen.prototype.update;
Game_Screen.prototype.update = function (sceneActive) {
  RiruPictureloop_Update.call(this, sceneActive);
  this.updateLooppicture(); //riru追加
};
//まばたき更新
Game_Screen.prototype.updateLooppicture = function () {
  if (picture_loop_flug == true) {
    var j = 0;
    for (i = 1; i < 101; i++) {
      if (j == LoopPicture_v) break;
      if (LoopPictures[i] != null) {
        var layer = LoopPictures[i];
        if (LoopPictureCount[LoopPictures[i][0]] != null) {
          LoopPictureCount[LoopPictures[i][0]] += 1;
          this.LoopPicture(
            layer[0],
            layer[1],
            layer[2],
            layer[3],
            layer[4],
            layer[5],
            layer[6],
            layer[7],
            layer[8],
            layer[9],
            layer[10]
          );
        }
      }
    }
  }
};

repo_name: Idkwtcm/violated

license: unknown


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

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

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

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

  var getParamOther = function (paramNames) {
    if (!Array.isArray(paramNames)) paramNames = [paramNames];
    for (var i = 0; i < paramNames.length; i++) {
      var name = PluginManager.parameters(pluginName)[paramNames[i]];
      if (name) return name;
    }
    return null;
  };

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

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

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

  var getArgArrayString = function (args, upperFlg) {
    var values = getArgString(args, upperFlg).split(",");
    for (var i = 0; i < values.length; i++) values[i] = values[i].trim();
    return values;
  };

  var getArgArrayNumber = function (args, min, max) {
    var values = getArgArrayString(args, false);
    if (arguments.length < 2) min = -Infinity;
    if (arguments.length < 3) max = Infinity;
    for (var i = 0; i < values.length; i++)
      values[i] = (parseInt(values[i], 10) || 0).clamp(min, max);
    return values;
  };

  var convertEscapeCharactersAndEval = function (text, evalFlg) {
    if (text === null || text === undefined) text = "";
    var window = SceneManager._scene._windowLayer.children[0];
    if (window) {
      var result = window.convertEscapeCharacters(text);
      return evalFlg ? eval(result) : result;
    } else {
      return text;
    }
  };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


code:
//
//  ポップアップメッセージ ver1.02
//
// ------------------------------------------------------
// Copyright (c) 2016 Yana
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
// ------------------------------------------------------
//
// author Yana
//

var Imported = Imported || {};
Imported["PopupMessage"] = 1.02;

if (!Imported.CommonPopupCore) {
  console.error("CommonPopupCoreを導入してください。");
}

/*:
 * @plugindesc ver1.02/メッセージの表示をポップアップに変更する制御文字_pum[delay,x,y,action]を追加します。
 * @author Yana
 *
 * @param Pop Message FontSize
 * @desc ポップアップメッセージのデフォルトフォントサイズです。
 * @default 28
 *
 * @param Pop Message Count
 * @desc ポップアップメッセージの表示時間です。
 * @default 120
 *
 * @param Popup Pattern
 * @desc ポップアップパターンの初期設定です。
 * @default Down
 *
 * @help プラグインコマンドはありません。
 *
 * メッセージの表示のメッセージの中に_pum[delay,x,y,action,pattern]と記述することで、
 * メッセージをポップアップに変更します。
 * delayはディレイ値で、この値フレーム分待ってから、ポップアップを行います。
 * xは表示位置のX座標です。未指定の場合は、0が設定されます。
 * yは表示位置のY座標です。未指定の場合は、画面高さ-ポップアップの高さが設定されます。
 * actionはアクション形式です。1を指定すると、上から下にアクションします。
 * patternは動作パターンです。Normalで今まで通り、GrowUpでにょき、Stretchでうにょーんとなります。
 * ------------------------------------------------------
 * 利用規約
 * ------------------------------------------------------
 * 当プラグインはMITライセンスで公開されています。
 * 使用に制限はありません。商用、アダルト、いずれにも使用できます。
 * 二次配布も制限はしませんが、サポートは行いません。
 * 著作表示は任意です。行わなくても利用できます。
 * 要するに、特に規約はありません。
 * バグ報告や使用方法等のお問合せはネ実ツクールスレ、または、Twitterにお願いします。
 * https://twitter.com/yanatsuki_
 * 素材利用は自己責任でお願いします。
 * ------------------------------------------------------
 * このプラグインには「汎用ポップアップベース」のプラグインが必要です。
 * 汎用ポップアップベースより下に配置してください。
 * ------------------------------------------------------
 * 更新履歴:
 * ver1.03:
 * 各パラメータに制御文字が使用できるように変更。
 * ポップアップパターンのプラグインパラメータを追加。
 * ver1.02:
 * 動作パターンの設定を追加。
 * ver1.01:
 * 表示位置を調整する機能を追加。
 * ver1.00:
 * 公開
 */

(function () {
  "use strict";

  var parameters = PluginManager.parameters("PopupMessage");
  var popMesFontSize = Number(parameters["Pop Message FontSize"] || 28);
  var popMesCount = Number(parameters["Pop Message Count"] || 120);
  var popMesSlide = Number(parameters["Pop Message Slide"] || 60);
  var popupPattern = parameters["Popup Pattern"] || 0;
  var popMesRegExp = /_PUM\[(.+)\]/gi;

  var _pMes_GInterpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _pMes_GInterpreter_pluginCommand.call(this, command, args);
    if (command === "PopupMessage") {
    }
  };

  var _pMes_GInterpreter_c101 = Game_Interpreter.prototype.command101;
  Game_Interpreter.prototype.command101 = function () {
    var texts = [];
    var pIndex = this._index;
    var param = { delay: null };
    while (this.nextEventCode() === 401) {
      this._index++;
      texts.push(this.currentCommand().parameters[0]);
    }
    var window = CommonPopupManager.window();
    for (var i = 0; i < texts.length; i++) {
      if (texts[i].match(popMesRegExp)) {
        var ary = [0, null, null, 0, popupPattern];
        var text = texts[i].replace(
          popMesRegExp,
          function () {
            var arg = arguments[1].split(",");
            ary[0] = Number(window.convertEscapeCharacters(arg[0]));
            if (arg[1]) ary[1] = Number(window.convertEscapeCharacters(arg[1]));
            if (arg[2]) ary[2] = Number(window.convertEscapeCharacters(arg[2]));
            if (arg[3]) ary[3] = Number(window.convertEscapeCharacters(arg[3]));
            if (arg[4]) ary[4] = arg[4];
            return "";
          }.bind(this)
        );
        texts[i] = text;
        CommonPopupManager.setPopupMessage(this._params, texts, ary);
        return true;
      }
    }
    this._index = pIndex;
    var result = _pMes_GInterpreter_c101.call(this);
    return result;
  };

  var _pMes_GMessage_add = Game_Message.prototype.add;
  Game_Message.prototype.add = function (text) {
    text = text.replace(popMesRegExp, "");
    _pMes_GMessage_add.call(this, text);
  };

  CommonPopupManager.setPopupMessage = function (params, texts, ary) {
    this._readyPopup = this._readyPopup || [];
    var bitmap = ImageManager.loadFace(params[0]);
    this.bltCheck(bitmap);
    this._readyPopup.push([params, texts, ary, "pMessage"]);
  };

  var _pMes_CPManager_makeBitmap = CommonPopupManager.makeBitmap;
  CommonPopupManager.makeBitmap = function (arg) {
    if (arg[3] === "pMessage") {
      return ImageManager.loadFace(arg[0][0]);
    } else {
      return _pMes_CPManager_makeBitmap.call(this, arg);
    }
  };

  var _pMes_CPManager_startPopup = CommonPopupManager.startPopup;
  CommonPopupManager.startPopup = function (arg) {
    if (arg[3] === "pMessage") {
      this.startPopupMessage(arg[0], arg[1], arg[2]);
    } else {
      _pMes_CPManager_startPopup.call(this, arg);
    }
  };

  CommonPopupManager.startPopupMessage = function (params, texts, arg) {
    var fontSize = popMesFontSize;
    var oneHeight = fontSize + 8;
    var height = params[0] ? 144 : oneHeight * texts.length;
    var bitmap = new Bitmap(Graphics.boxWidth, height);
    var faceSize = params[0] === "" ? 0 : 144;
    var delay = arg[0];
    var x = arg[1];
    var y = arg[2];
    var action = arg[3];
    var pattern = arg[4];
    bitmap.fillRect(0, 0, bitmap.width / 2, bitmap.height, "rgba(0,0,0,0.5)");
    bitmap.gradientFillRect(
      bitmap.width / 2,
      0,
      bitmap.width / 2,
      bitmap.height,
      "rgba(0,0,0,0.5)",
      "rgba(0,0,0,0)"
    );
    this.window().contents = bitmap;
    this.window().drawTextEx("\\FS[" + fontSize + "]", 0, 0);
    this.window().drawFace(params[0], params[1], 0, 0);
    var iFontSize = fontSize;
    for (var i = 0; i < texts.length; i++) {
      var text = "\\FS[" + iFontSize + "]" + texts[i];
      this.window().drawTextEx(text, 8 + faceSize, i * oneHeight);
      iFontSize = this.window().contents.fontSize;
    }
    var arg = this.setPopup([]);
    arg.bitmap = bitmap;
    if (pattern === "GrowUp") {
      arg.x = 0;
      arg.y = Graphics.boxHeight;
      arg.moveX = 0;
      arg.anchorX = 0;
      arg.anchorY = 1.0;
      arg.pattern = -2;
    } else if (pattern === "Stretch") {
      arg.x = 0;
      arg.y = Graphics.boxHeight - height;
      arg.moveX = 0;
      arg.anchorX = 0;
      arg.anchorY = 0;
      arg.pattern = -1;
    } else {
      arg.x = Graphics.boxWidth * -1;
      arg.y = Graphics.boxHeight - height;
      arg.moveX = Graphics.boxWidth;
      arg.anchorX = 0;
      arg.anchorY = 0;
    }
    if (x) {
      arg.x += x;
    }
    if (y) {
      arg.y = y;
    }
    if ($gameParty.inBattle()) {
      arg.y = Math.min(Graphics.boxHeight - 180, arg.y);
    }
    arg.moveY = 0;
    arg.count = popMesCount;
    arg.fixed = false;
    arg.slideCount = popMesSlide;
    if (action === 1) {
      arg.slideAction = "Down";
    }
    arg.delay = delay;
    this._tempCommonSprites.setNullPos(arg);
  };
})();


code:
//=============================================================================
// RecollectionMode_through_command_patch.js

// RecollectionMode(https://github.com/rinne-grid/tkoolmv_plugin_RecollectionMode)
// Copyright (c) 2016 rinne_grid
// This plugin is released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:ja
 * @plugindesc RecollectionModeのパッチです。タイトルから直接回想閲覧に遷移します
 * @author rinne_grid
 *
 *
 * @help このプラグインには、プラグインコマンドはありません。
 *
 */

// 回想モードのカーソル
Scene_Recollection.rec_list_index = 0;

// 回想モードの背景に表示する画像
Scene_Recollection.background_image_name = "background";

Scene_Recollection.prototype.createCommandWindow = function () {
  // 回想モード選択ウィンドウ
  this._rec_window = new Window_RecollectionCommand();
  this._rec_window.setHandler(
    "select_recollection",
    this.commandShowRecollection.bind(this)
  );
  this._rec_window.setHandler("select_cg", this.commandShowCg.bind(this));
  this._rec_window.setHandler(
    "select_back_title",
    this.commandBackTitle.bind(this)
  );

  // パッチ：選択ウィンドウを非表示にする。通常はここがtrue
  this._rec_window.visible = false;
  this._rec_window.deactivate();
  this.addWindow(this._rec_window);

  // 回想リスト
  this._rec_list = new Window_RecList(0, 0, Graphics.width, Graphics.height);

  // パッチ：回想リストを表示にする。通常はここがfalse
  this._rec_list.visible = true;
  this._rec_list.setHandler("ok", this.commandDoRecMode.bind(this));
  this._rec_list.setHandler("cancel", this.commandBackSelectMode.bind(this));
  this._mode = "recollection";
  this._rec_list.activate();
  this._rec_list.select(Scene_Recollection.rec_list_index);
  this._rec_list.opacity = 0;

  this.addWindow(this._rec_list);

  // CG参照用ダミーコマンド
  this._dummy_window = new Window_Command(0, 0);
  this._dummy_window.deactivate();
  this._dummy_window.visible = false;
  this._dummy_window.setHandler("ok", this.commandDummyOk.bind(this));
  this._dummy_window.setHandler("cancel", this.commandDummyCancel.bind(this));
  this._dummy_window.addCommand("next", "ok");
  this.addWindow(this._dummy_window);
};

//-------------------------------------------------------------------------
// ● 回想orCGモードから「キャンセル」して前の画面に戻った場合のコマンド
//-------------------------------------------------------------------------
Scene_Recollection.prototype.commandBackSelectMode = function () {
  // タイトルに戻る場合は、インデックスをリセットする
  Scene_Recollection.rec_list_index = 0;
  SceneManager.goto(Scene_Title);
};