code:
//=============================================================================
//  Keke_KageMaster - 影マスター
// バージョン: 3.1
//=============================================================================
// Copyright (c) 2020 ケケー
// Released under the MIT license
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc リアルな影を手軽に自在につけられるよ
 * @author ケケー
 *
 *
 *
 * @param プレイヤー影タイプ
 * @desc  - プレイヤーの影の形。本体準拠の形をした real と、シンプルな円形の circle、影を表示しない none の三種類 初期値 real
 * @type select
 * @option real
 * @option circle
 * @option none
 * @default real
 *
 * @param キャラ影タイプ
 * @desc  - キャラクターの影の形。本体準拠の形をした real と、シンプルな円形の circle、影を表示しない none の三種類 初期値 real
 * @type select
 * @option real
 * @option circle
 * @option none
 * @default real
 *
 * @param オブジェクト影タイプ
 * @desc  - オブジェクトの影の形。 オブジェクトとは頭文字が ! の画像ファイルをもつイベントのこと 初期値 real
 * @type select
 * @option real
 * @option circle
 * @option none
 * @default real
 *
 * @param 乗り物影タイプ
 * @desc  - 乗り物の影の形。初期値 real
 * @type select
 * @option real
 * @option circle
 * @option none
 * @default real
 *
 * @param アクター影タイプ
 * @desc  - アクターの影の形。本体準拠の形をした real と、シンプルな円形の circle、影を表示しない none の三種類 初期値 real
 * @type select
 * @option real
 * @option circle
 * @option none
 * @default real
 *
 * @param エネミー影タイプ
 * @desc  - アクターの影の形。本体準拠の形をした real と、シンプルな円形の circle、影を表示しない none の三種類 初期値 real
 * @type select
 * @option real
 * @option circle
 * @option none
 * @default real
 *
 * @param マップ/影の位置(リアル)
 * @desc リアル形時の影の位置。1番目の数値がX軸で、2番目がY軸
 。数値が高いほど右下にいく - 初期値 [20, -25]
 * @default [20, -25]
 *
 * @param マップ/影の位置(円形)
 * @desc 円形時の影の位置。1番目の数値がX軸で、2番目がY軸
 。数値が高いほど右下にいく - 初期値 [0, -5]
 * @default [0, -5]
 *
 * @param マップ/影サイズ(リアル)
 * @desc リアル形時の影の大きさ。1番目の数値がX軸で、2番目がY軸 - 初期値 [110, 50]
 * @default [110, 50]
 *
 * @param マップ/影サイズ(円形)
 * @desc 円形時の影の大きさ。1番目の数値がX軸で、2番目がY軸 - 初期値 [85, 30]
 * @default [85, 30]
 *
 * @param マップ/影の角度
 * @desc 影の傾き角。数値を増やすほど右回りに回転していく - 初期値 0
 * @default 0
 *
 * @param バトル/影の位置(リアル)
 * @desc リアル形時の影の位置。1番目の数値がX軸で、2番目がY軸
 。数値が高いほど右下にいく - 初期値 [20, -25]
 * @default [20, -25]
 *
 * @param バトル/影の位置(円形)
 * @desc 円形時の影の位置。1番目の数値がX軸で、2番目がY軸
 。数値が高いほど右下にいく - 初期値 [0, -5]
 * @default [0, -5]
 *
 * @param バトル/影サイズ(リアル)
 * @desc リアル形時の影の大きさ。1番目の数値がX軸で、2番目がY軸 - 初期値 [110, 50]
 * @default [110, 50]
 *
 * @param バトル/影サイズ(円形)
 * @desc 円形時の影の大きさ。1番目の数値がX軸で、2番目がY軸 - 初期値 [85, 30]
 * @default [85, 30]
 *
 * @param バトル/影の角度
 * @desc 影の傾き角。数値を増やすほど右回りに回転していく - 初期値 0
 * @default 0
 *
 * @param 影の不透明度
 * @desc 影の濃さ。高いほど濃い - 初期値 128
 * @default 128
 *
 * @param 影のぼかし度(リアル)
 * @desc リアル形時の影のぼかしの強さ。ブラウザプレイでは1以上にすると影が出ないので注意 - 初期値 0
 * @default 0
 *
 * @param 影のぼかし度(円形)
 * @desc 円形時の影のぼかしの強さ。 - 初期値 15
 * @default 15
 *
 * @param 影のジャンプ縮小度
 * @desc 影がジャンプ時どれくらい小さくなるか。数値が高いほど小さくなる - 初期値 7
 * @default 7
 *
 * @param 影の向き反転
 * @desc 影を向きによって反転させるか - 初期値 false
 * @type boolean
 * @default false
 *
 * @param アクター死亡時影消す
 * @desc アクターが戦闘不能になったとき影を消すか - 初期値 false
 * @type boolean
 * @default false
 *
 * @param エネミー死亡時影消す
 * @desc エネミーが戦闘不能になったとき影を消すか - 初期値 false
 * @type boolean
 * @default false
 *
 *
 *
 * @help
 *
 *【注意】
 * このプラグインには『ベーシックパック』ver.1.5以上が必要だよ
 * まだ入れてないなら、このURLからダウンロードしてね
 * http://kekeelabo.com/?i=3
 *
 *
 * リアルな影を手軽に自在につけられるよ
 * マップ・バトル両対応
 * 豪華なリアル形から、シンプルな円形までなんでもござれー
 * 見た目の立体感を素敵にグレードアップするよ
 * しかも面倒な手間いらずのお手軽仕様だよ
 *
 * おもな機能は以下の通りだよ
 *
 *
 * ・特に指示は出さなくても自動的に影を表示
 *
 * ・本体が透明の場合は表示しない
 *
 * ・本体のサイズに応じ、自動的に影の大きさが変わる
 *
 * ・また、影は本体に合わせて動く。本体が倒れれば、影も倒れる
 *
 * ・つまり特に手間をかけずとも、リアルな影を表示して
 * ゲームの見た目をグレードアップできる
 *
 * ・自動表示はグローバル設定に従って行われる
 * グローバル設定をカスタマイズすることで、より好みの形にしていける
 * 設定はプラグインパラメータで行う
 *
 * ・カテゴリーごとに、影を表示するかしないか選べる
 * カテゴリーはプレイヤー、キャラ、オブジェクト、乗り物、
 * アクター、エネミーの6種類
 *
 * ・カテゴリーごとに影の形を選べる
 * ・本体と同じ形の『リアル形』と、『円形』の2種類
 *
 * ・影の位置・サイズ・角度・不透明度・ぼかし度を自由に調整できる
 *
 * ・本体がジャンプすると、高く飛ぶほどに影が小さくなる
 * 小さくなる度合いは好きに調整できる
 *
 * ・基本的に影の位置は固定だが、向きによって反転させるようにもできる
 * 左を向いてる時は右に、右を向いてる時は左に表示させ、
 * 常に影が本体の後ろにある感じにするなど
 *
 * ・プラグインコマンドで、マップ上の全ての影を消したり出したりできる
 * ここは影があると不自然だなという場面に
 *
 * ・プラグインコマンドで、マップ上の影を全て反転させることができる
 * 太陽の位置が変わり、影の向きも変わったというような表現に
 *
 * ・基本的には自動で一括表示するのを想定しているが、
 * 各対象ごとに細かく影の設定をすることも可能
 * 設定のしかたは以下
 *
 *
 *
 * ▼ メモ欄での影設定 ▼
 *
 * 影設定したい対象が
 * イベントの場合 → イベントのメモ欄に
 * アクターの場合 → アクターのメモ欄に
 * エネミーの場合 → エネミーのメモ欄に
 * マップキャラ全ての場合は → マップのメモ欄に
 * これをコピペし、パラメータをいじる
 * <kage:real|0:0|*0:0|&0>
 *
 各パラメータの意味は後述
 *
 * まだ、設定したい対象がアクターのホコグラの場合は
 * <kageH:real|0:0|*0:0|&0>
 *
 * kageH の H はホコグラの略
 *
 * ◉パラメータの説明
 *
 * type|px:py|*sx:sy|&angle
 *
 * 【type - 影の形】
 * real にすると本体準拠のリアル形に、circle だと円形になる
 * 0か空欄にするとグローバル設定に合わせる
 * noneにすると影を消去する
 *
 * 【px:py - 影のx位置:y位置】
 * この数値分だけ影の位置がズレる。単位は本体サイズに対する百分率
 * px100なら右方向に本体横幅分ズレる
 * 0か空欄にするとグローバル設定に合わせる
 *
 * 【sx:sy - 影のxサイズ:yサイズ】
 * この数値分だけ影が伸び縮みする。単位は本体サイズに対する百分率
 * sx200なら横方向に2倍に伸びる
 * 0か空欄にするとグローバル設定に合わせる
 *
 * 【angle - 影の角度】
 * 単位は360度式角度。90なら右に90度回転する
 *
 *
 *
 * ▼ プラグインコマンドでの影設定 ▼
 *
 * これをプラグインコマンドにコピペし、パラメータをいじる
 * kage self real|0:0|*0:0|&0
 *
 * パラメータの意味はメモ欄のときと同じ
 * self の部分で対象を指定する。指定のしかたは以下
 *
 * ◉対象指定のしかた
 *
 * 指定のしかたは2通りある
 *
 * 【イベントIDでの指定】
 * 数字を入れると、そのIDのイベントが対象になる
 * -1 を入れるとプレイヤーが対象になり、
 * 0 を入れるとコマンドを実行しているイベント自身が対象になる
 *
 * 【名前での指定】
 * 数字以外の文字を入れると、名前にその文字が含まれるイベント全てが対象になる
 * play を入れるとプレイヤーが対象になり、
 * self を入れるとコマンドを実行しているイベント自身が対象になる
 * all を入れるとマップ上のイベント全てが対象になる
 * all の場合、影タイプnoneのイベントは対象外になる
 *
 *
 * ◉影の可視切り替え
 *
 * マップ上の全ての影の可視状態を切り替えたいときは
 * kage visible
 *
 * 見えている影は消え、消えている影は現れる
 *
 * 全ての影を見える状態にしたいときは
 * kage visible 1
 *
 * 全ての影を見えない状態にしたいときは
 * kage visible 0
 *
 *
 * ◉マップでの影のx総反転
 *
 * マップ上の全ての影を横軸反転したいときは
 * kage xReverse
 *
 * 全ての影を横軸反転状態にしたいときは
 * kage xReverse 1
 *
 * 全ての影を横軸反転解除したいときは
 * kage xReverse 0
 *
 *
 * ◉マップでの影のy総反転
 *
 * マップ上の全ての影を縦軸反転したいときは
 * kage yReverse
 *
 * 全ての影を縦軸反転状態にしたいときは
 * kage yReverse 1
 *
 * 全ての影を縦軸反転解除したいときは
 * kage yReverse 0
 *
 *
 *
 * ▼ 各種補足 ▼
 *
 * ・影設定パラメータは0か空欄にすると、グローバル設定が適用される
 *
 * ・影設定パラメータの各項目は省略できる
 * たとえば none だけでもよい。それだけで影が表示されなくなる
 *
 * ・サイドビューの場合、エネミーの影の位置は自動的に反転する仕様
 *
 * ・アクターや飛行機など、デフォルトの影が存在するモノは、
 * 影タイプを none にするとデフォルトの影が表示される
 *
 * ・リアル影のぼかしはブラウザプレイでは非対応
 * ぼかし度1以上にすると影が出ないので注意
 *
 *
 * ※影が出ない場合はぼかし度を0にしてみてね
 * MVのバージョンが古い場合、ぼかしに対応してないことがあるので
 *
 *
 *
 * ◉ 利用規約 ◉
 *  MITライセンスのもと、好きに使ってくれて大丈夫
 * ただし作者は何も責任を負わないよ
 * 著作権は『ケケー』にあるよ
 */

(function () {
  //--  定数  --//

  KEKE_KAGE_NAME = "kage";
  KEKE_KAGE_REG =
    /(\w*)\|?\+?(-?\d*\.?\d*):?(-?\d*\.?\d*)\|?\*?(-?\d*\.?\d*):?(-?\d*\.?\d*)\|?&?(-?\d*)/;

  //--  パラメータ受け取り  --//

  var parameters = PluginManager.parameters("Keke_KageMaster");
  var keke_playerKageType = parameters["プレイヤー影タイプ"];
  var keke_charaKageType = parameters["キャラ影タイプ"];
  var keke_objectKageType = parameters["オブジェクト影タイプ"];
  var keke_vehicleKageType = parameters["乗り物影タイプ"];
  var keke_actorKageType = parameters["アクター影タイプ"];
  var keke_enemyKageType = parameters["エネミー影タイプ"];
  var keke_mapKagePosReal = eval(parameters["マップ/影の位置(リアル)"]);
  var keke_mapKagePosCircle = eval(parameters["マップ/影の位置(円形)"]);
  var keke_mapKageSizeReal = eval(parameters["マップ/影サイズ(リアル)"]);
  var keke_mapKageSizeCircle = eval(parameters["マップ/影サイズ(円形)"]);
  var keke_mapKageAngle = Number(parameters["マップ/影の角度"]);
  var keke_battleKagePosReal = eval(parameters["バトル/影の位置(リアル)"]);
  var keke_battleKagePosCircle = eval(parameters["バトル/影の位置(円形)"]);
  var keke_battleKageSizeReal = eval(parameters["バトル/影サイズ(リアル)"]);
  var keke_battleKageSizeCircle = eval(parameters["バトル/影サイズ(円形)"]);
  var keke_battleKageAngle = Number(parameters["バトル/影の角度"]);
  var keke_kageOpacity = Number(parameters["影の不透明度"]);
  var keke_kageBlurReal = Number(parameters["影のぼかし度(リアル)"]);
  var keke_kageBlurCircle = Number(parameters["影のぼかし度(円形)"]);
  var keke_kageJumpSmall = Number(parameters["影のジャンプ縮小度"]);
  var keke_kageReverseByMuki = eval(parameters["影の向き反転"]);
  var keke_actorDeadNoKageM = eval(parameters["アクター死亡時影消す"]);
  var keke_enemyDeadNoKageM = eval(parameters["エネミー死亡時影消す"]);
  var keke_tilesetKageType = "none";

  //--  プラグインコマンド  --//

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === KEKE_KAGE_NAME) {
      if (args[0] == "xReverse") {
        if (args[1] == null) {
          $gameSystem._kageXReverse *= -1;
        } else if (Number(args[1])) {
          $gameSystem._kageXReverse = 1;
        } else {
          $gameSystem._kageXReverse = 0;
        }
      } else if (args[0] == "yReverse") {
        if (args[1] == null) {
          $gameSystem._kageYReverse *= -1;
        } else if (Number(args[1])) {
          $gameSystem._kageYReverse = 1;
        } else {
          $gameSystem._kageYReverse = 0;
        }
      } else if (args[0] == "visible") {
        if (args[1] == null) {
          $gameSystem._kageVisible = Math.abs($gameSystem._kageVisible - 1);
        } else if (Number(args[1])) {
          $gameSystem._kageVisible = 0;
        } else {
          $gameSystem._kageVisible = 1;
        }
      } else {
        var targets = this.eventNameToId(args[0]);
        var note = args[1];
        var all = args[0] == "all" ? true : false;
        targets.forEach(function (target) {
          target = target == -1 ? $gamePlayer : $gameMap.event(target);
          target._kageM.changeParam(note, true, all);
        }, this);
      }
    }
  };

  //--  共通開始  --//

  var _Game_CharacterBase_initMembers =
    Game_CharacterBase.prototype.initMembers;
  Game_CharacterBase.prototype.initMembers = function () {
    _Game_CharacterBase_initMembers.call(this);
    this._bunshins = []; // ベーシック
    this._anotherMoveX = [0];
    this._anotherMoveY = [0];
  };

  var _Game_Player_initMembers = Game_Player.prototype.initMembers;
  Game_Player.prototype.initMembers = function () {
    _Game_Player_initMembers.call(this);
    this._eventId = 0; // ベーシック
  };

  var _Sprite_Character_initialize = Sprite_Character.prototype.initialize;
  Sprite_Character.prototype.initialize = function (character) {
    _Sprite_Character_initialize.call(this, character);
    this._bsId = this._character._bsIdSet || 0; // ベーシック
    this.remakeKageM();
  };

  var _Sprite_Battler_initialize = Sprite_Battler.prototype.initialize;
  Sprite_Battler.prototype.initialize = function (battler) {
    _Sprite_Battler_initialize.call(this, battler);
    this.remakeKageM();
  };

  //--  共通更新  --//

  var _SpriteCharacter_update = Sprite_Character.prototype.update;
  Sprite_Character.prototype.update = function () {
    _SpriteCharacter_update.call(this);
    if (this._bsId == 0) {
      // ベーシック
      this.getBitmapSize();
    }
    this.makeKageM();
    this.deleteKageM();
    this.updateKageM();
  };

  var _Sprite_Battler_update = Sprite_Battler.prototype.update;
  Sprite_Battler.prototype.update = function () {
    _Sprite_Battler_update.call(this);
    if (this._battler) {
      this.makeKageM();
      this.deleteKageM();
      this.updateKageM();
    }
  };

  //--  ベーシックパック  --//

  // スクリーン座標への変換
  Game_CharacterBase.prototype.convertScreenX = function (x) {
    var tw = $gameMap.tileWidth();
    var scrolledX = $gameMap.adjustX(x);
    return Math.round(scrolledX * tw + tw / 2);
  };

  Game_CharacterBase.prototype.convertScreenY = function (y) {
    var th = $gameMap.tileHeight();
    var scrolledY = $gameMap.adjustY(y);
    return Math.round(scrolledY * th + th - this.shiftY() - this.jumpHeight());
  };

  // 角度を度数に変更
  Game_Temp.prototype.angleToDegree = function (angle) {
    angle *= 180 / Math.PI;
    if (angle < 0) {
      angle += 360;
    }
    return angle;
  };

  // 角度をπに変更
  Game_Temp.prototype.angleToRadian = function (angle) {
    angle *= Math.PI / 180;
    return angle;
  };

  //--  イベント名をイベントIDに変換する  --//
  Game_Interpreter.prototype.eventNameToId = function (name) {
    if (!name) {
      return [];
    }
    if (name == "play" || name == "-1") {
      return [-1];
    } else if (name == "self" || name == "0") {
      return [this._eventId];
    } else if (name.match(/^\d+$/)) {
      return [name];
    } else if (name == "all") {
      var result = [];
      $gameMap.events().forEach(function (event) {
        if (!event) {
          return;
        }
        result.push(event._eventId);
      }, this);
      return result.length ? result : [];
    } else {
      result = [];
      var eventName = "";
      $gameMap.events().forEach(function (event) {
        if (!event) {
          return;
        }
        eventName = event._name;
        if (eventName.includes(name)) {
          result.push(event._eventId);
        }
      }, this);
      return result.length ? result : [];
    }
  };

  // ビットマップサイズの取得(キャラクター)
  Sprite_Character.prototype.getBitmapSize = function () {
    if (!this.bitmap) {
      return;
    }
    var chara = this._character;
    if (!chara._bitmapK) {
      chara._bitmapK = {};
    }
    var bitmapK = chara._bitmapK;
    bitmapK.width = this.bitmap.width;
    bitmapK.height = this.bitmap.height;
    if (!this._characterName.match(/^!?_/)) {
      if (this._characterName.match(/^!?\$/)) {
        bitmapK.width /= 3;
        bitmapK.height /= 4;
      } else {
        bitmapK.width /= 12;
        bitmapK.height /= 8;
      }
    }
    bitmapK.widthOri = bitmapK.width;
    bitmapK.heightOri = bitmapK.height;
    bitmapK.width *= this.scale.x;
    bitmapK.height *= this.scale.y;
  };

  // ビットマップサイズの取得(バトラー)
  var _Sprite_Actor_updateBitmap = Sprite_Actor.prototype.updateBitmap;
  Sprite_Actor.prototype.updateBitmap = function () {
    _Sprite_Actor_updateBitmap.call(this);
    var bitmap = this._mainSprite.bitmap;
    if (bitmap) {
      var actor = this._actor;
      if (!actor._bitmapK) {
        actor._bitmapK = {};
      }
      var bitmapK = actor._bitmapK;
      bitmapK.width = bitmap.width;
      bitmapK.height = bitmap.height;
      if (actor._battlerName.match(/^__/)) {
        bitmapK.width /= 5;
      } else if (actor._battlerName.match(/^_/)) {
      } else {
        bitmapK.width /= 9;
        bitmapK.height /= 6;
      }
      bitmapK.widthOri = bitmapK.width;
      bitmapK.heightOri = bitmapK.height;
      bitmapK.width *= this.scale.x;
      bitmapK.height *= this.scale.y;
    }
  };

  var _Sprite_Enemy_updateBitmap = Sprite_Enemy.prototype.updateBitmap;
  Sprite_Enemy.prototype.updateBitmap = function () {
    _Sprite_Enemy_updateBitmap.call(this);
    if (this.bitmap) {
      var enemy = this._enemy;
      if (!enemy._bitmapK) {
        enemy._bitmapK = {};
      }
      var bitmapK = enemy._bitmapK;
      bitmapK.width = this.bitmap.width;
      bitmapK.height = this.bitmap.height;
      bitmapK.widthOri = bitmapK.width;
      bitmapK.heightOri = bitmapK.height;
      bitmapK.width *= this.scale.x;
      bitmapK.height *= this.scale.y;
    }
  };

  // バラスプライトの取得
  Game_Temp.prototype.searchBaraSprite = function (subject) {
    var baras = [];
    if (subject._isCharacter) {
      var eventId = subject._eventId;
      var baras = $gameTemp._baraSprites
        ? $gameTemp._baraSprites[eventId] || []
        : [];
      baras = baras[0] || [];
    } else if (subject._isBattler) {
      var battlerId = subject._actorId ? subject._actorId : subject.index();
      var baraBank = subject._actorId
        ? $gameTemp._baraSpritesActor || []
        : $gameTemp._baraSpritesEnemy || [];
      var baras = baraBank[battlerId] || [];
    }
    return baras;
  };

  //--  マップ影パラムの取得  --//

  var _Game_Map_setup = Game_Map.prototype.setup;
  Game_Map.prototype.setup = function (mapId) {
    _Game_Map_setup.call(this, mapId);
    var kageM = new Game_KageMaster();
    var meta = $dataMap.meta[KEKE_KAGE_NAME];
    this._kageMParam = kageM.getParam(meta);
  };

  //-- 影マスタークラス  --//

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

  window[Game_KageMaster.name] = Game_KageMaster;

  // 開始処理
  Game_KageMaster.prototype.initialize = function (subje) {
    if (!subje) {
      return;
    }
    this._subje = subje;
    this._isCharacter = subje._direction;
    this._isBattler = subje._status;
    this._type = "none";
    this._posX = 0;
    this._posY = 0;
    this._sizeX = 0;
    this._sizeY = 0;
    this._angle = 0;
    this._commands = [];

    // グローバル値の読み込み
    var mapParam = $gameMap._kageMParam;
    if (mapParam) {
      this._mapType = mapParam["type"];
    }

    // 位置(リアル)
    if (
      mapParam &&
      (mapParam["posX"] || mapParam["posY"]) &&
      mapParam["type"] == "real"
    ) {
      this._posRealG = [
        mapParam["posX"] || keke_mapKagePosReal[0] / 100,
        mapParam["posY"] || keke_mapKagePosReal[1] / 100,
      ];
    } else {
      this._posRealG = this._isBattler
        ? keke_battleKagePosReal
        : keke_mapKagePosReal;
      this._posRealG = [this._posRealG[0] / 100, this._posRealG[1] / 100];
    }
    // 位置(円形)
    if (
      mapParam &&
      (mapParam["posX"] || mapParam["posY"]) &&
      mapParam["type"] == "circle"
    ) {
      this._posCircleG = [
        mapParam["posX"] || keke_mapKagePosCircle[0] / 100,
        mapParam["posY"] || keke_mapKagePosCircle[1] / 100,
      ];
    } else {
      this._posCircleG = this._isBattler
        ? keke_battleKagePosCircle
        : keke_mapKagePosCircle;
      this._posCircleG = [this._posCircleG[0] / 100, this._posCircleG[1] / 100];
    }

    // サイズ(リアル)
    if (
      mapParam &&
      (mapParam["sizeX"] || mapParam["sizeY"]) &&
      mapParam["type"] == "real"
    ) {
      this._sizeRealG = [
        mapParam["sizeX"] || keke_mapKageSizeReal[0] / 100,
        mapParam["sizeY"] || keke_mapKageSizeReal[1] / 100,
      ];
    } else {
      this._sizeRealG = this._isBattler
        ? keke_battleKageSizeReal
        : keke_mapKageSizeReal;
      this._sizeRealG = [this._sizeRealG[0] / 100, this._sizeRealG[1] / 100];
    }
    // サイズ(円形)
    if (
      mapParam &&
      (mapParam["sizeX"] || mapParam["sizeY"]) &&
      mapParam["type"] == "circle"
    ) {
      this._sizeCircleG = [
        mapParam["sizeX"] || keke_mapKageSizeCircle[0] / 100,
        mapParam["sizeY"] || keke_mapKageSizeCircle[1] / 100,
      ];
    } else {
      this._sizeCircleG = this._isBattler
        ? keke_battleKageSizeCircle
        : keke_mapKageSizeCircle;
      this._sizeCircleG = [
        this._sizeCircleG[0] / 100,
        this._sizeCircleG[1] / 100,
      ];
    }

    // 角度
    if (mapParam && mapParam["angle"]) {
      this._angleG = mapParam["angle"];
    } else {
      this._angleG = $gameParty.inBattle
        ? keke_battleKageAngle
        : keke_mapKageAngle;
    }
    this.refresh();
  };

  // リフレッシュ
  Game_KageMaster.prototype.refresh = function () {
    var subje = this._subje;

    // タイプ判定
    if (subje._followers || subje._memberIndex) {
      this._type = keke_playerKageType;
    } else if (subje._characterName && subje._characterName.match(/^!/)) {
      this._type = keke_objectKageType;
    } else if (subje._isObjectCharacter) {
      this._type = keke_tilesetKageType;
    } else if (subje._type) {
      this._type = keke_vehicleKageType;
    } else if (subje._isBattler) {
      this._type = subje._enemyId ? keke_enemyKageType : keke_actorKageType;
    } else {
      this._type = keke_charaKageType;
    }
    if (this._type != "none" && this._mapType) {
      this._type = this._mapType;
    }
    this.setParam();

    // リーダー
    if (subje._followers) {
      if ($gameParty.leader()) {
        var meta = $gameParty.leader().actor().meta[KEKE_KAGE_NAME + "H"];
      }
      if (meta) {
        this.changeParam(meta);
      }
    }

    // フォロワー
    if (subje._memberIndex) {
      var index = subje._memberIndex;
      if ($gameParty.members() && $gameParty.members()[index]) {
        var meta = $gameParty.members()[index].actor().meta["kageH"];
      }
      if (meta) {
        this.changeParam(meta);
      }
    }

    // イベント
    if (subje._eventId) {
      var id = subje._eventId;
      var meta = $dataMap.events[id].meta[KEKE_KAGE_NAME];
      if (meta) {
        this.changeParam(meta);
      }
    }

    // バトラー
    if (subje._isBattler) {
      var battler = subje._enemyId ? subje.enemy() : subje.actor();
      var meta = battler.meta[KEKE_KAGE_NAME];
      if (meta) {
        this.changeParam(meta);
      }
    }

    if (this._type != "none") {
      this.arise();
    }
  };

  // 影パラムの取得
  Game_KageMaster.prototype.getParam = function (note) {
    var param = {};
    if (!note) {
      return {};
    }
    var match = note.match(KEKE_KAGE_REG);
    if (match) {
      if (match[1]) {
        param["type"] = match[1];
      }
      if (match[2]) {
        param["posX"] = Number(match[2]) / 100;
      }
      if (match[3]) {
        param["posY"] = Number(match[3]) / 100;
      }
      if (match[4]) {
        param["sizeX"] = Number(match[4]) / 100;
      }
      if (match[5]) {
        param["sizeY"] = Number(match[5]) / 100;
      }
      if (match[6]) {
        param["angle"] = Number(match[6]);
      }
    }
    return param;
  };

  // 影パラムのセット
  Game_KageMaster.prototype.setParam = function () {
    if (!this._posX) {
      this._posX =
        this._type == "circle" ? this._posCircleG[0] : this._posRealG[0];
    }
    if (!this._posY) {
      this._posY =
        this._type == "circle" ? this._posCircleG[1] : this._posRealG[1];
    }
    if (!this._sizeX) {
      this._sizeX =
        this._type == "circle" ? this._sizeCircleG[0] : this._sizeRealG[0];
    }
    if (!this._sizeY) {
      this._sizeY =
        this._type == "circle" ? this._sizeCircleG[1] : this._sizeRealG[1];
    }
    if (!this._angle) {
      this._angle = this._angleG;
    }

    // ぼかしなし判定
    this._solid =
      (this._type == "real" && keke_kageBlurReal == 0) ||
      (this._type == "circle" && keke_kageBlurCircle == 0);
  };

  // 影パラムの変更
  Game_KageMaster.prototype.changeParam = function (note, force, all) {
    if (all && this._type == "none") {
      return;
    }
    var param = this.getParam(note);
    if (param["type"]) {
      this._type = param["type"];
    }
    if (param["posX"] || force) {
      this._posX = param["posX"];
    } else {
      this._posX =
        this._type == "circle" ? this._posCircleG[0] : this._posRealG[0];
    }
    if (param["posY"] || force) {
      this._posY = param["posY"];
    } else {
      this._posY =
        this._type == "circle" ? this._posCircleG[1] : this._posRealG[1];
    }
    if (param["sizeX"] || force) {
      this._sizeX = param["sizeX"];
    } else {
      this._sizeX =
        this._type == "circle" ? this._sizeCircleG[0] : this._sizeRealG[0];
    }
    if (param["sizeY"] || force) {
      this._sizeY = param["sizeY"];
    } else {
      this._sizeY =
        this._type == "circle" ? this._sizeCircleG[1] : this._sizeRealG[1];
    }
    if (param["angle"] || force) {
      this._angle = param["angle"];
    } else {
      this._angle = this._angleG;
    }

    // ぼかしなし判定
    this.setParam();

    // 影出現
    if (force && this._type != "none") {
      this.arise();
    }
  };

  // 影の発生
  Game_KageMaster.prototype.arise = function () {
    if (this._kageType == "none") {
      return;
    }
    var bunshins = this._subje._bunshins || [];
    if (!this._commands) {
      this._commands = [];
    }
    for (i = 0; i < bunshins.length + 1; i++) {
      this._commands[i] = "make";
    }
  };

  // 影の消去
  Game_KageMaster.prototype.clear = function () {
    var bunshins = this._subje._bunshins || [];
    for (i = 0; i < bunshins.length + 1; i++) {
      this._commands[i] = "del";
    }
    if (this._followers) {
      this._followers.forEach(function (follower) {
        if (!follower) {
          return;
        }
        follower._kageM.clear();
      }, this);
    }
  };

  Game_KageMaster.prototype.saveFrame = function (frame) {
    this._frameWidth = frame.width;
    this._frameHeight = frame.height;
  };

  //-- 影・キャラクター  --//

  // 影の開始(キャラクター)
  Game_CharacterBase.prototype.initKageM = function () {
    this._kageM = new Game_KageMaster(this);
  };

  // 影スプライトの作成(キャラクター)
  Sprite_Character.prototype.makeKageM = function () {
    if (!this._character._kageM) {
      this._character.initKageM();
    }
    if (this._character._kageM._commands[this._bsId] != "make") {
      return;
    }
    if (!SceneManager._scene._spriteset) {
      return;
    }
    if (!this._character._bitmapK || !this._character._bitmapK.width) {
      return;
    }
    var kage = this._character._kageM;
    kage._commands[this._bsId] = "del";
    this.deleteKageM();
    var tilemap = SceneManager._scene._spriteset._tilemap;
    var sprite = new Sprite_KageMaster(this, this._character);
    this._kageMSprite = sprite;
    tilemap.addChildAt(sprite, 2);
    kage._commands[this._bsId] = "comp";
  };

  // 影スプライトの再作成(キャラクター)
  Sprite_Character.prototype.remakeKageM = function () {
    if (this._bsId > 0) {
      return;
    }
    if (!this._character._kageM) {
      return;
    }
    var kage = this._character._kageM;
    kage._commands.forEach(function (state, i) {
      if (state == "comp") {
        kage._commands[i] = "make";
      }
    }, this);
  };

  // 影スプライトの消去(キャラクター)
  Sprite_Character.prototype.deleteKageM = function () {
    if (this._character._kageM._commands[this._bsId] != "del") {
      return;
    }
    if (!this._kageMSprite) {
      return;
    }
    var tilemap = SceneManager._scene._spriteset._tilemap;
    tilemap.removeChild(this._kageMSprite);
    this._kageMSprite = null;
    this._character._kageM._commands[this._bsId] = 0;
  };

  // 影スプライトの更新(キャラクター)
  Sprite_Character.prototype.updateKageM = function () {
    if (!SceneManager._scene._spriteset) {
      return;
    }
    if (this._kageMSprite) {
      this._kageMSprite.update();
    }
  };

  // 影スプライトの再描画(キャラクター)
  Sprite_Character.prototype.redrawKageM = function (realOnly) {
    if (!this._character._kageM) {
      this._character.initKageM();
    }
    if (realOnly && this._character._kageM._type != "real") {
      return;
    }
    if (!this._kageMSprite) {
      return;
    }
    var kage = this._character._kageM;
    kage.arise();
  };

  var _Sprite_Character_updateBitmap = Sprite_Character.prototype.updateBitmap;
  Sprite_Character.prototype.updateBitmap = function () {
    if (this.isImageChanged()) {
      this.redrawKageM();
    }
    _Sprite_Character_updateBitmap.call(this);
  };

  var _Sprite_Character_updateCharacterFrame =
    Sprite_Character.prototype.updateCharacterFrame;
  Sprite_Character.prototype.updateCharacterFrame = function () {
    var preFrameX = this._frame.x;
    var preFrameY = this._frame.y;
    var preFrameWidth = this._frame.width;
    var preFrameHeight = this._frame.height;
    _Sprite_Character_updateCharacterFrame.call(this);
    if (this._frame.x != preFrameX) {
      this.redrawKageM(true);
    }
  };

  // 飛行機影の不透明度
  var _Game_Vehicle_shadowOpacity = Game_Vehicle.prototype.shadowOpacity;
  Game_Vehicle.prototype.shadowOpacity = function () {
    var result = _Game_Vehicle_shadowOpacity.call(this);
    if (this._kageType != "none") {
      result = 0;
    }
    return result;
  };

  //-- 影・バトラー  --//

  // 影の開始(バトラー)
  Game_BattlerBase.prototype.initKageM = function () {
    this._kageM = new Game_KageMaster(this);
  };

  // 影スプライトの作成(バトラー)
  Sprite_Battler.prototype.makeKageM = function () {
    if (!this._battler._kageM) {
      this._battler.initKageM();
    }
    if (this._battler._kageM._commands[0] != "make") {
      return;
    }
    if (!SceneManager._scene._spriteset) {
      return;
    }
    if (!this._battler._bitmapK || !this._battler._bitmapK.width) {
      return;
    }
    var kage = this._battler._kageM;
    kage._commands[0] = "del";
    this.deleteKageM();
    var battleField = SceneManager._scene._spriteset._battleField;
    var sprite = new Sprite_KageMaster(this, this._battler);
    this._kageMSprite = sprite;
    battleField.addChildAt(sprite, 2);
    kage._commands[0] = "comp";
  };

  // 影スプライトの再作成(バトラー)
  Sprite_Battler.prototype.remakeKageM = function () {
    if (!this._battler) {
      return;
    }
    if (!this._battler._kageM) {
      return;
    }
    var kage = this._battler._kageM;
    if (kage._commands[0] == "comp") {
      kage._commands[0] = "make";
    }
  };

  // 影スプライトの消去(バトラー)
  Sprite_Battler.prototype.deleteKageM = function () {
    if (this._battler._kageM._commands[0] != "del") {
      return;
    }
    if (!this._kageMSprite) {
      return;
    }
    var battleField = SceneManager._scene._spriteset._battleField;
    battleField.removeChild(this._kageMSprite);
    this._kageMSprite = null;
    this._battler._kageM._commands[0] = 0;
  };

  // 影スプライトの更新(バトラー)
  Sprite_Battler.prototype.updateKageM = function () {
    if (!SceneManager._scene._BattleFIeld) {
      return;
    }
    if (this._kageMSprite) {
      this._kageMSprite.update();
    }
  };

  // 影スプライトの再描画(バトラー)
  Sprite_Battler.prototype.redrawKageM = function (realOnly) {
    if (!this._battler._kageM) {
      this._battler.initKageM();
    }
    if (realOnly && this._battler._kageM._type != "real") {
      return;
    }
    if (!this._kageMSprite) {
      return;
    }
    var kage = this._battler._kageM;
    kage.arise();
  };

  var _Sprite_Battler_updateBitmap = Sprite_Battler.prototype.updateBitmap;
  Sprite_Battler.prototype.updateBitmap = function () {
    var preBattlerName = this._battlerName;
    _Sprite_Battler_updateBitmap.call(this);
    if (this._battlerName != preBattlerName) {
      this.redrawKageM();
    }
  };

  var _Sprite_Actor_updateFrame = Sprite_Actor.prototype.updateFrame;
  Sprite_Actor.prototype.updateFrame = function () {
    var main = this._mainSprite;
    var preFrameX = main._frame.x;
    var preFrameY = main._frame.y;
    var preFrameWidth = main._frame.width;
    var preFrameHeight = main._frame.height;
    _Sprite_Actor_updateFrame.call(this);
    if (main._frame.x != preFrameX) {
      this.redrawKageM(true);
    }
  };

  // 従来のアクター影を消去(再定義)
  var _Sprite_Actor_updateShadow = Sprite_Actor.prototype.updateShadow;
  Sprite_Actor.prototype.updateShadow = function () {
    _Sprite_Actor_updateShadow.call(this);
    if (this._kageMSprite) {
      this._shadowSprite.visible = false;
    }
  };

  // 戦闘終了時に影マスタークラスを消去
  var _Scene_Battle_terminate = Scene_Battle.prototype.terminate;
  Scene_Battle.prototype.terminate = function () {
    _Scene_Battle_terminate.call(this);
    $gameParty.members().forEach(function (actor) {
      actor._kageM = null;
    }, this);
  };

  //--  影マスタースプライト  --//

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

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

  // 影スプライトの初期化
  Sprite_KageMaster.prototype.initialize = function (oriSprite, subje) {
    Sprite.prototype.initialize.call(this);
    this._oriSprite = oriSprite;
    this._subje = subje;
    this._kage = subje._kageM;
    this._bsId = oriSprite._bsId;
    if (this._kage._isCharacter) {
      this._isCharacter = true;
    } else {
      this._isBattler = true;
    }
    this.anchor.x = 0.5;
    this.anchor.y = 0.5;
    this.z = 1;
    this.createBitmap();
    this.update();
  };

  // 影スプライトの描画
  Sprite_KageMaster.prototype.createBitmap = function () {
    var subje = this._subje;
    var kage = this._kage;
    name = this._isCharacter ? subje._characterName : subje._battlerName;
    if (!name) {
      return;
    }

    // ▼ マップ ▼//
    // 共通　　　─影スプライトの描画
    // リアル形　　　─影スプライトの描画
    // 円形　　　─影スプライトの描画

    // 共通　　　─影スプライトの描画
    var width = Math.abs(this._subje._bitmapK.widthOri);
    var height = Math.abs(this._subje._bitmapK.heightOri);
    var aWidth = width * 3.0;
    var aHeight = height * 3.0;
    var radius = width / 2;
    this.bitmap = new Bitmap(aWidth, aHeight);
    var context = this.bitmap._context;
    context.shadowColor = `rgba(0, 0, 0)`;
    var gWidth = 0;
    var realSolid = kage._type == "real" && keke_kageBlurReal == 0;
    var circleSolid = kage._type == "circle" && keke_kageBlurCircle == 0;
    if (!kage._solid) {
      gWidth = Graphics.width * 2;
      context.shadowOffsetX = gWidth;
      context.shadowOffsetY = 0;
      context.shadowBlur =
        kage._type == "real" ? keke_kageBlurReal : keke_kageBlurCircle;
    }

    // リアル形　　　─影スプライトの描画
    if (kage._type == "real") {
      var ori = subje._actorId ? this._oriSprite._mainSprite : this._oriSprite;
      var x = (aWidth - width) / 2 - gWidth;
      var y = (aHeight - height) / 2;
      var frameWidth = ori._frame.width;
      var frameHeight = ori._frame.height;
      if (this._isCharacter && ori._bushDepth > 0) {
        frameWidth = ori.patternWidth();
        frameHeight = ori.patternHeight();
        frameHeight -= ori._bushDepth;
        height -= ori._bushDepth;
      }
      this.bitmap.bltImage(
        ori.bitmap,
        ori._frame.x,
        ori._frame.y,
        frameWidth,
        frameHeight,
        x,
        y,
        width,
        height
      );
      if (kage._solid) {
        this.setColorTone([-255, -255, -255, 0]);
      }

      // 円形　　　─影スプライトの描画
    } else if (kage._type == "circle") {
      var color1 = "rgba(0, 0, 0, 0.5)";
      var color2 = "rgba(0, 0, 0, 1.0)";
      var grad = context.createLinearGradient(width / 2, 0, width / 2, height);
      grad.addColorStop(0, color1);
      grad.addColorStop(1, color2);
      context.save();
      context.strokeStyle = color1;
      context.fillStyle = grad;
      context.beginPath();

      context.arc(
        aWidth * 0.5 - gWidth,
        aHeight * 0.5,
        radius,
        0,
        Math.PI * 2,
        false
      );
      context.fill();

      context.restore();
      this.bitmap._setDirty();
    }
  };

  // 影スプライトの更新
  Sprite_KageMaster.prototype.update = function () {
    var subje = this._subje;
    var kage = this._kage;
    var oriSprite = this._oriSprite;
    var bsId = this._bsId;
    var baras = $gameTemp.searchBaraSprite(subje);

    // ▼ マップ ▼//
    // 位置　　　─影スプライトの更新
    // 不透明度　　　─影スプライトの更新
    // 見えるか　　　─影スプライトの更新
    // スケール　　　─影スプライトの更新
    // 角度　　　─影スプライトの更新

    // 位置　　　─影スプライトの更新
    var xReverse = 1;
    xReverse *=
      keke_kageReverseByMuki && (subje._direction == 6 || subje._direction == 8)
        ? -1
        : 1;
    xReverse *= subje._bitmapK.width < 0 ? -1 : 1;
    xReverse *=
      $gameParty.inBattle() && $gameSystem.isSideView() && subje._enemyId
        ? -1
        : 1;
    xReverse *= $gameSystem._kageXReverse || 1;
    var kagePosX = kage._posX * xReverse;
    var kagePosY = kage._posY * ($gameSystem._kageYReverse || 1);
    // 位置(マップ)　　　─影スプライトの更新
    if (this._isCharacter) {
      if (bsId == 0) {
        var x = subje._realX;
        var y = subje._realY;
      } else {
        x = subje._bsX[bsId];
        y = subje._bsY[bsId];
      }
      if (bsId > 0 && subje._modeMultiEffect) {
        x -= subje._anotherMoveX[0];
        y -= subje._anotherMoveY[0];
      }
      if (subje._memberIndex > 0 && $gamePlayer._modeMultiEffect) {
        x -= $gamePlayer._anotherMoveX[0];
        y -= $gamePlayer._anotherMoveY[0];
      }
      if (baras[0]) {
        x += baras[0]._gMoverX / $gameMap.tileWidth();
        y += baras[0]._gMoverY / $gameMap.tileHeight();
      }
      if (subje.jumpHeight()) {
        y += subje.jumpHeight() / $gameMap.tileHeight();
      }
      this.x = subje.convertScreenX(x) + kagePosX * subje._bitmapK.width;
      this.y = subje.convertScreenY(y) + kagePosY * subje._bitmapK.height;
      if (!this._isCharacter) {
        this.y += subje.shiftY();
      }
      // 位置(バトル)　　　─影スプライトの更新
    } else {
      this.x = oriSprite.x + kagePosX * subje._bitmapK.width;
      this.y = oriSprite.y + kagePosY * subje._bitmapK.height;
      if (oriSprite._kekeActAir) {
        this.y -= oriSprite._kekeActAir;
      }
      // DynamicMotion対応
      if (oriSprite._airY || oriSprite._rollAdjustY) {
        this.y -= oriSprite.rollAirY() * 1.0;
      }
    }

    // 不透明度　　　─影スプライトの更新
    if (baras[0]) {
      var maxOpa = 0;
      baras.forEach(function (bara) {
        if (bara && bara.opacity > maxOpa) {
          maxOpa = bara.opacity;
        }
      }, this);
      this.opacity = Math.min(
        maxOpa * (keke_kageOpacity / 255),
        keke_kageOpacity
      );
      // MOG_CollapseEffects 対応
    } else if (this._oriSprite._spriteCol) {
      this.opacity = Math.min(
        oriSprite._spriteCol[0].opacity,
        keke_kageOpacity
      );
    } else {
      var opacity = this._oriSprite._mainSprite
        ? this._oriSprite._mainSprite.opacity
        : this._oriSprite.opacity;
      this.opacity = opacity * (keke_kageOpacity / 255);
    }
    if (
      (subje._actorId && keke_actorDeadNoKageM && subje.isDead()) ||
      (subje._enemyId && keke_enemyDeadNoKageM && subje.isDead())
    ) {
      this.opacity = 0;
    }

    // 見えるか　　　─影スプライトの更新
    this.visible = oriSprite.visible && !$gameSystem._kageVisible;

    // スケール　　　─影スプライトの更新
    var scaleX = baras[0] ? baras[0].scale.x : oriSprite.scale.x;
    var scaleY = baras[0] ? baras[0].scale.y : oriSprite.scale.y;
    if (this._isCharacter) {
      if (subje._memberIndex) {
        var subje = $gamePlayer;
      } else {
        subje = subje;
      }
      var another = subje._freeM ? subje._freeM.anotherY[0] : 0;
      var jumpY = another - subje.jumpHeight() / $gameMap.tileHeight();
      var scaleRate = jumpY < 0 ? 1 - -jumpY / 10 : 1;
    } else {
      var jumpY = 0;
      jumpY += oriSprite._jumpHeight || 0;
      if (baras[0]) {
        jumpY += baras[0].gMoverY < 0 ? baras[0]._gMoverY : 0;
      }
      // BattlerGraphicExtend 対応
      if (subje._altitude) {
        jumpY += subje.getAltitude() * 2;
      }
      jumpY /= $gameMap.tileHeight();

      scaleRate = jumpY < 0 ? 1 - -jumpY / 10 : 1;
    }
    this.scale.x = scaleX * scaleRate * kage._sizeX;
    this.scale.y =
      scaleY * scaleRate * kage._sizeY * ($gameSystem._kageYReverse || 1);

    // 角度　　　─影スプライトの更新
    this.rotation = $gameTemp.angleToRadian(
      $gameTemp.angleToDegree(oriSprite.rotation) + kage._angle
    );
  };

  // 影スプライトのクリア
  Sprite_KageMaster.prototype.clear = function () {
    if (this._isCharacter) {
      var tilemap = SceneManager._scene._spriteset._tilemap;
      tilemap.removeChild(this);
    } else {
      var battleField = SceneManager._scene._spriteset._battleField;
      battleField.removeChild(this);
    }
  };
})();


code:
//=============================================================================
// KuishibariState.js
//=============================================================================

/*:
 * @plugindesc 「HPが2以上ある状態でダメージを受けた場合、一定確率でHP1残る」ステートを作成します。
 * @author 奏ねこま（おとぶきねこま）
 *
 * @help
 * ステートのメモ欄に、以下のように記述してください。
 * 確率値は正の整数で指定してください。
 *
 *  <kuishibari:[確率]>
 *
 * 例：HP2以上で被ダメージ時、必ずHP1残る
 *  <kuishibari:100>
 *
 * 例：HP2以上で被ダメージ時、50%の確率でHP1残る
 *  <kuishibari:50>
 *
 * *このプラグインには、プラグインコマンドはありません。
 *
 * [ 利用規約 ] ...................................................................
 *  本プラグインの利用者は、RPGツクールMV/RPGMakerMVの正規ユーザーに限られます。
 *  商用、非商用、ゲームの内容（年齢制限など）を問わず利用可能です。
 *  ゲームへの利用の際、報告や出典元の記載等は必須ではありません。
 *  二次配布や転載、ソースコードURLやダウンロードURLへの直接リンクは禁止します。
 *  （プラグインを利用したゲームに同梱する形での結果的な配布はOKです）
 *  不具合対応以外のサポートやリクエストは受け付けておりません。
 *  本プラグインにより生じたいかなる問題においても、一切の責任を負いかねます。
 * [ 改訂履歴 ] ...................................................................
 *   Version 1.00  2016/07/02  初版
 * -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  Web Site: http://i.gmobb.jp/nekoma/rpg_tkool/
 *  Twitter : https://twitter.com/koma_neko
 */

(function () {
  "use strict";

  var _Game_Action_executeHpDamage = Game_Action.prototype.executeHpDamage;
  Game_Action.prototype.executeHpDamage = function (target, value) {
    if (target._hp > 1 && value >= target._hp) {
      var kuishibari = 0;
      target._states.forEach(function (state) {
        if ($dataStates[state].meta["kuishibari"]) {
          kuishibari = Math.max(
            kuishibari,
            $dataStates[state].meta["kuishibari"]
          );
        }
      });
      if (kuishibari) {
        if (Math.floor(Math.random() * 100) + 1 <= kuishibari) {
          value = target._hp - 1;
        }
      }
    }
    _Game_Action_executeHpDamage.call(this, target, value);
  };
})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// RPGツクールMZ - LL_SprashScreenMV.js v1.0.0
//-----------------------------------------------------------------------------
// ルルの教会 (Lulu's Church)
// https://nine-yusha.com/
//
// URL below for license details.
// https://nine-yusha.com/plugin/
//=============================================================================

/*:
 * @target MV
 * @plugindesc スプラッシュスクリーンを表示します。
 * @author ルルの教会
 * @url https://nine-yusha.com/plugin/
 *
 * @help LL_SprashScreenMV.js
 *
 * スプラッシュスクリーンを表示します。
 * スプラッシュスクリーンは複数設定することが可能です。
 * 決定キー、クリックでスキップさせることもできます。
 * ジングルMEを再生することも可能です。
 *
 * 利用規約:
 *   ・著作権表記は必要ございません。
 *   ・利用するにあたり報告の必要は特にございません。
 *   ・商用・非商用問いません。
 *   ・R18作品にも使用制限はありません。
 *   ・ゲームに合わせて自由に改変していただいて問題ございません。
 *   ・プラグイン素材としての再配布（改変後含む）は禁止させていただきます。
 *
 * 作者: ルルの教会
 * 作成日: 2021/1/24
 *
 * @param splashImages
 * @text 画像リスト
 * @desc スプラッシュスクリーンとして表示する画像リストです。
 * 上から順番に表示されます。
 * @default []
 * @type struct<splashImages>[]
 *
 * @param skipEnabled
 * @text スキップ許可
 * @desc 決定キー、クリックでスキップを許可するか設定します。
 * @type boolean
 * @default true
 *
 * @param debugDisabled
 * @text テストプレイ時は非表示
 * @desc テストプレイ時は非表示にするか設定します。
 * @type boolean
 * @default false
 *
 * @param jingleSettings
 * @text ジングルの設定
 * @desc ※この項目は使用しません
 *
 * @param meName
 * @text ME
 * @desc 再生する音声ファイルを選択してください。
 * @dir audio/me
 * @type file
 * @require 1
 * @parent jingleSettings
 *
 * @param meVolume
 * @text MEの音量
 * @desc MEの音量(0～100%)です。 (初期値: 90%)
 * @default 90
 * @max 100
 * @min 0
 * @type number
 * @parent jingleSettings
 *
 * @param mePitch
 * @text MEのピッチ
 * @desc MEのピッチ(50～150%)です。 (初期値: 100%)
 * @default 100
 * @max 150
 * @min 50
 * @type number
 * @parent jingleSettings
 *
 * @param mePan
 * @text MEの位相
 * @desc MEの位相(-100～100)です。 (初期値: 0)
 * @default 0
 * @max 100
 * @min -100
 * @type number
 * @parent jingleSettings
 */

/*~struct~splashImages:
 *
 * @param imageName
 * @text 画像ファイル名
 * @desc 表示する画像ファイルを選択してください。
 * @dir img/system
 * @type file
 * @require 1
 *
 * @param fadeTime
 * @text フェード時間
 * @desc フェードイン・フェードアウトの効果時間です。
 * @default 60
 * @min 0
 * @max 999
 * @type number
 *
 * @param waitTime
 * @text 表示時間
 * @desc フェードイン後の表示時間です。
 * @default 60
 * @min 0
 * @max 999
 * @type number
 */

(function () {
  "use strict";
  var pluginName = "LL_SprashScreenMV";

  var parameters = PluginManager.parameters(pluginName);
  var skipEnabled = eval(parameters["skipEnabled"] || "true");
  var debugDisabled = eval(parameters["debugDisabled"] || "false");
  // ME
  var meName = String(parameters["meName"] || "");
  var meVolume = Number(parameters["meVolume"] || 90);
  var mePitch = Number(parameters["mePitch"] || 100);
  var mePan = Number(parameters["mePan"] || 0);
  // 画像リスト
  var splashImages = JSON.parse(parameters["splashImages"] || "null");
  var splashImageLists = [];
  if (splashImages) {
    splashImages.forEach(function (elm) {
      splashImageLists.push(JSON.parse(elm));
    });
  }

  var _Scene_Boot_loadSystemImages = Scene_Boot.prototype.loadSystemImages;
  Scene_Boot.prototype.loadSystemImages = function () {
    _Scene_Boot_loadSystemImages.call(this);
    // スプラッシュ画像を読み込み
    splashImageLists.forEach(function (item) {
      ImageManager.loadSystem(item.imageName);
    });
  };

  var _Scene_Boot_startNormalGame = Scene_Boot.prototype.startNormalGame;
  Scene_Boot.prototype.startNormalGame = function () {
    if (
      !DataManager.isBattleTest() &&
      !DataManager.isEventTest() &&
      splashImageLists.length > 0
    ) {
      if (!Utils.isOptionValid("test") || !debugDisabled) {
        this.checkPlayerLocation();
        DataManager.setupNewGame();
        SceneManager.goto(Scene_SplashScreen);
        return;
      }
    }

    _Scene_Boot_startNormalGame.apply(this, arguments);
  };

  // for MV
  var _Scene_Boot_start = Scene_Boot.prototype.start;
  Scene_Boot.prototype.start = function () {
    if (
      !DataManager.isBattleTest() &&
      !DataManager.isEventTest() &&
      splashImageLists.length > 0
    ) {
      if (!Utils.isOptionValid("test") || !debugDisabled) {
        this.checkPlayerLocation();
        DataManager.setupNewGame();
        SceneManager.goto(Scene_SplashScreen);
        return;
      }
    }

    _Scene_Boot_start.apply(this, arguments);
  };

  //-----------------------------------------------------------------------------
  // Scene_SplashScreen
  //
  // スプラッシュスクリーンを表示する独自のシーンを追加定義します。

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

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

  Scene_SplashScreen.prototype.initialize = function () {
    Scene_Base.prototype.initialize.call(this);
    SceneManager.clearStack();
    this._originalSplash = null;
    this._splashIndex = 0;
    this._fadeTime = 60;
    this._waitTime = 0;
    this._fadeOpacity = 255;
  };

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

  Scene_SplashScreen.prototype.start = function () {
    Scene_Base.prototype.start.call(this);
    this.playMeJingle();
  };

  Scene_SplashScreen.prototype.update = function () {
    Scene_Base.prototype.update.call(this);

    this._fadeOpacity = this._fadeSprite ? this._fadeSprite.opacity : 255;

    // 画像切り替え
    if (this._waitTime == 0) {
      if (this._fadeOpacity == 0) {
        this.startFadeOut(this._fadeTime, false);
      } else if (this._fadeOpacity == 255) {
        this.setSplashImage();
        // 終了判定
        if (!this._originalSplash) {
          this.gotoNextScene();
          return;
        }
        this.adjustSpriteImage();
        this.startFadeIn(this._fadeTime, false);
      }
    }
    // スキップ判定
    if (skipEnabled) {
      if (Input.isTriggered("ok") || TouchInput.isTriggered()) {
        this._waitTime = 0;
        this.startFadeOut(1, false);
      }
    }
    // ウェイト判定
    if (this._fadeOpacity == 0 && this._waitTime > 0) {
      this._waitTime--;
    }
  };

  Scene_SplashScreen.prototype.setSplashImage = function () {
    var splashImage = splashImageLists[this._splashIndex];
    this._originalSplash = null;
    if (splashImage) {
      this._originalSplash = new Sprite(
        ImageManager.loadSystem(String(splashImage.imageName))
      );
      this.addChild(this._originalSplash);
      this._fadeTime = Number(splashImage.fadeTime);
      this._waitTime = Number(splashImage.waitTime);
      // インデックスを更新
      this._splashIndex++;
    }
  };

  Scene_SplashScreen.prototype.adjustSpriteImage = function () {
    this.centerSprite(this._originalSplash);
  };

  Scene_SplashScreen.prototype.playMeJingle = function () {
    if (!meName) return;
    AudioManager.playMe({
      name: meName,
      volume: meVolume,
      pitch: mePitch,
      pan: mePan,
    });
  };

  Scene_SplashScreen.prototype.gotoNextScene = function () {
    AudioManager.stopMe();
    SceneManager.goto(Scene_Title);
  };

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

  Scene_SplashScreen.prototype.startFadeIn = function () {
    this._fadeSprite = null;
    Scene_Base.prototype.startFadeIn.call(this);
  };
})();


code:
//=============================================================================
// RPGツクールMV - LL_StandingPictureMV.js v2.6.3
//-----------------------------------------------------------------------------
// ルルの教会 (Lulu's Church)
// https://nine-yusha.com/
//
// URL below for license details.
// https://nine-yusha.com/plugin/
//=============================================================================

/*:
 * @target MV
 * @plugindesc メッセージウィンドウ表示時に立ち絵を表示します。
 * @author ルルの教会
 * @url https://nine-yusha.com/plugin-spicture/
 *
 * @help LL_StandingPictureMV.js
 *
 * メッセージ内に専用の制御文字を入力することで、
 * 立ち絵を表示できます。
 *
 * ・\FH[ON]を入力するとウィンドウ消去後も立ち絵が残り続けます。
 *   \FH[OFF]を入力すると解除されウィンドウ消去と同時に立ち絵が消えます。
 *   ウィンドウ表示時以外のタイミングで立ち絵を表示・消去したい場合は、
 *   プラグインコマンド「制御文字の実行」を使用してください。
 * ・立ち絵IDには半角英数字とアンダースコア(_)が使用できます。
 * ・立ち絵IDは変数で指定することも可能です。 【例】\F[\V[1]]
 * ・立ち絵は一度に4人まで表示することが可能です。
 *
 * 専用制御文字:
 *   \F[立ち絵ID]         立ち絵1を表示します。 【例】\F[reid]
 *   \FF[立ち絵ID]        立ち絵2を表示します。
 *   \FFF[立ち絵ID]       立ち絵3を表示します。
 *   \FFFF[立ち絵ID]      立ち絵4を表示します。
 *   \M[モーション名]     立ち絵1のモーションを再生します。 【例】\M[yes]
 *   \MM[モーション名]    立ち絵2のモーションを再生します。
 *   \MMM[モーション名]   立ち絵3のモーションを再生します。
 *   \MMMM[モーション名]  立ち絵4のモーションを再生します。
 *   \AA[F]               立ち絵1にフォーカスを当てます。 (立ち絵1以外を暗く)
 *   \AA[FF]              立ち絵2にフォーカスを当てます。 (立ち絵2以外を暗く)
 *   \AA[FFF]             立ち絵3にフォーカスを当てます。 (立ち絵3以外を暗く)
 *   \AA[FFFF]            立ち絵4にフォーカスを当てます。 (立ち絵4以外を暗く)
 *   \AA[N]               立ち絵を全て暗くします。
 *   \AA[R]               立ち絵のフォーカスをリセットします。
 *   \FH[ON]              ホールドモードをONにします (立ち絵が残り続ける)
 *   \FH[OFF]             ホールドモードをOFFにします
 *
 * 立ち絵モーション一覧:
 *   yes(頷く)、yesyes(二回頷く)、no(横に揺れる)、noslow(ゆっくり横に揺れる)
 *   jump(跳ねる)、jumpjump(二回跳ねる)、jumploop(跳ね続ける)
 *   shake(ガクガク)、shakeloop(ガクガクし続ける)
 *   runleft(画面左へ走り去る)、runright(画面右へ走り去る)
 *   noslowloop(横に揺れ続ける)、huwahuwa(ふわふわ)
 *
 * プラグインコマンド(制御文字の実行):
 *   LL_StandingPictureMV processChar 制御文字
 *   LL_StandingPictureMV processChar \F[s]\M[yes]\FH[ON]  # 立ち絵sを表示
 *   LL_StandingPictureMV processChar \FH[OFF]             # 立ち絵を消去
 *
 * プラグインコマンド:
 *   LL_StandingPictureMV setEnabled true       # 立ち絵を表示に設定 (初期値)
 *   LL_StandingPictureMV setEnabled false      # 立ち絵を非表示に設定
 *   LL_StandingPictureMV setTone 68,-34,-34,0  # 立ち絵の色調を夕暮れに変更
 *   LL_StandingPictureMV setTone -68,-68,68,0  # 立ち絵の色調を夜に変更
 *   LL_StandingPictureMV setTone 0,0,0,255     # 立ち絵の色調を白黒に変更
 *   LL_StandingPictureMV setTone 0,0,0,0       # 立ち絵の色調を通常に戻す
 *
 * 利用規約:
 *   ・著作権表記は必要ございません。
 *   ・利用するにあたり報告の必要は特にございません。
 *   ・商用・非商用問いません。
 *   ・R18作品にも使用制限はありません。
 *   ・ゲームに合わせて自由に改変していただいて問題ございません。
 *   ・プラグイン素材としての再配布（改変後含む）は禁止させていただきます。
 *
 * 作者: ルルの教会
 * 作成日: 2022/7/8
 *
 * @command processChar
 * @text 制御文字の実行
 * @desc ウィンドウ表示時以外のタイミングで立ち絵を操作します。
 *
 * @arg text
 * @text 制御文字
 * @desc [例]立ち絵の表示→\F[s] \FH[ON]、立ち絵の消去→\FH[OFF]
 * 文章表示時と同じように制御文字を入力してください。
 * @type multiline_string
 *
 * @command setEnabled
 * @text 立ち絵表示ON・OFF
 * @desc 立ち絵の表示・非表示を一括制御します。
 *
 * @arg enabled
 * @text 立ち絵表示
 * @desc OFFにすると立ち絵が一切表示されなくなります。
 * @default true
 * @type boolean
 *
 * @command setTone
 * @text 色調変更
 * @desc 立ち絵の色調を変更します。
 *
 * @arg toneR
 * @text 赤
 * @desc 色調のR成分です。 (-255～255)
 * @default 0
 * @type number
 * @min -255
 * @max 255
 *
 * @arg toneG
 * @text 緑
 * @desc 色調のG成分です。 (-255～255)
 * @default 0
 * @type number
 * @min -255
 * @max 255
 *
 * @arg toneB
 * @text 青
 * @desc 色調のB成分です。 (-255～255)
 * @default 0
 * @type number
 * @min -255
 * @max 255
 *
 * @arg toneC
 * @text グレー
 * @desc グレースケールの強さです。 (0～255)
 * @default 0
 * @type number
 * @min 0
 * @max 255
 *
 * @param sPictures
 * @text 立ち絵リスト
 * @desc メッセージウィンドウに表示する立ち絵を定義します。
 * @default []
 * @type struct<sPictures>[]
 *
 * @param picture1Settings
 * @text 立ち絵1(\F)の設定
 * @desc ※この項目は使用しません
 *
 * @param transition
 * @text 切替効果
 * @desc 出現・消去時の切替効果を指定します。
 * @type select
 * @default 1
 * @option なし
 * @value 0
 * @option フェード
 * @value 1
 * @option フロート左
 * @value 2
 * @option フロート右
 * @value 3
 * @option フロート下
 * @value 4
 * @option フロート上
 * @value 5
 * @parent picture1Settings
 *
 * @param foreFront
 * @text ウィンドウの前面に表示
 * @desc ONにするとメッセージウィンドウよりも前面に表示されます。
 * @type boolean
 * @default false
 * @parent picture1Settings
 *
 * @param picture2Settings
 * @text 立ち絵2(\FF)の設定
 * @desc ※この項目は使用しません
 *
 * @param transition2
 * @text 切替効果
 * @desc 出現・消去時の切替効果を指定します。
 * @type select
 * @default 1
 * @option なし
 * @value 0
 * @option フェード
 * @value 1
 * @option フロート左
 * @value 2
 * @option フロート右
 * @value 3
 * @option フロート下
 * @value 4
 * @option フロート上
 * @value 5
 * @parent picture2Settings
 *
 * @param foreFront2
 * @text ウィンドウの前面に表示
 * @desc ONにするとメッセージウィンドウよりも前面に表示されます。
 * @type boolean
 * @default false
 * @parent picture2Settings
 *
 * @param picture3Settings
 * @text 立ち絵3(\FFF)の設定
 * @desc ※この項目は使用しません
 *
 * @param transition3
 * @text 切替効果
 * @desc 出現・消去時の切替効果を指定します。
 * @type select
 * @default 1
 * @option なし
 * @value 0
 * @option フェード
 * @value 1
 * @option フロート左
 * @value 2
 * @option フロート右
 * @value 3
 * @option フロート下
 * @value 4
 * @option フロート上
 * @value 5
 * @parent picture3Settings
 *
 * @param foreFront3
 * @text ウィンドウの前面に表示
 * @desc ONにするとメッセージウィンドウよりも前面に表示されます。
 * @type boolean
 * @default false
 * @parent picture3Settings
 *
 * @param picture4Settings
 * @text 立ち絵4(\FFFF)の設定
 * @desc ※この項目は使用しません
 *
 * @param transition4
 * @text 切替効果
 * @desc 出現・消去時の切替効果を指定します。
 * @type select
 * @default 1
 * @option なし
 * @value 0
 * @option フェード
 * @value 1
 * @option フロート左
 * @value 2
 * @option フロート右
 * @value 3
 * @option フロート下
 * @value 4
 * @option フロート上
 * @value 5
 * @parent picture4Settings
 *
 * @param foreFront4
 * @text ウィンドウの前面に表示
 * @desc ONにするとメッセージウィンドウよりも前面に表示されます。
 * @type boolean
 * @default false
 * @parent picture4Settings
 *
 * @param focusToneAdjust
 * @text フォーカス時の暗さ
 * @desc AA[s]でフォーカスを当てた時の暗さ(-255～0)です。
 * 暗くなりすぎる場合に調整してください。(初期値: -96)
 * @default -96
 * @min -255
 * @max 0
 * @type number
 *
 * @param catheBootPicture
 * @text 立ち絵画像の事前読み込み
 * @desc アツマールなどブラウザプレイ時の読み込み待ちを解消します。
 * 画像数や回線速度により起動が遅くなる場合があります。
 * @default true
 * @type boolean
 */

/*~struct~sPictures:
 *
 * @param id
 * @text 立ち絵ID
 * @desc 立ち絵IDです。立ち絵を制御文字で呼び出す際に使用します。
 * 半角英数字(_)で入力してください。
 * @type string
 *
 * @param imageName
 * @text 画像ファイル名
 * @desc 立ち絵として表示する画像ファイルを選択してください。
 * @dir img/pictures
 * @type file
 * @require 1
 *
 * @param origin
 * @text 原点
 * @desc 立ち絵の原点です。
 * @default 0
 * @type select
 * @option 左上
 * @value 0
 * @option 中央
 * @value 1
 *
 * @param x
 * @text X座標 (立ち絵1)
 * @desc 立ち絵1(F)で呼び出された時の表示位置(X)です。
 * @default 464
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param y
 * @text Y座標 (立ち絵1)
 * @desc 立ち絵1(F)で呼び出された時の表示位置(Y)です。
 * @default 96
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param x2
 * @text X座標 (立ち絵2)
 * @desc 立ち絵2(FF)で呼び出された時の表示位置(X)です。
 * @default 20
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param y2
 * @text Y座標 (立ち絵2)
 * @desc 立ち絵2(FF)で呼び出された時の表示位置(Y)です。
 * @default 96
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param x3
 * @text X座標 (立ち絵3)
 * @desc 立ち絵3(FFF)で呼び出された時の表示位置(X)です。
 * @default 364
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param y3
 * @text Y座標 (立ち絵3)
 * @desc 立ち絵3(FFF)で呼び出された時の表示位置(Y)です。
 * @default 96
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param x4
 * @text X座標 (立ち絵4)
 * @desc 立ち絵4(FFFF)で呼び出された時の表示位置(X)です。
 * @default 120
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param y4
 * @text Y座標 (立ち絵4)
 * @desc 立ち絵4(FFFF)で呼び出された時の表示位置(Y)です。
 * @default 96
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param reverse
 * @text 立ち絵2, 4の左右反転
 * @desc 立ち絵2(FF)、立ち絵4(FFFF)で呼び出された時に
 * 立ち絵を左右反転させるかの設定です。
 * @default 1
 * @type select
 * @option 左右反転しない
 * @value 1
 * @option 左右反転する
 * @value -1
 *
 * @param scaleX
 * @text X拡大率
 * @desc 立ち絵の拡大率(X)です。
 * @default 100
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param scaleY
 * @text Y拡大率
 * @desc 立ち絵の拡大率(Y)です。
 * @default 100
 * @min -2000
 * @max 2000
 * @type number
 *
 * @param opacity
 * @text 不透明度
 * @desc 立ち絵の不透明度(0～255)です。
 * @default 255
 * @type number
 * @min 0
 * @max 255
 *
 * @param blendMode
 * @text 合成方法
 * @desc 立ち絵の合成方法です。
 * @default 0
 * @type select
 * @option 通常
 * @value 0
 * @option 加算
 * @value 1
 * @option 除算
 * @value 2
 * @option スクリーン
 * @value 3
 */

(function () {
  "use strict";
  var pluginName = "LL_StandingPictureMV";

  var parameters = PluginManager.parameters(pluginName);
  // 切替効果
  var transitions = [
    null,
    Number(parameters["transition"] || 1),
    Number(parameters["transition2"] || 1),
    Number(parameters["transition3"] || 1),
    Number(parameters["transition4"] || 1),
  ];
  // ウィンドウ前面表示
  var foreFronts = [
    null,
    eval(parameters["foreFront"] || "false"),
    eval(parameters["foreFront2"] || "false"),
    eval(parameters["foreFront3"] || "false"),
    eval(parameters["foreFront4"] || "false"),
  ];

  var focusToneAdjust = Number(parameters["focusToneAdjust"] || -96);
  var catheBootPicture = eval(parameters["catheBootPicture"] || "true");
  var sPictures = JSON.parse(parameters["sPictures"] || "null");
  var sPictureLists = [];
  if (sPictures) {
    sPictures.forEach(function (elm) {
      sPictureLists.push(JSON.parse(elm));
    });
  }

  //-----------------------------------------------------------------------------
  // PluginCommand (for MV)
  //

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === pluginName) {
      switch (args[0]) {
        case "processChar":
          var text = args[1];
          exStandingPictureParseChar(text);

          // 立ち絵表示状態を継続
          if ($gameSystem._LL_StandingPicture_picture1.showSPicture) {
            $gameSystem._LL_StandingPicture_picture1.refSPicture = true;
            $gameSystem._LL_StandingPicture_picture1.animationCount =
              animationFrame[
                $gameSystem._LL_StandingPicture_picture1.motionSPicture
              ];
          }
          if ($gameSystem._LL_StandingPicture_picture2.showSPicture) {
            $gameSystem._LL_StandingPicture_picture2.refSPicture = true;
            $gameSystem._LL_StandingPicture_picture2.animationCount =
              animationFrame[
                $gameSystem._LL_StandingPicture_picture2.motionSPicture
              ];
          }
          if ($gameSystem._LL_StandingPicture_picture3.showSPicture) {
            $gameSystem._LL_StandingPicture_picture3.refSPicture = true;
            $gameSystem._LL_StandingPicture_picture3.animationCount =
              animationFrame[
                $gameSystem._LL_StandingPicture_picture3.motionSPicture
              ];
          }
          if ($gameSystem._LL_StandingPicture_picture4.showSPicture) {
            $gameSystem._LL_StandingPicture_picture4.refSPicture = true;
            $gameSystem._LL_StandingPicture_picture4.animationCount =
              animationFrame[
                $gameSystem._LL_StandingPicture_picture4.motionSPicture
              ];
          }
          if (!$gameSystem._LL_StandingPicture_holdSPicture) {
            $gameSystem._LL_StandingPicture_picture1.showSPicture = false;
            $gameSystem._LL_StandingPicture_picture2.showSPicture = false;
            $gameSystem._LL_StandingPicture_picture3.showSPicture = false;
            $gameSystem._LL_StandingPicture_picture4.showSPicture = false;
            $gameSystem._LL_StandingPicture_picture1.motionSPicture = "";
            $gameSystem._LL_StandingPicture_picture2.motionSPicture = "";
            $gameSystem._LL_StandingPicture_picture3.motionSPicture = "";
            $gameSystem._LL_StandingPicture_picture4.motionSPicture = "";
          }
          break;
        case "setEnabled":
          var enabled = eval(args[1] || "true");
          $gameSystem._StandingPictureDisabled = !enabled;
          break;
        case "setTone":
          var setTone = args[1].split(",");
          var pictureTone = [
            Number(setTone[0]),
            Number(setTone[1]),
            Number(setTone[2]),
            Number(setTone[3]),
          ];
          $gameSystem._StandingPictureTone = pictureTone;
          break;
      }
    }
  };

  // アニメーションフレーム数定義
  var animationFrame = {
    yes: 24,
    yesyes: 48,
    no: 24,
    noslow: 48,
    jump: 24,
    jumpjump: 48,
    jumploop: 48,
    shake: 1,
    shakeloop: 1,
    runleft: 1,
    runright: 1,
    noslowloop: 96,
    breathing: 96,
    breathing2: 96,
    huwahuwa: 192,
    none: 0,
  };

  // フォーカス状態リセット用
  let focusReset = false;

  //-----------------------------------------------------------------------------
  // Game_System
  //
  // 立ち絵制御用の独自配列を追加定義します。

  var _Game_System_initialize = Game_System.prototype.initialize;
  Game_System.prototype.initialize = function () {
    _Game_System_initialize.apply(this, arguments);

    this.iniLLStandingPictures();
    this._LL_StandingPicture_battleCache = null;
  };

  Game_System.prototype.iniLLStandingPictures = function () {
    // 立ち絵1 (F)
    this._LL_StandingPicture_picture1 = {
      animationCount: 0,
      spriteSPicture: null,
      showSPicture: false,
      refSPicture: false,
      motionSPicture: "",
    };
    // 立ち絵2 (FF)
    this._LL_StandingPicture_picture2 = {
      animationCount: 0,
      spriteSPicture: null,
      showSPicture: false,
      refSPicture: false,
      motionSPicture: "",
    };
    // 立ち絵3 (FFF)
    this._LL_StandingPicture_picture3 = {
      animationCount: 0,
      spriteSPicture: null,
      showSPicture: false,
      refSPicture: false,
      motionSPicture: "",
    };
    // 立ち絵4 (FFFF)
    this._LL_StandingPicture_picture4 = {
      animationCount: 0,
      spriteSPicture: null,
      showSPicture: false,
      refSPicture: false,
      motionSPicture: "",
    };
    // フォーカス設定
    this._LL_StandingPicture_focusSPicture = {
      0: false,
      1: false,
      2: false,
      3: false,
      4: false,
    };
    // ホールド設定
    this._LL_StandingPicture_holdSPicture = false;
  };

  Game_System.prototype.inBattleMakeCacheLLStandingPictures = function () {
    if (!this._LL_StandingPicture_battleCache) {
      this._LL_StandingPicture_battleCache = {
        picture1: this._LL_StandingPicture_picture1,
        picture2: this._LL_StandingPicture_picture2,
        picture3: this._LL_StandingPicture_picture3,
        picture4: this._LL_StandingPicture_picture4,
        focusSPicture: this._LL_StandingPicture_focusSPicture,
        holdSPicture: this._LL_StandingPicture_holdSPicture,
      };
    }
    this.iniLLStandingPictures();
  };

  Game_System.prototype.refreshCacheLLStandingPictures = function () {
    if (this._LL_StandingPicture_battleCache) {
      this._LL_StandingPicture_picture1 =
        this._LL_StandingPicture_battleCache.picture1;
      this._LL_StandingPicture_picture2 =
        this._LL_StandingPicture_battleCache.picture2;
      this._LL_StandingPicture_picture3 =
        this._LL_StandingPicture_battleCache.picture3;
      this._LL_StandingPicture_picture4 =
        this._LL_StandingPicture_battleCache.picture4;
      this._LL_StandingPicture_focusSPicture =
        this._LL_StandingPicture_battleCache.focusSPicture;
      this._LL_StandingPicture_holdSPicture =
        this._LL_StandingPicture_battleCache.holdSPicture;
    }
    this._LL_StandingPicture_battleCache = null;
  };

  //-----------------------------------------------------------------------------
  // ExStandingPictureParseChar
  //
  // 立ち絵制御文字を解読する関数です。

  var exStandingPictureParseChar = function (text) {
    text = text.replace(
      /\\V\[(\d+)\]/gi,
      function () {
        return $gameVariables.value(parseInt(arguments[1]));
      }.bind(this)
    );

    // 専用制御文字を取得 (\F[s])
    var sPictureNumber = null;
    var processEscapeNumber = text.match(/\\F\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureNumber = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\FF[s])
    var sPictureNumber2 = null;
    processEscapeNumber = text.match(/\\FF\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureNumber2 = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\FFF[s])
    var sPictureNumber3 = null;
    processEscapeNumber = text.match(/\\FFF\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureNumber3 = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\FFFF[s])
    var sPictureNumber4 = null;
    processEscapeNumber = text.match(/\\FFFF\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureNumber4 = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\M[s])
    var sPictureMotion = null;
    processEscapeNumber = text.match(/\\M\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureMotion = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\MM[s])
    var sPictureMotion2 = null;
    processEscapeNumber = text.match(/\\MM\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureMotion2 = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\MMM[s])
    var sPictureMotion3 = null;
    processEscapeNumber = text.match(/\\MMM\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureMotion3 = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\MMMM[s])
    var sPictureMotion4 = null;
    processEscapeNumber = text.match(/\\MMMM\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureMotion4 = processEscapeNumber[1];
      }
    }
    // 専用制御文字を取得 (\AA[s])
    var focusSPicture = false;
    processEscapeNumber = text.match(/\\AA\[(F|1)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        focusSPicture = true;
      }
    }
    var focusSPicture2 = false;
    processEscapeNumber = text.match(/\\AA\[(FF|2)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        focusSPicture2 = true;
      }
    }
    var focusSPicture3 = false;
    processEscapeNumber = text.match(/\\AA\[(FFF|3)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        focusSPicture3 = true;
      }
    }
    var focusSPicture4 = false;
    processEscapeNumber = text.match(/\\AA\[(FFFF|4)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        focusSPicture4 = true;
      }
    }
    var focusSPictureAllout = false;
    processEscapeNumber = text.match(/\\AA\[(N|0)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        focusSPictureAllout = true;
      }
    }
    $gameSystem._LL_StandingPicture_focusSPicture = {
      0: focusSPictureAllout,
      1: focusSPicture,
      2: focusSPicture2,
      3: focusSPicture3,
      4: focusSPicture4,
    };
    // フォーカス状態リセット (\AA[R])
    processEscapeNumber = text.match(/\\AA\[(R|0)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        focusReset = true;
      }
    }
    // 専用制御文字を取得 (\FH[s])
    var sPictureHold = null;
    processEscapeNumber = text.match(/\\FH\[(\w+)\]/);
    if (processEscapeNumber) {
      if (processEscapeNumber[1]) {
        sPictureHold = processEscapeNumber[1];
      }
    }
    // 立ち絵1を更新
    if (sPictureNumber) {
      var sPicture = sPictureLists.filter(function (item, index) {
        if (String(item.id) == sPictureNumber) return true;
      });
      $gameSystem._LL_StandingPicture_picture1.spriteSPicture = sPicture[0];
      if (sPicture[0]) {
        $gameSystem._LL_StandingPicture_picture1.showSPicture = true;
        $gameSystem._LL_StandingPicture_picture1.refSPicture = true;
      } else {
        $gameSystem._LL_StandingPicture_picture1.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture1.refSPicture = false;
      }
      // 再生モーション定義
      $gameSystem._LL_StandingPicture_picture1.motionSPicture = sPictureMotion
        ? sPictureMotion
        : "none";
      $gameSystem._LL_StandingPicture_picture1.animationCount =
        animationFrame[$gameSystem._LL_StandingPicture_picture1.motionSPicture];
    } else {
      if (!$gameSystem._LL_StandingPicture_holdSPicture) {
        $gameSystem._LL_StandingPicture_picture1.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture1.motionSPicture = "";
      } else if (sPictureMotion) {
        // 再生モーション更新
        $gameSystem._LL_StandingPicture_picture1.motionSPicture =
          sPictureMotion;
        $gameSystem._LL_StandingPicture_picture1.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture1.motionSPicture
          ];
      }
    }
    // 立ち絵2を更新
    if (sPictureNumber2) {
      var sPicture2 = sPictureLists.filter(function (item, index) {
        if (String(item.id) == sPictureNumber2) return true;
      });
      $gameSystem._LL_StandingPicture_picture2.spriteSPicture = sPicture2[0];
      if (sPicture2[0]) {
        $gameSystem._LL_StandingPicture_picture2.showSPicture = true;
        $gameSystem._LL_StandingPicture_picture2.refSPicture = true;
      } else {
        $gameSystem._LL_StandingPicture_picture2.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture2.refSPicture = false;
      }
      // 再生モーション定義
      $gameSystem._LL_StandingPicture_picture2.motionSPicture = sPictureMotion2
        ? sPictureMotion2
        : "none";
      $gameSystem._LL_StandingPicture_picture2.animationCount =
        animationFrame[$gameSystem._LL_StandingPicture_picture2.motionSPicture];
    } else {
      if (!$gameSystem._LL_StandingPicture_holdSPicture) {
        $gameSystem._LL_StandingPicture_picture2.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture2.motionSPicture = "";
      } else if (sPictureMotion2) {
        // 再生モーション更新
        $gameSystem._LL_StandingPicture_picture2.motionSPicture =
          sPictureMotion2;
        $gameSystem._LL_StandingPicture_picture2.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture2.motionSPicture
          ];
      }
    }
    // 立ち絵3を更新
    if (sPictureNumber3) {
      var sPicture3 = sPictureLists.filter(function (item, index) {
        if (String(item.id) == sPictureNumber3) return true;
      });
      $gameSystem._LL_StandingPicture_picture3.spriteSPicture = sPicture3[0];
      if (sPicture3[0]) {
        $gameSystem._LL_StandingPicture_picture3.showSPicture = true;
        $gameSystem._LL_StandingPicture_picture3.refSPicture = true;
      } else {
        $gameSystem._LL_StandingPicture_picture3.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture3.refSPicture = false;
      }
      // 再生モーション定義
      $gameSystem._LL_StandingPicture_picture3.motionSPicture = sPictureMotion3
        ? sPictureMotion3
        : "none";
      $gameSystem._LL_StandingPicture_picture3.animationCount =
        animationFrame[$gameSystem._LL_StandingPicture_picture3.motionSPicture];
    } else {
      if (!$gameSystem._LL_StandingPicture_holdSPicture) {
        $gameSystem._LL_StandingPicture_picture3.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture3.motionSPicture = "";
      } else if (sPictureMotion3) {
        // 再生モーション更新
        $gameSystem._LL_StandingPicture_picture3.motionSPicture =
          sPictureMotion3;
        $gameSystem._LL_StandingPicture_picture3.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture3.motionSPicture
          ];
      }
    }
    // 立ち絵4を更新
    if (sPictureNumber4) {
      var sPicture4 = sPictureLists.filter(function (item, index) {
        if (String(item.id) == sPictureNumber4) return true;
      });
      $gameSystem._LL_StandingPicture_picture4.spriteSPicture = sPicture4[0];
      if (sPicture4[0]) {
        $gameSystem._LL_StandingPicture_picture4.showSPicture = true;
        $gameSystem._LL_StandingPicture_picture4.refSPicture = true;
      } else {
        $gameSystem._LL_StandingPicture_picture4.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture4.refSPicture = false;
      }
      // 再生モーション定義
      $gameSystem._LL_StandingPicture_picture4.motionSPicture = sPictureMotion4
        ? sPictureMotion4
        : "none";
      $gameSystem._LL_StandingPicture_picture4.animationCount =
        animationFrame[$gameSystem._LL_StandingPicture_picture4.motionSPicture];
    } else {
      if (!$gameSystem._LL_StandingPicture_holdSPicture) {
        $gameSystem._LL_StandingPicture_picture4.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture4.motionSPicture = "";
      } else if (sPictureMotion4) {
        // 再生モーション更新
        $gameSystem._LL_StandingPicture_picture4.motionSPicture =
          sPictureMotion4;
        $gameSystem._LL_StandingPicture_picture4.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture4.motionSPicture
          ];
      }
    }

    // ホールドモードを切替
    if (sPictureHold === "ON") {
      $gameSystem._LL_StandingPicture_holdSPicture = true;
    } else if (sPictureHold === "OFF") {
      $gameSystem._LL_StandingPicture_holdSPicture = false;
    }
  };

  //-----------------------------------------------------------------------------
  // ExStandingPicture
  //
  // 立ち絵を表示する独自のクラスを追加定義します。

  class ExStandingPicture {
    static create(elm) {
      // 立ち絵1
      elm._spSprite = new Sprite_LL_SPicture();
      elm.addChildAt(
        elm._spSprite,
        elm.children.indexOf(
          foreFronts[1] ? elm._windowLayer : elm._spriteset
        ) + 1
      );
      // 立ち絵2
      elm._spSprite2 = new Sprite_LL_SPicture();
      elm.addChildAt(
        elm._spSprite2,
        elm.children.indexOf(
          foreFronts[2] ? elm._windowLayer : elm._spriteset
        ) + 1
      );
      // 立ち絵3
      elm._spSprite3 = new Sprite_LL_SPicture();
      elm.addChildAt(
        elm._spSprite3,
        elm.children.indexOf(
          foreFronts[3] ? elm._windowLayer : elm._spriteset
        ) + 1
      );
      // 立ち絵4
      elm._spSprite4 = new Sprite_LL_SPicture();
      elm.addChildAt(
        elm._spSprite4,
        elm.children.indexOf(
          foreFronts[4] ? elm._windowLayer : elm._spriteset
        ) + 1
      );

      // ※下記は念のためMVでは無効 (v2.5.1)

      // 立ち絵画像を事前読み込み
      // if (catheBootPicture) {
      // 	sPictureLists.forEach(function(elm) {
      // 		ImageManager.loadPicture(elm.imageName);
      // 	});
      // }

      // 旧Ver.のセーブデータ読み込み対策
      if (typeof $gameSystem._LL_StandingPicture_picture1 === "undefined") {
        $gameSystem.iniLLStandingPictures();
      }

      // 戦闘時判定
      if (SceneManager._scene.constructor === Scene_Battle) {
        // 表示中の立ち絵を消去
        $gameSystem.inBattleMakeCacheLLStandingPictures();
      } else {
        $gameSystem.refreshCacheLLStandingPictures();
      }

      // 立ち絵表示状態を継続
      if ($gameSystem._LL_StandingPicture_picture1.showSPicture) {
        $gameSystem._LL_StandingPicture_picture1.refSPicture = true;
        $gameSystem._LL_StandingPicture_picture1.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture1.motionSPicture
          ];
      }
      if ($gameSystem._LL_StandingPicture_picture2.showSPicture) {
        $gameSystem._LL_StandingPicture_picture2.refSPicture = true;
        $gameSystem._LL_StandingPicture_picture2.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture2.motionSPicture
          ];
      }
      if ($gameSystem._LL_StandingPicture_picture3.showSPicture) {
        $gameSystem._LL_StandingPicture_picture3.refSPicture = true;
        $gameSystem._LL_StandingPicture_picture3.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture3.motionSPicture
          ];
      }
      if ($gameSystem._LL_StandingPicture_picture4.showSPicture) {
        $gameSystem._LL_StandingPicture_picture4.refSPicture = true;
        $gameSystem._LL_StandingPicture_picture4.animationCount =
          animationFrame[
            $gameSystem._LL_StandingPicture_picture4.motionSPicture
          ];
      }
    }

    static update(elm) {
      // 立ち絵を非表示に設定している場合、処理を中断
      if ($gameSystem._StandingPictureDisabled) {
        elm._spSprite.opacity = 0;
        elm._spSprite2.opacity = 0;
        elm._spSprite3.opacity = 0;
        elm._spSprite4.opacity = 0;
        return;
      }

      // 立ち絵1ピクチャ作成
      if (
        $gameSystem._LL_StandingPicture_picture1.spriteSPicture &&
        $gameSystem._LL_StandingPicture_picture1.refSPicture
      ) {
        this.refresh(
          elm._spSprite,
          $gameSystem._LL_StandingPicture_picture1.spriteSPicture,
          1
        );
        $gameSystem._LL_StandingPicture_picture1.refSPicture = false;
      }
      // 立ち絵2ピクチャ作成
      if (
        $gameSystem._LL_StandingPicture_picture2.spriteSPicture &&
        $gameSystem._LL_StandingPicture_picture2.refSPicture
      ) {
        this.refresh(
          elm._spSprite2,
          $gameSystem._LL_StandingPicture_picture2.spriteSPicture,
          2
        );
        $gameSystem._LL_StandingPicture_picture2.refSPicture = false;
      }
      // 立ち絵3ピクチャ作成
      if (
        $gameSystem._LL_StandingPicture_picture3.spriteSPicture &&
        $gameSystem._LL_StandingPicture_picture3.refSPicture
      ) {
        this.refresh(
          elm._spSprite3,
          $gameSystem._LL_StandingPicture_picture3.spriteSPicture,
          3
        );
        $gameSystem._LL_StandingPicture_picture3.refSPicture = false;
      }
      // 立ち絵4ピクチャ作成
      if (
        $gameSystem._LL_StandingPicture_picture4.spriteSPicture &&
        $gameSystem._LL_StandingPicture_picture4.refSPicture
      ) {
        this.refresh(
          elm._spSprite4,
          $gameSystem._LL_StandingPicture_picture4.spriteSPicture,
          4
        );
        $gameSystem._LL_StandingPicture_picture4.refSPicture = false;
      }

      // フォーカス状態リセット
      if (focusReset) {
        elm._spSprite.setBlendColor([0, 0, 0, 0]);
        elm._spSprite2.setBlendColor([0, 0, 0, 0]);
        elm._spSprite3.setBlendColor([0, 0, 0, 0]);
        elm._spSprite4.setBlendColor([0, 0, 0, 0]);
        focusReset = false;
      }

      // フォーカス処理
      if (
        $gameSystem._LL_StandingPicture_focusSPicture[0] !== false ||
        $gameSystem._LL_StandingPicture_focusSPicture[1] !== false ||
        $gameSystem._LL_StandingPicture_focusSPicture[2] !== false ||
        $gameSystem._LL_StandingPicture_focusSPicture[3] !== false ||
        $gameSystem._LL_StandingPicture_focusSPicture[4] !== false
      ) {
        // フォーカス状態を一度リフレッシュ
        elm._spSprite.setBlendColor([0, 0, 0, 0]);
        elm._spSprite2.setBlendColor([0, 0, 0, 0]);
        elm._spSprite3.setBlendColor([0, 0, 0, 0]);
        elm._spSprite4.setBlendColor([0, 0, 0, 0]);

        if (
          $gameSystem._LL_StandingPicture_focusSPicture[1] === false ||
          $gameSystem._LL_StandingPicture_focusSPicture[0] === true
        ) {
          elm._spSprite.setBlendColor([0, 0, 0, focusToneAdjust * -1]);
        }
        if (
          $gameSystem._LL_StandingPicture_focusSPicture[2] === false ||
          $gameSystem._LL_StandingPicture_focusSPicture[0] === true
        ) {
          elm._spSprite2.setBlendColor([0, 0, 0, focusToneAdjust * -1]);
        }
        if (
          $gameSystem._LL_StandingPicture_focusSPicture[3] === false ||
          $gameSystem._LL_StandingPicture_focusSPicture[0] === true
        ) {
          elm._spSprite3.setBlendColor([0, 0, 0, focusToneAdjust * -1]);
        }
        if (
          $gameSystem._LL_StandingPicture_focusSPicture[4] === false ||
          $gameSystem._LL_StandingPicture_focusSPicture[0] === true
        ) {
          elm._spSprite4.setBlendColor([0, 0, 0, focusToneAdjust * -1]);
        }
      }

      // フェード処理
      if ($gameSystem._LL_StandingPicture_picture1.showSPicture) {
        this.fadeIn(
          elm._spSprite,
          $gameSystem._LL_StandingPicture_picture1.spriteSPicture,
          1
        );
      } else {
        this.fadeOut(
          elm._spSprite,
          $gameSystem._LL_StandingPicture_picture1.spriteSPicture,
          1
        );
      }
      if ($gameSystem._LL_StandingPicture_picture2.showSPicture) {
        this.fadeIn(
          elm._spSprite2,
          $gameSystem._LL_StandingPicture_picture2.spriteSPicture,
          2
        );
      } else {
        this.fadeOut(
          elm._spSprite2,
          $gameSystem._LL_StandingPicture_picture2.spriteSPicture,
          2
        );
      }
      if ($gameSystem._LL_StandingPicture_picture3.showSPicture) {
        this.fadeIn(
          elm._spSprite3,
          $gameSystem._LL_StandingPicture_picture3.spriteSPicture,
          3
        );
      } else {
        this.fadeOut(
          elm._spSprite3,
          $gameSystem._LL_StandingPicture_picture3.spriteSPicture,
          3
        );
      }
      if ($gameSystem._LL_StandingPicture_picture4.showSPicture) {
        this.fadeIn(
          elm._spSprite4,
          $gameSystem._LL_StandingPicture_picture4.spriteSPicture,
          4
        );
      } else {
        this.fadeOut(
          elm._spSprite4,
          $gameSystem._LL_StandingPicture_picture4.spriteSPicture,
          4
        );
      }

      // 立ち絵モーション再生
      if (
        !elm._spSprite.opening &&
        !elm._spSprite.closing &&
        $gameSystem._LL_StandingPicture_picture1.animationCount > 0
      ) {
        $gameSystem._LL_StandingPicture_picture1.animationCount =
          this.animation(
            elm._spSprite,
            $gameSystem._LL_StandingPicture_picture1.motionSPicture,
            $gameSystem._LL_StandingPicture_picture1.animationCount
          );
      }
      if (
        !elm._spSprite2.opening &&
        !elm._spSprite2.closing &&
        $gameSystem._LL_StandingPicture_picture2.animationCount > 0
      ) {
        $gameSystem._LL_StandingPicture_picture2.animationCount =
          this.animation(
            elm._spSprite2,
            $gameSystem._LL_StandingPicture_picture2.motionSPicture,
            $gameSystem._LL_StandingPicture_picture2.animationCount
          );
      }
      if (
        !elm._spSprite3.opening &&
        !elm._spSprite3.closing &&
        $gameSystem._LL_StandingPicture_picture3.animationCount > 0
      ) {
        $gameSystem._LL_StandingPicture_picture3.animationCount =
          this.animation(
            elm._spSprite3,
            $gameSystem._LL_StandingPicture_picture3.motionSPicture,
            $gameSystem._LL_StandingPicture_picture3.animationCount
          );
      }
      if (
        !elm._spSprite4.opening &&
        !elm._spSprite4.closing &&
        $gameSystem._LL_StandingPicture_picture4.animationCount > 0
      ) {
        $gameSystem._LL_StandingPicture_picture4.animationCount =
          this.animation(
            elm._spSprite4,
            $gameSystem._LL_StandingPicture_picture4.motionSPicture,
            $gameSystem._LL_StandingPicture_picture4.animationCount
          );
      }
    }

    static refresh(sSprite, sPicture, sNumber) {
      sSprite.setPicture(sPicture);
      sSprite.showing = false;
      var calcScaleX = Number(sPicture.scaleX);
      var calcScaleY = Number(sPicture.scaleY);
      // 左右反転させる場合 (立ち絵2, 4)
      if (sNumber == 2 || sNumber == 4) calcScaleX *= Number(sPicture.reverse);
      // 画像が読み込まれたあとに実行
      sSprite.bitmap.addLoadListener(
        function () {
          if (Number(sPicture.origin) == 0) {
            // 左上原点
            if (sNumber == 1) {
              sSprite.x = Number(sPicture.x);
              sSprite.y = Number(sPicture.y);
              sSprite.originX = Number(sPicture.x);
              sSprite.originY = Number(sPicture.y);
            }
            if (sNumber == 2) {
              sSprite.x = Number(sPicture.x2);
              sSprite.y = Number(sPicture.y2);
              sSprite.originX = Number(sPicture.x2);
              sSprite.originY = Number(sPicture.y2);
            }
            if (sNumber == 3) {
              sSprite.x = Number(sPicture.x3);
              sSprite.y = Number(sPicture.y3);
              sSprite.originX = Number(sPicture.x3);
              sSprite.originY = Number(sPicture.y3);
            }
            if (sNumber == 4) {
              sSprite.x = Number(sPicture.x4);
              sSprite.y = Number(sPicture.y4);
              sSprite.originX = Number(sPicture.x4);
              sSprite.originY = Number(sPicture.y4);
            }
          } else {
            // 中央原点
            if (sNumber == 1) {
              sSprite.x =
                Number(sPicture.x) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.y =
                Number(sPicture.y) - (sSprite.height * calcScaleY) / 100 / 2;
              sSprite.originX =
                Number(sPicture.x) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.originY =
                Number(sPicture.y) - (sSprite.height * calcScaleY) / 100 / 2;
            }
            if (sNumber == 2) {
              sSprite.x =
                Number(sPicture.x2) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.y =
                Number(sPicture.y2) - (sSprite.height * calcScaleY) / 100 / 2;
              sSprite.originX =
                Number(sPicture.x2) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.originY =
                Number(sPicture.y2) - (sSprite.height * calcScaleY) / 100 / 2;
            }
            if (sNumber == 3) {
              sSprite.x =
                Number(sPicture.x3) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.y =
                Number(sPicture.y3) - (sSprite.height * calcScaleY) / 100 / 2;
              sSprite.originX =
                Number(sPicture.x3) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.originY =
                Number(sPicture.y3) - (sSprite.height * calcScaleY) / 100 / 2;
            }
            if (sNumber == 4) {
              sSprite.x =
                Number(sPicture.x4) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.y =
                Number(sPicture.y4) - (sSprite.height * calcScaleY) / 100 / 2;
              sSprite.originX =
                Number(sPicture.x4) - (sSprite.width * calcScaleX) / 100 / 2;
              sSprite.originY =
                Number(sPicture.y4) - (sSprite.height * calcScaleY) / 100 / 2;
            }
          }
          // 切替効果
          if (sSprite.opacity == 0) {
            if (transitions[sNumber] == 0)
              sSprite.opacity = Number(sPicture.opacity);
            if (transitions[sNumber] == 2) sSprite.x -= 30;
            if (transitions[sNumber] == 3) sSprite.x += 30;
            if (transitions[sNumber] == 4) sSprite.y += 30;
            if (transitions[sNumber] == 5) sSprite.y -= 30;
          }
          sSprite.setBlendMode(Number(sPicture.blendMode));
          sSprite.setColorTone(
            $gameSystem._StandingPictureTone
              ? $gameSystem._StandingPictureTone
              : [0, 0, 0, 0]
          );
          sSprite.setBlendColor([0, 0, 0, 0]);
          sSprite.scale.x = calcScaleX / 100;
          sSprite.scale.y = calcScaleY / 100;
          sSprite.showing = true;
        }.bind(this)
      );
    }

    static fadeIn(sSprite, sPicture, sNumber) {
      if (!sSprite.showing) return;
      if (sSprite.opacity >= Number(sPicture.opacity)) {
        sSprite.opening = false;
        sSprite.opacity = Number(sPicture.opacity);
        return;
      }
      sSprite.opening = true;
      sSprite.closing = false;
      // 切替効果
      if (sSprite.originX > sSprite.x) sSprite.x += 2;
      if (sSprite.originX < sSprite.x) sSprite.x -= 2;
      if (sSprite.originY < sSprite.y) sSprite.y -= 2;
      if (sSprite.originY > sSprite.y) sSprite.y += 2;
      sSprite.opacity += Number(sPicture.opacity) / 15;
    }

    static fadeOut(sSprite, sPicture, sNumber) {
      if (sSprite.opacity == 0) {
        sSprite.closing = false;
        return;
      }
      sSprite.closing = true;
      if (!sPicture) {
        sSprite.opacity = 0;
        return;
      }
      sSprite.opacity -= Number(sPicture.opacity) / 15;
      // 切替効果
      if (transitions[sNumber] == 0) sSprite.opacity = 0;
      if (transitions[sNumber] == 2 && sSprite.originX - 30 < sSprite.x)
        sSprite.x -= 2;
      if (transitions[sNumber] == 3 && sSprite.originX + 30 > sSprite.x)
        sSprite.x += 2;
      if (transitions[sNumber] == 4 && sSprite.originY + 30 > sSprite.y)
        sSprite.y += 2;
      if (transitions[sNumber] == 5 && sSprite.originY - 30 < sSprite.y)
        sSprite.y -= 2;
    }

    static animation(sSprite, sMotion, animationCount) {
      if (!sSprite.showing) return animationCount;
      if (sMotion == "yes") {
        if (animationCount > 12) {
          sSprite.y += 2;
        } else {
          sSprite.y -= 2;
        }
        animationCount -= 1;
      }
      if (sMotion == "yesyes") {
        if (animationCount > 36) {
          sSprite.y += 2;
        } else if (animationCount > 24) {
          sSprite.y -= 2;
        } else if (animationCount > 12) {
          sSprite.y += 2;
        } else {
          sSprite.y -= 2;
        }
        animationCount -= 1;
      }
      if (sMotion == "no") {
        if (animationCount > 18) {
          sSprite.x += 2;
        } else if (animationCount > 6) {
          sSprite.x -= 2;
        } else {
          sSprite.x += 2;
        }
        animationCount -= 1;
      }
      if (sMotion == "noslow") {
        if (animationCount > 36) {
          sSprite.x += 1;
        } else if (animationCount > 12) {
          sSprite.x -= 1;
        } else {
          sSprite.x += 1;
        }
        animationCount -= 1;
      }
      if (sMotion == "jump") {
        if (animationCount > 12) {
          sSprite.y -= 2;
        } else {
          sSprite.y += 2;
        }
        animationCount -= 1;
      }
      if (sMotion == "jumpjump") {
        if (animationCount > 36) {
          sSprite.y -= 2;
        } else if (animationCount > 24) {
          sSprite.y += 2;
        } else if (animationCount > 12) {
          sSprite.y -= 2;
        } else {
          sSprite.y += 2;
        }
        animationCount -= 1;
      }
      if (sMotion == "jumploop") {
        if (animationCount > 36) {
          sSprite.y -= 2;
        } else if (animationCount > 24) {
          sSprite.y += 2;
        }
        animationCount -= 1;
        if (animationCount == 0) animationCount = 48;
      }
      if (sMotion == "shake") {
        if (animationCount <= 2) {
          sSprite.x -= 2;
          animationCount += 1;
        } else if (animationCount <= 4) {
          sSprite.y -= 2;
          animationCount += 1;
        } else if (animationCount <= 6) {
          sSprite.x += 4;
          sSprite.y += 4;
          animationCount += 1;
        } else if (animationCount <= 8) {
          sSprite.y -= 2;
          animationCount += 1;
        } else if (animationCount == 9) {
          sSprite.x -= 2;
          animationCount += 1;
        } else if (animationCount == 10) {
          sSprite.x -= 2;
          animationCount = 0;
        }
      }
      if (sMotion == "shakeloop") {
        if (animationCount <= 2) {
          sSprite.x -= 1;
          animationCount += 1;
        } else if (animationCount <= 4) {
          sSprite.y -= 1;
          animationCount += 1;
        } else if (animationCount <= 6) {
          sSprite.x += 2;
          sSprite.y += 2;
          animationCount += 1;
        } else if (animationCount <= 8) {
          sSprite.y -= 1;
          animationCount += 1;
        } else if (animationCount <= 10) {
          sSprite.x -= 1;
          animationCount += 1;
        }
        if (animationCount > 10) animationCount = 1;
      }
      if (sMotion == "runleft") {
        sSprite.x -= 16;
        if (sSprite.x < -2000) animationCount = 0;
      }
      if (sMotion == "runright") {
        sSprite.x += 16;
        if (sSprite.x > 2000) animationCount = 0;
      }
      if (sMotion == "noslowloop") {
        if (animationCount > 72) {
          sSprite.x += 0.25;
        } else if (animationCount > 24) {
          sSprite.x -= 0.25;
        } else {
          sSprite.x += 0.25;
        }
        animationCount -= 1;
        if (animationCount == 0) animationCount = animationFrame["noslowloop"];
      }
      if (sMotion == "breathing") {
        if (animationCount > 72) {
          sSprite.y += 0.5;
        } else if (animationCount > 48) {
          sSprite.y -= 0.5;
        } else {
        }
        animationCount -= 1;
        if (animationCount == 0) animationCount = animationFrame["breathing"];
      }
      if (sMotion == "breathing2") {
        if (animationCount > 48) {
          // sSprite.anchor.y = 1;
          sSprite.y -= sSprite.height * 0.0003;
          sSprite.scale.y += 0.0003;
        } else {
          // sSprite.anchor.y = 1;
          sSprite.y += sSprite.height * 0.0003;
          sSprite.scale.y -= 0.0003;
        }
        animationCount -= 1;
        if (animationCount == 0) animationCount = animationFrame["breathing2"];
      }
      if (sMotion == "huwahuwa") {
        if (animationCount > 144) {
          sSprite.y += 0.25;
        } else if (animationCount > 48) {
          sSprite.y -= 0.25;
        } else {
          sSprite.y += 0.25;
        }
        animationCount -= 1;
        if (animationCount == 0) animationCount = animationFrame["huwahuwa"];
      }
      return animationCount;
    }
  }

  var _Scene_Map_update = Scene_Map.prototype.update;
  Scene_Map.prototype.update = function () {
    _Scene_Map_update.apply(this, arguments);
    ExStandingPicture.update(this);
  };

  var _Scene_Map_createDisplayObjects =
    Scene_Map.prototype.createDisplayObjects;
  Scene_Map.prototype.createDisplayObjects = function () {
    _Scene_Map_createDisplayObjects.apply(this, arguments);
    ExStandingPicture.create(this);
  };

  var _Scene_Battle_update = Scene_Battle.prototype.update;
  Scene_Battle.prototype.update = function () {
    _Scene_Battle_update.apply(this, arguments);
    ExStandingPicture.update(this);
  };

  var _Scene_Battle_createDisplayObjects =
    Scene_Battle.prototype.createDisplayObjects;
  Scene_Battle.prototype.createDisplayObjects = function () {
    _Scene_Battle_createDisplayObjects.apply(this, arguments);
    ExStandingPicture.create(this);
  };

  var _Window_Message_updateClose = Window_Message.prototype.updateClose;
  Window_Message.prototype.updateClose = function () {
    // ピクチャ消去判定
    if (this._closing && this.openness == 255) {
      if (!$gameSystem._LL_StandingPicture_holdSPicture) {
        $gameSystem._LL_StandingPicture_picture1.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture2.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture3.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture4.showSPicture = false;
        $gameSystem._LL_StandingPicture_picture1.motionSPicture = "";
        $gameSystem._LL_StandingPicture_picture2.motionSPicture = "";
        $gameSystem._LL_StandingPicture_picture3.motionSPicture = "";
        $gameSystem._LL_StandingPicture_picture4.motionSPicture = "";
      }
    }
    _Window_Message_updateClose.apply(this, arguments);
  };

  var _Window_Message_startMessage = Window_Message.prototype.startMessage;
  Window_Message.prototype.startMessage = function () {
    var messageAllText = $gameMessage.allText();
    exStandingPictureParseChar(messageAllText);

    _Window_Message_startMessage.apply(this, arguments);
  };

  var _Window_Base_convertEscapeCharacters =
    Window_Base.prototype.convertEscapeCharacters;
  Window_Base.prototype.convertEscapeCharacters = function (text) {
    // 立ち絵呼び出し用の制御文字(\V[n]内包)を追加
    text = text.replace(/\\F\[\\V\[(\d+)\]\]/gi, "");
    text = text.replace(/\\FF\[\\V\[(\d+)\]\]/gi, "");
    text = text.replace(/\\FFF\[\\V\[(\d+)\]\]/gi, "");
    text = text.replace(/\\FFFF\[\\V\[(\d+)\]\]/gi, "");

    // 立ち絵呼び出し用の制御文字を追加
    text = text.replace(/\\F\[(\w+)\]/gi, "");
    text = text.replace(/\\FF\[(\w+)\]/gi, "");
    text = text.replace(/\\FFF\[(\w+)\]/gi, "");
    text = text.replace(/\\FFFF\[(\w+)\]/gi, "");
    text = text.replace(/\\M\[(\w+)\]/gi, "");
    text = text.replace(/\\MM\[(\w+)\]/gi, "");
    text = text.replace(/\\MMM\[(\w+)\]/gi, "");
    text = text.replace(/\\MMMM\[(\w+)\]/gi, "");
    text = text.replace(/\\AA\[(\w+)\]/gi, "");
    text = text.replace(/\\FH\[(\w+)\]/gi, "");

    return _Window_Base_convertEscapeCharacters.call(this, text);
  };

  var _Scene_Boot_loadSystemImages = Scene_Boot.loadSystemImages;
  Scene_Boot.loadSystemImages = function () {
    _Scene_Boot_loadSystemImages.call(this);

    if (!catheBootPicture) return;

    // 立ち絵画像を事前読み込み
    sPictureLists.forEach(function (elm) {
      ImageManager.loadPicture(elm.imageName);
    });
  };

  //-----------------------------------------------------------------------------
  // Sprite_LL_SPicture
  //
  // 立ち絵を表示するための独自のスプライトを追加定義します。

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

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

  Sprite_LL_SPicture.prototype.initialize = function () {
    Sprite.prototype.initialize.call(this);

    this.bitmap = null;
    this.opacity = 0;
    this.opening = false;
    this.closing = false;
    this.originX = 0;
    this.originY = 0;
    this.showing = false;

    this.setOverlayBitmap();
    this.initMembers();
  };

  Sprite_LL_SPicture.prototype.setOverlayBitmap = function () {
    //
  };

  Sprite_LL_SPicture.prototype.initMembers = function () {
    //
  };

  Sprite_LL_SPicture.prototype.update = function () {
    Sprite.prototype.update.call(this);
  };

  Sprite_LL_SPicture.prototype.setPicture = function (sPicture) {
    // ベース画像
    this.bitmap = null;
    this.bitmap = ImageManager.loadPicture(sPicture.imageName);
  };

  Sprite_LL_SPicture.prototype.setBlendColor = function (color) {
    Sprite.prototype.setBlendColor.call(this, color);
  };

  Sprite_LL_SPicture.prototype.setColorTone = function (tone) {
    Sprite.prototype.setColorTone.call(this, tone);
  };

  Sprite_LL_SPicture.prototype.setBlendMode = function (mode) {
    this.blendMode = mode;
  };
})();