code:
//=============================================================================
// TMPlugin - バトラー表示拡張
// バージョン: 2.0.0
// 最終更新日: 2016/08/12
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc エネミーに遠近感や息づかいの表現を追加します。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param baseY
 * @desc 拡大率が等倍になるＹ座標。
 * 初期値: 400
 * @default 400
 *
 * @param breathH
 * @desc 息づかいの大きさ。
 * 初期値: 0.05
 * @default 0.05
 *
 * @param mirrorRate
 * @desc 左右反転の確率。
 * 初期値: 0.4（ 0 ～ 1 ）
 * @default 0.4
 *
 * @param breathStop
 * @desc 行動不能時に息づかいを止める。
 * 初期値: 1（ 0 で無効 / 1 で有効 ）
 * @default 1
 *
 * @param shakeEffect
 * @desc 点滅エフェクトを揺れエフェクトに差し替える。
 * 初期値: 1（ 0 で無効 / 1 で有効 ）
 * @default 1
 *
 * @help
 * 使い方:
 *
 *   このプラグインを導入すると、敵キャラの表示に以下の演出が追加されます。
 *     ・画面の上の方に出現する敵が小さく表示される（遠近感）
 *     ・ゆっくりと拡大縮小を繰り返す（息づかい）
 *     ・ランダムに左右が反転する
 *
 *   サイドビューでは左右反転が無効になります。
 *   敵キャラのメモ欄にタグを書き込むことで、敵キャラごとに演出の強弱を
 *   設定することができます。
 *
 *   プラグインコマンドはありません。
 *
 *   このプラグインは RPGツクールMV Version 1.3.0 で動作確認をしています。
 *
 *
 * メモ欄（敵キャラ）タグ:
 *
 *   <scale:1>
 *     拡大率を個別に設定します、このタグがある敵キャラには遠近感の表現が
 *     適用されません。
 *
 *   <breathH:0.05>
 *     息づかいの大きさを個別に設定します。
 *
 *   <noMirror>
 *     左右反転を禁止します。
 */

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

var TMPlugin = TMPlugin || {};
TMPlugin.BattlerEx = {};
TMPlugin.BattlerEx.Parameters = PluginManager.parameters('TMBattlerEx');
TMPlugin.BattlerEx.BaseY = +(TMPlugin.BattlerEx.Parameters['baseY'] || 400);
TMPlugin.BattlerEx.BreathH = +(TMPlugin.BattlerEx.Parameters['breathH'] || 0.05);
TMPlugin.BattlerEx.MirrorRate = +(TMPlugin.BattlerEx.Parameters['mirrorRate'] || 0.4);
TMPlugin.BattlerEx.BreathStop = TMPlugin.BattlerEx.Parameters['breathStop'] === '1';
TMPlugin.BattlerEx.ShakeEffect = TMPlugin.BattlerEx.Parameters['shakeEffect'] === '1';

(function() {

  //-----------------------------------------------------------------------------
  // Sprite_Enemy
  //

  var _Sprite_Enemy_initialize = Sprite_Enemy.prototype.initialize;
  Sprite_Enemy.prototype.initialize = function(battler) {
    _Sprite_Enemy_initialize.call(this, battler);
    var r = +(battler.enemy().meta.scale || this.y / (TMPlugin.BattlerEx.BaseY * 2) + 0.5);
    this._baseScale = new Point(r, r);
    if (!$gameSystem.isSideView() && Math.random() < TMPlugin.BattlerEx.MirrorRate &&
        !battler.enemy().meta.noMirror) {
      this._baseScale.x = 0 - r;
      this._stateIconSprite.scale.x = -1;
    }
    this._breathMax = Math.randomInt(90) + 90;
    this._breathCount = Math.randomInt(this._breathMax);
  };

  var _Sprite_Enemy_update = Sprite_Enemy.prototype.update;
  Sprite_Enemy.prototype.update = function() {
    _Sprite_Enemy_update.call(this);
    this.updateScaleEx();
  };

  Sprite_Enemy.prototype.updateScaleEx = function() {
    if (TMPlugin.BattlerEx.BreathStop && !this._enemy.canMove()) return;
    this._breathCount++;
    if (this._breathCount >= this._breathMax) {
      this._breathMax = Math.randomInt(90) + 90;
      this._breathCount = 0;
    }
    var scaleX = this._baseScale.x;
    var scaleY = this._baseScale.y;
    var bh = +(this._enemy.enemy().meta.breathH || TMPlugin.BattlerEx.BreathH);
    scaleY += Math.sin(Math.PI * this._breathCount / (this._breathMax / 2)) * bh;
    this.scale.set(scaleX, scaleY);
  };

  var _Sprite_Enemy_updateBlink = Sprite_Enemy.prototype.updateBlink;
  Sprite_Enemy.prototype.updateBlink = function() {
    if (TMPlugin.BattlerEx.ShakeEffect) {
      var ed = this._effectDuration;
      this.rotation = ed % 4 < 2 ? ed / 200 : 0 - ed / 200;
    } else {
      _Sprite_Enemy_updateBlink.call(this);
    }
  };

})();


code:
//=============================================================================
// TMPlugin - バニータッチ
// バージョン: 1.1.0
// 最終更新日: 2018/03/02
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2018 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc 数字を順番にタッチしていくミニゲームを追加します。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param characterName
 * @type file
 * @desc バニーとして使用する歩行画像のファイル名
 * 初期値: People2
 * @default People2
 * @require 1
 * @dir img/characters/
 *
 * @param characterIndex
 * @type number
 * @desc バニーとして使用する歩行画像のインデックス
 * 初期値: 7
 * @default 7
 *
 * @param numberColor
 * @desc バニーに描画する数字の色
 * 初期値: #000000
 * @default #000000
 *
 * @param numberOutlineColor
 * @desc バニーに描画する数字の縁の色
 * 初期値: #ffffff
 * @default #ffffff
 *
 * @param selectColor
 * @desc バニーに描画する数字の色 (選択中)
 * 初期値: #e02000
 * @default #e02000
 *
 * @param selectOutlineColor
 * @desc バニーに描画する数字の縁の色 (選択中)
 * 初期値: #ffffe0
 * @default #ffffe0
 *
 * @param helpLines
 * @number
 * @desc ヘルプテキストを表示するウィンドウの行数
 * 初期値: 2
 * @default 2
 *
 * @param helpTexts
 * @type struct<HelpText>
 * @desc ヘルプテキストの表示内容 (バニータッチ)
 * @default {"prestart":"数字が小さい順にタッチしてね!!\\n(クリック or タップ でタッチ開始)","end":"\\C[2]タッチ完了!!\\C[0]\\n所要時間: %1秒 (ミス%2回 × %3秒)", "timeup":"\\C[2]時間切れ!!\\C[0]\\n成功タッチ: %1回 (ミス%2回 × %3秒)"}
 *
 * @param helpCalcTexts
 * @type struct<HelpText>
 * @desc ヘルプテキストの表示内容 (バニー計算)
 * @default {"prestart":"合計がお題と同じになるようにタッチしてね!!\\n(クリック or タップ でタッチ開始)","end":"\\C[2]タッチ完了!!\\C[0]\\n所要時間: %1秒", "timeup":"\\C[2]時間切れ!!\\C[0]"}
 *
 * @param stateText
 * @desc 連続プレイオプションが有効なときのプレイ回数の書式
 * (%1 = 現在のプレイ数 / %2 = 最大プレイ数)
 * @default %1/%2回
 *
 * @param giveupText
 * @desc shiftキーによるギブアップで表示されるメッセージ
 * @default ギブアップしました。
 *
 * @param penalty
 * @type number
 * @desc ミスタッチのペナルティ時間 (ミリ秒)
 * 初期値: 1000
 * @default 1000
 *
 * @param vnResultTime
 * @type variable
 * @desc 結果（所要時間）を代入するゲーム変数
 * 初期値: 1
 * @default 1
 *
 * @param vnResultSuccess
 * @type variable
 * @desc 結果（成功タッチ）を代入するゲーム変数
 * 初期値: 2
 * @default 2
 *
 * @param seTouchSuccess
 * @type struct<SoundEffect>
 * @desc 成功タッチの効果音
 * @default {"name":"Item3","volume":"90","pitch":"150","pan":"0"}
 *
 * @param seTouchMiss
 * @type struct<SoundEffect>
 * @desc ミスタッチの効果音
 * @default {"name":"Buzzer2","volume":"90","pitch":"100","pan":"0"}
 *
 * @param seCalcSelectOn
 * @type struct<SoundEffect>
 * @desc 選択タッチの効果音 (バニー計算)
 * @default {"name":"Cursor2","volume":"90","pitch":"100","pan":"0"}
 *
 * @param seCalcSelectOff
 * @type struct<SoundEffect>
 * @desc 解除タッチの効果音 (バニー計算)
 * @default {"name":"Cancel1","volume":"90","pitch":"100","pan":"0"}
 *
 * @param seTouchStart
 * @type struct<SoundEffect>
 * @desc タッチ開始の効果音
 * @default {"name":"Magic3","volume":"90","pitch":"120","pan":"0"}
 *
 * @param seTouchEnd
 * @type struct<SoundEffect>
 * @desc タッチ終了の効果音
 * @default {"name":"Applause1","volume":"90","pitch":"100","pan":"0"}
 *
 * @param seTimeup
 * @type struct<SoundEffect>
 * @desc タイムアップの効果音
 * @default {"name":"Applause2","volume":"90","pitch":"80","pan":"0"}
 *
 * @help
 * TMPlugin - バニータッチ ver1.1.0
 *
 * 使い方:
 *
 *   イベントコマンド『プラグインコマンド』で startBunnyTouch を
 *   実行するとバニータッチゲームが起動します。
 *
 *   バニータッチが終わると結果がゲーム変数に代入されます、
 *   この値で条件分岐させることで、結果に応じた処理が作れます。
 *   初期設定では1番に所要時間、2番に成功タッチ数が代入されます。
 *   時間切れの場合は所要時間に -1 が代入されます。
 *
 *   BGMを再生する機能はありません、バニータッチ起動直前に
 *   イベントコマンドで好きなBGMを流してください。
 *
 *   このプラグインは RPGツクールMV Version 1.5.1 で動作確認をしています。
 *
 *   このプラグインはMITライセンスのもとに配布しています、商用利用、
 *   改造、再配布など、自由にお使いいただけます。
 *
 *
 * プラグインコマンド:
 *
 *   startBunnyTouch 5 3 2 10 1.0
 *     バニータッチを開始します。
 *     数値は順に バニーの数、列数、行数、制限時間、拡大率 となります。
 *     上記の例は、横3マス×縦2マスの場に5人のバニーさんが配置され、
 *     制限時間は10秒という設定になっています。
 *     制限時間に 0 を設定すると、制限時間がなくなります。
 *
 *     場が狭く、画面の余白が広くなってしまう場合は、拡大率の値を
 *     大きく設定することで、場を拡大表示することができます。
 *
 *     また、下記のようにオプション値を付けることもできます。
 *     startBunnyTouch 5 3 2 10 1.0 rm
 *     r = 数字が連続しなくなる
 *     m = 数字が左右反転する
 *     rm なら両方のオプションが有効になります。
 *
 *   startBunnyCalc 6 4 3 2 30 1.0
 *     バニー計算を開始します。
 *     数値は順に バニーの数、お題バニーの数、列数、行数、制限時間、
 *     拡大率 となります。
 *     上記の例では6人のバニーのうち、4人の合計がお題となり、
 *     合計がお題と同じになるようにタッチするゲームになります。
 *
 *     他の数値はバニータッチと同様です、オプション値も利用できます。
 *
 *
 * プラグインパラメータ補足:
 *
 *   helpTexts
 *     \C[n] や \} などの制御文字も利用できます、改行したい場合は
 *     \n で改行することができます。
 *
 *   helpCalcTexts
 *     バニー計算のルールでは成功タッチ、ミス回数がカウントされません。
 */
/*~struct~SoundEffect:
 *
 * @param name
 * @type file
 * @dir audio/se/
 * @desc 効果音のファイル名
 * @default
 * @require 1
 *
 * @param volume
 * @type number
 * @max 100
 * @desc 効果音の音量
 * 初期値: 90
 * @default 90
 *
 * @param pitch
 * @type number
 * @min 50
 * @max 150
 * @desc 効果音のピッチ
 * 初期値: 100
 * @default 100
 *
 * @param pan
 * @type number
 * @min -100
 * @max 100
 * @desc 効果音の位相
 * 初期値: 0
 * @default 0
 *
 */
/*~struct~HelpText:
 *
 * @param prestart
 * @desc バニータッチ開始前に表示するヘルプテキスト
 *
 * @param end
 * @desc バニータッチ終了時に表示するヘルプテキスト
 * (%1 = 所要時間 / %2 = ミス回数 / %3 = ペナルティ秒数)
 *
 * @param timeup
 * @desc 時間切れの際に表示するヘルプテキスト
 * (%1 = 成功タッチ / %2 = ミス回数 / %3 = ペナルティ秒数)
 *
 */

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

(function() {

  var parameters = PluginManager.parameters('TMBunnyTouch');
  var characterName = parameters['characterName'] || 'People2';
  var characterIndex = +(parameters['characterIndex'] || 7);
  var numberColor = parameters['numberColor'] || '#000000';
  var numberOutlineColor = parameters['numberOutlineColor'] || '#ffffff';
  var selectColor = parameters['selectColor'] || '#e02000';
  var selectOutlineColor = parameters['selectOutlineColor'] || '#ffffe0';
  var helpLines = +(parameters['helpLines'] || 2);
  var helpTexts = JSON.parse(parameters['helpTexts'] || "{}");
  var helpCalcTexts = JSON.parse(parameters['helpCalcTexts'] || "{}");
  var stateText = parameters['stateText'] || '%1/%2回';
  var giveupText = parameters['giveupText'] || '';
  var penalty = +(parameters['penalty'] || 1000);
  var vnResultTime = +(parameters['vnResultTime'] || 1);
  var vnResultSuccess = +(parameters['vnResultSuccess'] || 2);
  var seTouchSuccess = JSON.parse(parameters['seTouchSuccess'] || "{}");
  var seTouchMiss = JSON.parse(parameters['seTouchMiss'] || "{}");
  var seCalcSelectOn = JSON.parse(parameters['seCalcSelectOn'] || "{}");
  var seCalcSelectOff = JSON.parse(parameters['seCalcSelectOff'] || "{}");
  var seTouchStart = JSON.parse(parameters['seTouchStart'] || "{}");
  var seTouchEnd = JSON.parse(parameters['seTouchEnd'] || "{}");
  var seTimeup = JSON.parse(parameters['seTimeup'] || "{}");

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

  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function(command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === 'startBunnyTouch') {
      SceneManager.push(Scene_BunnyTouch);
      SceneManager.prepareNextScene.apply(SceneManager, args);
    } else if (command === 'startBunnyCalc') {
      SceneManager.push(Scene_BunnyCalc);
      SceneManager.prepareNextScene.apply(SceneManager, args);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_Bunny
  //

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

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

  Window_Bunny.prototype.initialize = function(cellWidth, cellHeight, scale) {
    var width = cellWidth * 48 * scale + this.standardPadding() * 2;
    var height = cellHeight * 48 * scale + this.standardPadding() * 2;
    var x = (Graphics.width - width) / 2;
    Window_Base.prototype.initialize.call(this, x, 0, width, height);
    this.refresh();
  };

  Window_Bunny.prototype.refresh = function() {
    this.contents.clear();
  };

  //-----------------------------------------------------------------------------
  // Window_BunnyTimer
  //

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

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

  Window_BunnyTimer.prototype.initialize = function(timeLimit) {
    var width = this.windowWidth();
    var height = this.fittingHeight(1);
    var x = (Graphics.width - width) / 2;
    Window_Base.prototype.initialize.call(this, x, 0, width, height);
    this._timeLimit = timeLimit;
    this._time = 0;
    this._stop = true;
    this.refresh();
  };

  Window_BunnyTimer.prototype.windowWidth = function() {
    return 240;
  };

  Window_BunnyTimer.prototype.setTimeupHandler = function(method) {
    this._timeupHandler = method;
  };

  Window_BunnyTimer.prototype.isTimeup = function() {
    return this._timeLimit && this._time >= this._timeLimit;
  };

  Window_BunnyTimer.prototype.refresh = function() {
    this.contents.clear();
    var n = this._timeLimit ? Math.max(this._timeLimit - this._time, 0) : this._time;
    this.drawText((n / 1000).toFixed(3) + " 秒", 0, 0, this.contents.width, 'right');
  };

  Window_BunnyTimer.prototype.start = function() {
    this._stop = false;
    this._startTime = Date.now();
  };

  Window_BunnyTimer.prototype.stop = function() {
    this._stop = true;
    return this._time;
  };

  Window_BunnyTimer.prototype.applyPenalty = function() {
    this._startTime -= penalty;
  };

  Window_BunnyTimer.prototype.update = function() {
    Window_Base.prototype.update.call(this);
    if (!this._stop) {
      this._time = Date.now() - this._startTime;
      if (this.isTimeup()) this._timeupHandler();
    }
    if (Graphics.frameCount % 4 === 0) {
      this.refresh();
    }
  };

  //-----------------------------------------------------------------------------
  // Window_BunnyState
  //

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

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

  Window_BunnyState.prototype.initialize = function(repeatTimes) {
    var width = this.windowWidth();
    var height = this.fittingHeight(1);
    Window_Base.prototype.initialize.call(this, 0, 0, width, height);
    this._repeatTimes = repeatTimes;
    this._count = 1;
    this.refresh();
  };

  Window_BunnyState.prototype.windowWidth = function() {
    return 140;
  };

  Window_BunnyState.prototype.increaseCount = function() {
    this._count++;
    this.refresh();
  };

  Window_BunnyState.prototype.refresh = function() {
    this.contents.clear();
    var text = stateText.format(this._count, this._repeatTimes);
    this.drawText(text, 0, 0, this.contents.width, 'right');
  };

  //-----------------------------------------------------------------------------
  // Window_BunnyCalc
  //

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

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

  Window_BunnyCalc.prototype.initialize = function() {
    var width = this.windowWidth();
    var height = this.fittingHeight(1);
    Window_Base.prototype.initialize.call(this, 0, 0, width, height);
  };

  Window_BunnyCalc.prototype.windowWidth = function() {
    return 240;
  };

  Window_BunnyCalc.prototype.setNumber = function(current, target) {
    this._currentNumber = current;
    this._targetNumber = target;
    this.refresh();
  };

  Window_BunnyCalc.prototype.refresh = function() {
    this.contents.clear();
    var textWidth = this.textWidth('/');
    var w = Math.floor((this.contents.width - textWidth) / 2);
    this.drawText('/', 0, 0, this.contents.width, 'center');
    this.drawText(this._currentNumber, 0, 0, w, 'center');
    this.drawText(this._targetNumber, w + textWidth, 0, w, 'center');
  };

  //-----------------------------------------------------------------------------
  // Sprite_Bunny
  //

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

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

  Sprite_Bunny.prototype.initialize = function(id, scale, mirror) {
    Sprite.prototype.initialize.call(this);
    this.createBitmap();
    this.setId(id);
    this._mirror = mirror;
    this.anchor.x = 0.5;
    this.anchor.y = 0.5;
    this._baseX = 0;
    this._baseY = 0;
    this._baseScale = scale;
    this.updateScale();
  };

  Sprite_Bunny.prototype.id = function() {
    return this._id;
  };

  Sprite_Bunny.prototype.setId = function(id) {
    this._id = id;
    this.drawBunny();
    this.drawNumber();
    this.opacity = 255;
    this._active = true;
    this._touching = false;
    this._effectType = 0;
    this._effectDuration = 0;
    this._offsetX = 0;
    this._offsetY = 0;
    this._offsetScale = 1;
  };

  Sprite_Bunny.prototype.createBitmap = function() {
    var bitmap = ImageManager.loadCharacter(characterName);
    this._isBigCharacter = ImageManager.isBigCharacter(characterName);
    var pw = bitmap.width / (this._isBigCharacter ? 3 : 12);
    var ph = bitmap.height / (this._isBigCharacter ? 4 : 8);
    this.bitmap = new Bitmap(pw, ph);
  };

  Sprite_Bunny.prototype.drawBunny = function() {
    this.bitmap.clear();
    var pw = this.bitmap.width;
    var ph = this.bitmap.height;
    var sx = (this.characterBlockX() + 1) * pw;
    var sy = (this.characterBlockY() + 0) * ph;
    var bitmap = ImageManager.loadCharacter(characterName);
    this.bitmap.blt(bitmap, sx, sy, pw, ph, 0, 0);
  };

  Sprite_Bunny.prototype.characterBlockX = function() {
    return this._isBigCharacter ? 0 : characterIndex % 4 * 3;
  };

  Sprite_Bunny.prototype.characterBlockY = function() {
    return this._isBigCharacter ? 0 : Math.floor(characterIndex / 4) * 4;
  };

  Sprite_Bunny.prototype.drawNumber = function(select) {
    this.bitmap.textColor = select ? selectColor : numberColor;
    this.bitmap.outlineWidth = 8;
    this.bitmap.outlineColor = select ? selectOutlineColor : numberOutlineColor;
    this.bitmap.drawText(this._id, 0, 0, this.bitmap.width, this.bitmap.height, 'center');
  };

  Sprite_Bunny.prototype.setBasePosition = function(x, y) {
    this._baseX = x;
    this._baseY = y;
    this.updatePosition();
  };

  Sprite_Bunny.prototype.update = function() {
    Sprite.prototype.update.call(this);
    this.updatePosition();
    this.updateScale();
    this.processTouch();
    this.updateEffect();
  };

  Sprite_Bunny.prototype.updatePosition = function() {
    this.x = this._baseX + this._offsetX;
    this.y = this._baseY + this._offsetY;
  };

  Sprite_Bunny.prototype.updateScale = function() {
    this.scale.y = this._baseScale * this._offsetScale;
    this.scale.x = this._mirror ? 0 - this.scale.y : this.scale.y;
  };

  Sprite_Bunny.prototype.updateEffect = function() {
    if (this._effectDuration > 0) {
      this._effectDuration--;
      if (this._effectType === 1) {
        this.opacity -= 16;
        this._offsetScale += 0.03;
      } else if (this._effectType === 2) {
        if (this._effectDuration === 0) {
          this._offsetX = 0;
        } else {
          this._offsetX = Math.sin(this._effectDuration) * 8;
        }
      } else if (this._effectType === 3) {
        if (this._effectDuration === 0) {
          this._offsetScale = 1.0;
        } else {
          this._offsetScale += 0.02;
        }
      }
    }
  };

  Sprite_Bunny.prototype.setClickHandler = function(method) {
    this._clickHandler = method;
  };

  Sprite_Bunny.prototype.callClickHandler = function() {
    if (this._clickHandler) this._clickHandler(this);
  };

  Sprite_Bunny.prototype.processSuccess = function() {
    AudioManager.playSe(seTouchSuccess);
    this._effectType = 1;
    this._effectDuration = 16;
    this._offsetScale = 0.75;
    this._active = false;
  };

  Sprite_Bunny.prototype.processMiss = function() {
    AudioManager.playSe(seTouchMiss);
    this._effectType = 2;
    this._effectDuration = 16;
  };

  Sprite_Bunny.prototype.processCalc = function(select) {
    AudioManager.playSe(select ? seCalcSelectOn : seCalcSelectOff);
    this.drawBunny();
    this.drawNumber(select);
    this._effectType = 3;
    this._effectDuration = 16;
    this._offsetScale = 0.68;
  };

  Sprite_Bunny.prototype.processTouch = function() {
    if (this._active) {
      if (TouchInput.isTriggered() && this.isTouched()) {
        this._touching = true;
      }
      if (this._touching) {
        if (TouchInput.isReleased() || !this.isTouched()) {
          this._touching = false;
          if (TouchInput.isReleased()) this.callClickHandler();
        }
      }
    } else {
      this._touching = false;
    }
  };

  Sprite_Bunny.prototype.isTouched = function() {
    var x = this.canvasToLocalX(TouchInput.x);
    var y = this.canvasToLocalY(TouchInput.y);
    var w = this.width / 2 * this._baseScale;
    var h = this.height / 2 * this._baseScale;
    return x >= -w && y >= -h && x < w && y < h;
  };

  Sprite_Bunny.prototype.canvasToLocalX = function(x) {
    var node = this;
    while (node) {
      x -= node.x;
      node = node.parent;
    }
    return x;
  };

  Sprite_Bunny.prototype.canvasToLocalY = function(y) {
    var node = this;
    while (node) {
      y -= node.y;
      node = node.parent;
    }
    return y;
  };

  //-----------------------------------------------------------------------------
  // Scene_BunnyBase
  //

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

  Scene_BunnyBase.prototype = Object.create(Scene_MenuBase.prototype);
  Scene_BunnyBase.prototype.constructor = Scene_BunnyBase;

  Scene_BunnyBase.prototype.initialize = function() {
    Scene_Base.prototype.initialize.call(this);
    ImageManager.reserveCharacter(characterName);
    this._sceneState = 0;
    this._waitCount = 0;
    this._missCount = 0;
    this._successCount = 0;
  };

  Scene_BunnyBase.prototype.prepare = function(num, targetNum, w, h, time, scale, options) {
    this._bunnyNum = +(num || 5);
    this._cellWidth = +(w || 3);
    this._cellHeight = +(h || 3);
    this._targetNum = +(targetNum || Math.max(Math.floor(num / 2), 1));
    this._timeLimit = +(time || 0) * 1000;
    this._scale = +(scale || 1);
    this._random = options && options.indexOf('r') >= 0;
    this._mirror = options && options.indexOf('m') >= 0;
    this._repeatTimes = this.repeatTimes(options);
  };

  Scene_BunnyBase.prototype.repeatTimes = function(options) {
    var re = /\d+/g;
    var match = re.exec(options);
    return match ? +match[0] : 1;
  };

  Scene_BunnyBase.prototype.create = function() {
    Scene_MenuBase.prototype.create.call(this);
    this.createWindows();
    this._helpWindow.setText(this.helpTexts().prestart.replace(/\\n/g, '\n'));
    this._helpWindow.openness = 0;
    this._helpWindow.open();
    this.setWindowPosition();
  };

  Scene_BunnyBase.prototype.createWindows = function() {
    this.createTimerWindow();
    this.createBunnyWindow();
    this.createHelpWindow(helpLines);
    if (this._repeatTimes > 1) this.createStateWindow();
  };

  Scene_BunnyBase.prototype.createTimerWindow = function() {
    this._timerWindow = new Window_BunnyTimer(this._timeLimit);
    this._timerWindow.setTimeupHandler(this.processTimeup.bind(this));
    this.addWindow(this._timerWindow);
  };

  Scene_BunnyBase.prototype.createCalcWindow = function() {
    this._calcWindow = new Window_BunnyCalc();
    this.addWindow(this._calcWindow);
  };

  Scene_BunnyBase.prototype.createBunnyWindow = function() {
    this._bunnyWindow = new Window_Bunny(this._cellWidth, this._cellHeight, this._scale);
    this.addWindow(this._bunnyWindow);
  };

  Scene_BunnyBase.prototype.createStateWindow = function() {
    this._stateWindow = new Window_BunnyState(this._repeatTimes);
    this.addWindow(this._stateWindow);
  };

  Scene_BunnyBase.prototype.setWindowPosition = function() {
    this._helpWindow.y = (Graphics.height - this._helpWindow.height) / 2;
    var wy = (Graphics.height - this._bunnyWindow.height) / 2;
    this._bunnyWindow.y = Math.max(wy, this._timerWindow.height);
    this._timerWindow.y = this._bunnyWindow.y - this._timerWindow.height;
    if (this._stateWindow) {
      this._stateWindow.x = this._timerWindow.x + this._timerWindow.width;
      this._stateWindow.y = this._timerWindow.y;
    }
  };

  Scene_BunnyBase.prototype.createBunnySprites = function() {
    var ids = this.spriteIds();
    this._bunnySprites = [];
    for (var i = 0; i < this._bunnyNum; i++) {
      var sprite = new Sprite_Bunny(ids[i], this._scale, this._mirror);
      sprite.setClickHandler(this.processTouch.bind(this));
      this._bunnySprites.unshift(sprite);
      this._bunnyWindow.addChild(sprite);
    }
    this.setSpritePosition();
  };

  Scene_BunnyBase.prototype.spriteIds = function() {
    var result = [];
    var n = 1;
    for (var i = 0; i < this._bunnyNum; i++) {
      result.unshift(n++);
      if (this._random) n += Math.randomInt(Math.randomInt(10) + 1);
    }
    return result;
  };

  Scene_BunnyBase.prototype.setSpritePosition = function() {
    var points = [];
    for (var i = 0; i < this._cellWidth * this._cellHeight; i++) {
      points.push(i);
    }
    var len = points.length;
    var w = 48 * this._scale;
    var padding = this._bunnyWindow.standardPadding();
    for (var i = 0; i < this._bunnySprites.length; i++) {
      var r = Math.randomInt(len);
      var x = (points[r] % this._cellWidth) * w + w / 2;
      var y = Math.floor(points[r] / this._cellWidth) * w + w / 2;
      this._bunnySprites[i].setBasePosition(x + padding, y + padding);
      len--;
      points[r] = points[len];
    }
  };

  Scene_BunnyBase.prototype.processTimeup = function() {
    AudioManager.playSe(seTimeup);
    this._resultTime = this._timerWindow.stop();
    $gameVariables.setValue(vnResultTime, -1);
    $gameVariables.setValue(vnResultSuccess, this._successCount);
    var text = this.helpTexts().timeup;
    var n = this._successCount;
    this._helpWindow.setText(text.replace(/\\n/g, '\n').format(n, this._missCount,
                             (penalty / 1000).toFixed(3)));
    this._helpWindow.open();
    this._sceneState = 2;
    this._waitCount = 0;
  };

  Scene_BunnyBase.prototype.processEnd = function() {
    this._repeatTimes--;
    if (this._repeatTimes === 0) {
      AudioManager.playSe(seTouchEnd);
      this._resultTime = this._timerWindow.stop();
      $gameVariables.setValue(vnResultTime, this._resultTime);
      $gameVariables.setValue(vnResultSuccess, this._successCount);
      var text = this.helpTexts().end;
      var n = (this._resultTime / 1000).toFixed(3);
      this._helpWindow.setText(text.replace(/\\n/g, '\n').format(n, this._missCount,
                               (penalty / 1000).toFixed(3)));
      this._helpWindow.open();
      this._sceneState = 2;
      this._waitCount = 0;
    } else {
      this.restartTouch();
    }
  };

  Scene_BunnyBase.prototype.update = function() {
    Scene_MenuBase.prototype.update.call(this);
    if (this._sceneState === 0) {
      this.updatePrestart();
    } else if (this._sceneState === 1) {
      if (Input.isTriggered('shift')) {
        this._timerWindow.stop();
        $gameVariables.setValue(vnResultTime, -1);
        $gameVariables.setValue(vnResultSuccess, 0);
        this._helpWindow.setText(giveupText.replace(/\\n/g, '\n'));
        this._helpWindow.open();
        this._sceneState = 2;
        this._waitCount = 0;
      }
    } else {
      this.updateEnding();
    }
  };

  Scene_BunnyBase.prototype.updatePrestart = function() {
    if (Input.isTriggered('ok') || TouchInput.isTriggered()) this.startTouch();
  }

  Scene_BunnyBase.prototype.startTouch = function() {
    AudioManager.playSe(seTouchStart);
    this._helpWindow.close();
    this.createBunnySprites();
    this._timerWindow.start();
    this._sceneState = 1;
    this.reset();
  };

  Scene_BunnyBase.prototype.restartTouch = function() {
    AudioManager.playSe(seTouchStart);
    var ids = this.spriteIds().reverse();
    this._bunnySprites.forEach(function(sprite, i) {
      sprite.setId(ids[i]);
    });
    this.setSpritePosition();
    this.reset();
    if (this._stateWindow) this._stateWindow.increaseCount();
  };

  Scene_BunnyBase.prototype.updateEnding = function() {
    this._waitCount++;
    if (this._waitCount >= 60) {
      if (Input.isTriggered('ok') || TouchInput.isTriggered()) this.popScene();
    }
  }

  //-----------------------------------------------------------------------------
  // Scene_BunnyTouch
  //

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

  Scene_BunnyTouch.prototype = Object.create(Scene_BunnyBase.prototype);
  Scene_BunnyTouch.prototype.constructor = Scene_BunnyTouch;

  Scene_BunnyTouch.prototype.prepare = function(num, w, h, time, scale, options) {
    Scene_BunnyBase.prototype.prepare.call(this, num, null, w, h, time, scale, options);
  };

  Scene_BunnyTouch.prototype.helpTexts = function() {
    return helpTexts;
  };

  Scene_BunnyTouch.prototype.processTouch = function(sprite) {
    if (this._sceneState !== 1) return;
    if (sprite === this._bunnySprites[this._targetIndex]) {
      sprite.processSuccess();
      this._successCount++;
      this.setNextTarget();
    } else {
      sprite.processMiss();
      this._missCount++;
      this._timerWindow.applyPenalty();
    }
  };

  Scene_BunnyTouch.prototype.setNextTarget = function() {
    this._targetIndex++;
    if (!this._bunnySprites[this._targetIndex]) this.processEnd();
  };

  Scene_BunnyTouch.prototype.reset = function() {
    this._targetIndex = 0;
  };

  //-----------------------------------------------------------------------------
  // Scene_BunnyCalc
  //

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

  Scene_BunnyCalc.prototype = Object.create(Scene_BunnyBase.prototype);
  Scene_BunnyCalc.prototype.constructor = Scene_BunnyCalc;

  Scene_BunnyCalc.prototype.prepare = function(num, targetNum, w, h, time, scale, options) {
    Scene_BunnyBase.prototype.prepare.call(this, num, targetNum, w, h, time, scale, options);
  };

  Scene_BunnyCalc.prototype.helpTexts = function() {
    return helpCalcTexts;
  };

  Scene_BunnyCalc.prototype.createWindows = function() {
    this.createCalcWindow();
    Scene_BunnyBase.prototype.createWindows.call(this);
  };

  Scene_BunnyCalc.prototype.setWindowPosition = function() {
    Scene_BunnyBase.prototype.setWindowPosition.call(this);
    this._timerWindow.x = Math.floor(Graphics.width / 2);
    this._calcWindow.x = this._timerWindow.x - this._calcWindow.width;
    this._calcWindow.y = this._timerWindow.y;
    if (this._stateWindow) this._stateWindow.x = this._timerWindow.x + this._timerWindow.width;
  };

  Scene_BunnyCalc.prototype.processTouch = function(sprite) {
    if (this._sceneState !== 1) return;
    var id = sprite.id();
    var index = this._selectSpriteIds.indexOf(id);
    if (index >= 0) {
      sprite.processCalc(false);
      this._selectSpriteIds.splice(index, 1);
    } else {
      sprite.processCalc(true);
      this._selectSpriteIds.push(id);
    }
    var currentNumber = this.currentNumber();
    this._calcWindow.setNumber(currentNumber, this._totalNumber);
    if (currentNumber === this._totalNumber) {
      this.processEnd();
    }
  };

  Scene_BunnyCalc.prototype.currentNumber = function() {
    return this._selectSpriteIds.reduce(function(r, id) {
      return r + id;
    }, 0);
  };

  Scene_BunnyCalc.prototype.reset = function() {
    this._selectSpriteIds = [];
    this.setTarget();
    this._calcWindow.setNumber(0, this._totalNumber);
  };

  Scene_BunnyCalc.prototype.setTarget = function() {
    var ids = [];
    for (var i = 0; i < this._bunnySprites.length; i++) {
      ids.push(this._bunnySprites[i].id());
    }
    var len = ids.length;
    this._totalNumber = 0;
    for (var i = 0; i < this._targetNum; i++) {
      var r = Math.randomInt(len);
      this._totalNumber += ids[r];
      len--;
      ids[r] = ids[len];
    }
  };

})();

repo_name: onms/sister

license: unknown


code:
//=============================================================================
// TMPlugin - コモンイベントキー
// バージョン: 1.0.2
// 最終更新日: 2017/06/28
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc 任意のキーにコモンイベントを設定し、マップシーンで
 * ショートカットキーとして利用できるようにします。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param commonKey0
 * @type number
 * @desc ０キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey1
 * @type number
 * @desc １キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey2
 * @type number
 * @desc ２キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey3
 * @type number
 * @desc ３キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey4
 * @type number
 * @desc ４キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey5
 * @type number
 * @desc ５キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey6
 * @type number
 * @desc ６キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey7
 * @type number
 * @desc ７キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey8
 * @type number
 * @desc ８キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKey9
 * @type number
 * @desc ９キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyA
 * @type number
 * @desc Ａキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyB
 * @type number
 * @desc Ｂキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyC
 * @type number
 * @desc Ｃキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyD
 * @type number
 * @desc Ｄキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyE
 * @type number
 * @desc Ｅキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF
 * @type number
 * @desc Ｆキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyG
 * @type number
 * @desc Ｇキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyH
 * @type number
 * @desc Ｈキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyI
 * @type number
 * @desc Ｉキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyJ
 * @type number
 * @desc Ｊキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyK
 * @type number
 * @desc Ｋキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyL
 * @type number
 * @desc Ｌキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyM
 * @type number
 * @desc Ｍキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyN
 * @type number
 * @desc Ｎキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyO
 * @type number
 * @desc Ｏキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyP
 * @type number
 * @desc Ｐキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyQ
 * @type number
 * @desc Ｑキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyR
 * @type number
 * @desc Ｒキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyS
 * @type number
 * @desc Ｓキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyT
 * @type number
 * @desc Ｔキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyU
 * @type number
 * @desc Ｕキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyV
 * @type number
 * @desc Ｖキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyW
 * @type number
 * @desc Ｗキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyX
 * @type number
 * @desc Ｘキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyY
 * @type number
 * @desc Ｙキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyZ
 * @type number
 * @desc Ｚキーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF1
 * @type number
 * @desc Ｆ１キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF2
 * @type number
 * @desc Ｆ２キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF3
 * @type number
 * @desc Ｆ３キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF4
 * @type number
 * @desc Ｆ４キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF5
 * @type number
 * @desc Ｆ５キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF6
 * @type number
 * @desc Ｆ６キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF7
 * @type number
 * @desc Ｆ７キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF8
 * @type number
 * @desc Ｆ８キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF9
 * @type number
 * @desc Ｆ９キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF10
 * @type number
 * @desc Ｆ１０キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF11
 * @type number
 * @desc Ｆ１１キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param commonKeyF12
 * @type number
 * @desc Ｆ１２キーで起動するコモンイベント番号
 * 初期値: 0（ 1 以上で有効）
 * @default 0
 *
 * @param freeMove
 * @type boolean
 * @desc プレイヤーが移動中でもキーが有効になります。
 * 初期値: OFF ( false = OFF 無効 / true = ON 有効 )
 * @default false
 *
 * @help
 * TMPlugin - コモンイベントキー ver1.0.2
 *
 * 使い方:
 *
 *   プラグインパラメータに起動したいコモンイベントの番号を設定してください、
 *   マップシーンで対応するキーを押せばコモンイベントが実行されます。
 *
 *   下記の状況ではコモンイベントキーが無効化されます。
 *   ・シーン切り替え中
 *   ・プレイヤー移動中
 *   ・イベント実行中
 *
 *   このプラグインは RPGツクールMV Version 1.5.0 で動作確認をしています。
 *
 *
 * 注意:
 *
 *   RPGツクールMVの標準機能、または他のプラグインで使用しているキーを使うと
 *   競合によるエラーの原因になります。
 */

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

(function() {

  var parameters = PluginManager.parameters('TMCommonEventKey');
  var commonKeyCodes = {48: '0', 49: '1', 50: '2', 51: '3', 52: '4',
                        53: '5', 54: '6', 55: '7', 56: '8', 57: '9',
                        65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E',
                        70: 'F', 71: 'G', 72: 'H', 73: 'I', 74: 'J',
                        75: 'K', 76: 'L', 77: 'M', 78: 'N', 79: 'O',
                        80: 'P', 81: 'Q', 82: 'R', 83: 'S', 84: 'T',
                        85: 'U', 86: 'V', 87: 'W', 88: 'X', 89: 'Y',
                        90: 'Z',
                        112: 'F1', 113: 'F2',  114: 'F3',  115: 'F4',
                        116: 'F5', 117: 'F6',  118: 'F7',  119: 'F8',
                        120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12'};
  var commonKeys = {};
  var keys = Object.keys(commonKeyCodes);
  for (var i = 0, len = keys.length; i < len; i++) {
    var key = keys[i];
    var name = 'commonKey' + commonKeyCodes[key];
    var commonEventId = +parameters[name];
    if (commonEventId > 0) {
      Input.keyMapper[key] = name;
      commonKeys[name] = commonEventId;
    }
  }
  var freeMove = JSON.parse(parameters['freeMove']);

  //-----------------------------------------------------------------------------
  // Scene_Map
  //

  var _Scene_Map_updateScene = Scene_Map.prototype.updateScene;
  Scene_Map.prototype.updateScene = function() {
    _Scene_Map_updateScene.call(this);
    if (!SceneManager.isSceneChanging() && !$gameMap.isEventRunning() &&
        (!$gamePlayer.isMoving() || freeMove )) {
      Object.keys(commonKeys).some (function(key) {
        if (Input.isTriggered(key)) {
          $gameTemp.reserveCommonEvent(commonKeys[key]);
          return true;
        }
      });
    }
  };

})();


code:
//=============================================================================
// TMPlugin - 欲張りショップ
// バージョン: 2.2.0
// 最終更新日: 2018/07/17
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc お金以外にアイテムも要求されるショップ機能を追加します。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param materialWindowPosition
 * @type select
 * @option 商品名の下
 * @value 0
 * @option 商品名の右
 * @value 1
 * @option 購入ウィンドウの下
 * @value 2
 * @desc 素材ウィンドウの表示位置
 * @default 0
 *
 * @param materialWindowWidth
 * @type number
 * @desc 素材ウィンドウの幅
 * 初期値: 408
 * @default 408
 *
 * @param buyWindowWidth
 * @type number
 * @desc 購入ウィンドウの幅
 * 初期値: 456
 * @default 456
 *
 * @param buyWindowHeight
 * @type number
 * @desc 購入ウィンドウの高さ
 * 0なら自動で決定
 * @default 0
 *
 * @param materialMax
 * @type number
 * @desc 設定できる素材の最大数。
 * 初期値: 5
 * @default 5
 *
 * @param fontRate
 * @type number
 * @decimals 2
 * @desc 素材情報のフォント倍率
 * @default 0.8
 *
 * @param greedCommand
 * @desc 欲張りショップの購入コマンド名。
 * 初期値: 購入する
 * @default 購入する
 *
 * @param needText
 * @desc 素材一覧のトップに表示するテキスト
 * ( 何も設定しなければ省略 )
 * @default 必要なもの
 *
 * @param showSellCommand
 * @type boolean
 * @desc 購入のみの場合にも売却コマンドを表示する。
 * @default true
 *
 * @param showMaterialWindow
 * @type boolean
 * @desc 素材ウィンドウを表示する。
 * @default true
 *
 * @param overlaid
 * @type boolean
 * @desc 素材ウィンドウを他のウィンドウと違うレイヤーに表示する。
 * 四隅が欠ける問題は解決しますが、可読性は低下します。
 * @default true
 *
 * @param backOpacity
 * @type number
 * @desc 素材ウィンドウの背景の不透明度
 * @default 192
 *
 * @param showMaterialFromNumberWindow
 * @type boolean
 * @desc 個数選択ウィンドウに素材情報を表示する。
 * @default true
 *
 * @param showPrice
 * @type boolean
 * @desc 商品ウィンドウに価格を表示する。
 * @default true
 *
 * @param seGreedBuy
 * @type struct<SoundEffect>
 * @desc 欲張りショップで購入時に鳴らす効果音
 * @default {"name":"Shop1","volume":"90","pitch":"100","pan":"0"}
 *
 * @help
 * TMPlugin - 欲張りショップ ver2.2.0
 *
 * 使い方:
 *
 *   アイテム、武器、防具にメモ欄タグ（後述）を使って素材を設定します。
 *
 *   イベントコマンド『プラグインコマンド』で greedShop を実行し、
 *   直後にイベントコマンド『ショップの処理』で、素材を設定したアイテムを
 *   商品として販売してください。
 *
 *   このプラグインは RPGツクールMV Version 1.6.1 で動作確認をしています。
 *
 *
 * プラグインコマンド:
 *
 *   greedShop
 *     このコマンドが実行された直後にショップの処理を
 *     実行することで欲張りショップになります。
 *
 *   greedCommand 買っちゃう
 *     欲張りショップの購入コマンド名を『買っちゃう』に変更します。
 *     この変更はセーブデータには保存されません。
 *
 *
 * メモ欄タグ（アイテム、武器、防具）:
 *
 *   <mat1:I1*3>
 *     お金以外にアイテム１番が３個必要になります。
 *     mat2, mat3... と素材を追加していくことができます。
 *     I の部分が W なら武器、A なら防具になります。
 *
 *   <matKey:1>
 *     mat1 タグに設定されている素材をキー素材として扱います。
 *     キー素材を所持していない場合、商品リストから除外されます。
 *     <matKey:1 2> というように半角スペースで区切り、複数のキー素材を
 *     設定することもできます。（この場合、mat1 と mat2 がキー素材になる）
 *     このタグを使うことで、レシピを所持していないと
 *     ショップに並ばない商品などを表現することができます。
 *
 *   <matG:50>
 *     価格を50に設定します、この設定は欲張りショップが
 *     有効になっている場合にのみ購入価格として反映されます。
 *
 *
 * メモ欄タグ（武器、防具）:
 *
 *   <noConsume>
 *     このタグを指定した武器、防具は素材として設定しても
 *     消費されなくなります。
 *
 *     消耗設定が『しない』になっているアイテムを素材にした場合、
 *     消耗しないが必要なものとして機能します。
 */
/*~struct~SoundEffect:
 *
 * @param name
 * @type file
 * @dir audio/se/
 * @desc 効果音のファイル名
 * @default
 * @require 1
 *
 * @param volume
 * @type number
 * @max 100
 * @desc 効果音の音量
 * 初期値: 90
 * @default 90
 *
 * @param pitch
 * @type number
 * @min 50
 * @max 150
 * @desc 効果音のピッチ
 * 初期値: 100
 * @default 100
 *
 * @param pan
 * @type number
 * @min -100
 * @max 100
 * @desc 効果音の位相
 * 初期値: 0
 * @default 0
 *
 */

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

(function() {

  var parameters = PluginManager.parameters('TMGreedShop');
  var materialWindowPosition = +(parameters['materialWindowPosition'] || 0);
  var materialWindowWidth = +(parameters['materialWindowWidth'] || 408);
  var buyWindowWidth = +(parameters['buyWindowWidth'] || 456);
  var buyWindowHeight = +(parameters['buyWindowHeight'] || 0);
  var materialMax = +(parameters['materialMax'] || 5);
  var fontRate = +(parameters['fontRate'] || 0.8);
  var greedCommand = parameters['greedCommand'] || '購入する';
  var needText = parameters['needText'] || '';
  var showSellCommand = JSON.parse(parameters['showSellCommand'] || 'true');
  var showMaterialWindow = JSON.parse(parameters['showMaterialWindow'] || 'true');
  var overlaid = JSON.parse(parameters['overlaid'] || 'true');
  var backOpacity = +(parameters['backOpacity'] || 192);
  var showMaterialFromNumberWindow = JSON.parse(parameters['showMaterialFromNumberWindow'] || 'true');
  var showPrice = JSON.parse(parameters['showPrice'] || 'true');
  var seGreedBuy = JSON.parse(parameters['seGreedBuy'] || '{}');

  //-----------------------------------------------------------------------------
  // DataManager
  //

  DataManager.getGreedShopMaterials = function(item) {
    result = [];
    if (item) {
      var re = /(i|w|a)(\d+)\*(\d+)/i;
      for (var i = 1; i <= materialMax; i++) {
        var key = 'mat' + i;
        if (item.meta[key]) {
          var match = re.exec(item.meta[key]);
          if (match) {
            var material = {};
            material.type = match[1];
            material.id   = +match[2];
            material.need = +match[3];
            result.push(material);
          }
        }
      }
    }
    return result;
  };

  DataManager.materialToItem = function(material) {
    var type = material.type.toUpperCase();
    if (type === 'I') {
      return $dataItems[material.id];
    } else if (type === 'W') {
      return $dataWeapons[material.id];
    } else if (type === 'A') {
      return $dataArmors[material.id];
    }
    return null;
  };

  DataManager.isConsumableMaterial = function(item) {
    return item.consumable || (!this.isItem(item) && !item.meta.noConsume);
  };

  //-----------------------------------------------------------------------------
  // Game_Temp
  //

  Game_Temp.prototype.setGreedShop = function(flag) {
    this._greedShop = flag;
  };

  Game_Temp.prototype.isGreedShop = function() {
    return this._greedShop;
  };

  Game_Temp.prototype.setGreedCommand = function(text) {
    this._greedCommand = text;
  };

  Game_Temp.prototype.greedCommand = function() {
    return this._greedCommand || greedCommand;
  };

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

  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function(command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === 'greedShop') {
      $gameTemp.setGreedShop(true);
    } else if (command === 'greedCommand') {
      $gameTemp.setGreedCommand(args[0]);
    }
  };

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

  // 素材リストの描画
  Window_Base.prototype.drawGreedMaterials = function(x, y, item, amount, rate) {
    var materials = DataManager.getGreedShopMaterials(item);
    this.resetFontSettings();
    this.contents.fontSize = Math.floor(this.contents.fontSize * rate);
    if (needText) {
      y = this.drawGreedNeedText(y, rate);
    }
    for (var i = 0; i < materials.length; i++) {
      y = this.drawGreedMaterial(x, y, materials[i], amount, rate);
    }
    if (this._price) {
      this.drawGreedPrice(y, amount, rate);
    }
    this.resetFontSettings();
  };

  // 素材リストの見出し（初期設定：必要なもの）描画
  Window_Base.prototype.drawGreedNeedText = function(y, rate) {
    var lh = Math.floor(this.lineHeight() * rate);
    this.changeTextColor(this.systemColor());
    this.contents.drawText(needText, 0, y, this.contents.width, lh, 'center');
    return y + lh;
  };

  // 素材の描画
  Window_Base.prototype.drawGreedMaterial = function(x, y, material, amount, rate) {
    var x2 = x + Math.floor((Window_Base._iconWidth + 4) * rate);
    var lh = Math.floor(this.lineHeight() * rate);
    var materialItem = DataManager.materialToItem(material);
    var need = material.need * amount;
    var n = $gameParty.numItems(materialItem);
    var text = DataManager.isConsumableMaterial(materialItem) ? '' + n + '/' : '--/';
    text += ('   ' + need).substr(-3);
    this.drawStretchIcon(x, y, materialItem.iconIndex, rate);
    this.changeTextColor(this.normalColor());
    this.contents.drawText(materialItem.name, x2, y, 312, lh);
    this.contents.drawText(text, x, y, this.contents.width - this.textPadding(), lh, 'right');
    return y + lh;
  };

  // 拡大率を指定したアイコン描画
  Window_Base.prototype.drawStretchIcon = function(x, y, index, rate) {
    var bitmap = ImageManager.loadSystem('IconSet');
    var pw = Window_Base._iconWidth;
    var ph = Window_Base._iconHeight;
    var sx = index % 16 * pw;
    var sy = Math.floor(index / 16) * ph;
    var dw = Math.floor(pw * rate);
    var dh = Math.floor(ph * rate);
    this.contents.blt(bitmap, sx, sy, pw, ph, x, y, dw, dh);
  };

  // 価格の描画
  Window_Base.prototype.drawGreedPrice = function(y, amount, rate) {
    var x = this.textPadding();
    var lh = Math.floor(this.lineHeight() * rate);
    var width = this.contents.width - x * 2;
    var unitWidth = Math.min(80, this.textWidth(TextManager.currencyUnit));
    this.resetTextColor();
    this.contents.drawText(this._price * amount, x, y, width - unitWidth - 6, lh, 'right');
    this.changeTextColor(this.systemColor());
    this.contents.drawText(TextManager.currencyUnit, x + width - unitWidth, y, unitWidth, lh, 'right');
  };

  //-----------------------------------------------------------------------------
  // Window_ShopCommand
  //

  // 売却コマンドを表示するかどうかで列数を変更する
  var _Window_ShopCommand_maxCols = Window_ShopCommand.prototype.maxCols;
  Window_ShopCommand.prototype.maxCols = function() {
    return (showSellCommand || !this._purchaseOnly) ? _Window_ShopCommand_maxCols.call(this) : 2;
  };

  // 欲張りショップならば専用のコマンドリストを作成する
  var _Window_ShopCommand_makeCommandList = Window_ShopCommand.prototype.makeCommandList;
  Window_ShopCommand.prototype.makeCommandList = function() {
    if ($gameTemp.isGreedShop()) {
      this.addCommand($gameTemp.greedCommand(), 'buy');
      if (showSellCommand || !this._purchaseOnly) {
        this.addCommand(TextManager.sell, 'sell', !this._purchaseOnly);
      }
      this.addCommand(TextManager.cancel, 'cancel');
    } else {
      _Window_ShopCommand_makeCommandList.call(this);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_ShopBuy
  //

  var _Window_ShopBuy_initialize = Window_ShopBuy.prototype.initialize;
  Window_ShopBuy.prototype.initialize = function(x, y, height, shopGoods) {
    if ($gameTemp.isGreedShop() && +buyWindowHeight > 0) {
      height = +buyWindowHeight;
    }
    _Window_ShopBuy_initialize.call(this, x, y, height, shopGoods);
  };

  var _Window_ShopBuy_windowWidth = Window_ShopBuy.prototype.windowWidth;
  Window_ShopBuy.prototype.windowWidth = function() {
    if ($gameTemp.isGreedShop()) {
      return buyWindowWidth;
    }
    return _Window_ShopBuy_windowWidth.call(this);
  };

  var _Window_ShopBuy_price = Window_ShopBuy.prototype.price;
  Window_ShopBuy.prototype.price = function(item) {
    if ($gameTemp.isGreedShop() && (item && item.meta.matG)) {
      return +item.meta.matG;
    }
    return _Window_ShopBuy_price.call(this, item);
  };

  var _Window_ShopBuy_isEnabled = Window_ShopBuy.prototype.isEnabled;
  Window_ShopBuy.prototype.isEnabled = function(item) {
    var result = _Window_ShopBuy_isEnabled.call(this, item);
    if (result && $gameTemp.isGreedShop()) {
      var materials = DataManager.getGreedShopMaterials(item);
      for (var i = 0; i < materials.length; i++) {
        var material = materials[i];
        var matItem = DataManager.materialToItem(material);
        if ($gameParty.numItems(matItem) < material.need) {
          return false;
        }
      }
    }
    return result;
  };

  var _Window_ShopBuy_update = Window_ShopBuy.prototype.update;
  Window_ShopBuy.prototype.update = function() {
    _Window_ShopBuy_update.call(this);
    if (this.active && this._materialWindow) {
      this._materialWindow.setShopItem(this.item(), this.price(this.item()));
      this.setMaterialWindowPosition();
    }
  };

  Window_ShopBuy.prototype.setMaterialWindowPosition = function() {
    switch (materialWindowPosition) {
    case 0:  // 商品名の下
      var x = this.x + this.width / 2;
      var y = this.y + this.padding;
      var lineHeight = this.lineHeight();
      y += (this.index() - this.topRow() + 1) * lineHeight;
      this._materialWindow.x = x - this._materialWindow.width / 2;
      this._materialWindow.y = y;
      if (this._materialWindow.y + this._materialWindow.height > Graphics.boxHeight) {
        this._materialWindow.y = y - this._materialWindow.height - lineHeight;
      }
      break;
    case 1:  // 商品名の右
      var x = this.x + this.width - this.padding;
      var y = this.y + this.padding;
      var lineHeight = this.lineHeight();
      y += (this.index() - this.topRow()) * lineHeight;
      this._materialWindow.x = x;
      this._materialWindow.y = y;
      if (this._materialWindow.y + this._materialWindow.height > Graphics.boxHeight) {
        this._materialWindow.y = Graphics.boxHeight - this._materialWindow.height;
      }
      if (this._materialWindow.x + this._materialWindow.width > Graphics.boxWidth) {
        this._materialWindow.x = Graphics.boxWidth - this._materialWindow.width;
      }
      break;
    case 2:  // 購入ウィンドウの下
      this._materialWindow.x = this.x;
      this._materialWindow.y = this.y + this.height;
      if (this._materialWindow.y + this._materialWindow.height > Graphics.boxHeight) {
        this._materialWindow.y = Graphics.boxHeight - this._materialWindow.height;
      }
      break;
    }
  };

  // キー素材を所持していない場合は商品リストから除外する
  var _Window_ShopBuy_makeItemList = Window_ShopBuy.prototype.makeItemList;
  Window_ShopBuy.prototype.makeItemList = function() {
    _Window_ShopBuy_makeItemList.call(this);
    for (var i = this._data.length - 1; i >= 0; i--) {
      var item = this._data[i];
      if (item && item.meta.matKey) {
        var materials = DataManager.getGreedShopMaterials(item);
        var keys = item.meta.matKey.split(' ').map(Number);
        for (var j = 0; j < keys.length; j++) {
          var material = materials[keys[j] - 1];
          var matItem = DataManager.materialToItem(material);
          if (!$gameParty.hasItem(matItem, false)) {
            this._data.splice(i, 1);
            this._price.splice(i, 1);
            break;
          }
        }
      }
    }
  };

  var _Window_ShopBuy_drawItem = Window_ShopBuy.prototype.drawItem;
  Window_ShopBuy.prototype.drawItem = function(index) {
    if ($gameTemp.isGreedShop() && !showPrice) {
      var item = this._data[index];
      var rect = this.itemRect(index);
      rect.width -= this.textPadding();
      this.changePaintOpacity(this.isEnabled(item));
      this.drawItemName(item, rect.x, rect.y, rect.width);
      this.changePaintOpacity(true);
    } else {
      _Window_ShopBuy_drawItem.call(this, index);
    }
  };

  Window_ShopBuy.prototype.setMaterialWindow = function(materialWindow) {
    this._materialWindow = materialWindow;
  };

  //-----------------------------------------------------------------------------
  // Window_ShopNumber
  //

  var _Window_ShopNumber_windowWidth = Window_ShopNumber.prototype.windowWidth;
  Window_ShopNumber.prototype.windowWidth = function() {
    if ($gameTemp.isGreedShop()) {
      return buyWindowWidth;
    }
    return _Window_ShopNumber_windowWidth.call(this);
  };

  var _Window_ShopNumber_refresh = Window_ShopNumber.prototype.refresh;
  Window_ShopNumber.prototype.refresh = function() {
    _Window_ShopNumber_refresh.call(this);
    if ($gameTemp.isGreedShop() && showMaterialFromNumberWindow) {
      this.drawGreedMaterials(0, this.lineHeight() * 2, this._item, this._number, fontRate);
    }
  };

  // 欲張りショップの場合は価格表示を素材リストに任せる
  var _Window_ShopNumber_drawTotalPrice = Window_ShopNumber.prototype.drawTotalPrice;
  Window_ShopNumber.prototype.drawTotalPrice = function() {
    if (!$gameTemp.isGreedShop()) {
      _Window_ShopNumber_drawTotalPrice.call(this);
    }
  };

  var _Window_ShopNumber_itemY = Window_ShopNumber.prototype.itemY;
  Window_ShopNumber.prototype.itemY = function() {
    if ($gameTemp.isGreedShop() && showMaterialFromNumberWindow) {
      return 0;
    }
    return _Window_ShopNumber_itemY.call(this);
  };

  var _Window_ShopNumber_priceY = Window_ShopNumber.prototype.priceY;
  Window_ShopNumber.prototype.priceY = function() {
    if ($gameTemp.isGreedShop() && showMaterialFromNumberWindow) {
      return this.lineHeight() * 1.5;
    }
    return _Window_ShopNumber_priceY.call(this);
  };

  var _Window_ShopNumber_buttonY = Window_ShopNumber.prototype.buttonY;
  Window_ShopNumber.prototype.buttonY = function() {
    if ($gameTemp.isGreedShop() && showMaterialFromNumberWindow) {
      return Math.min(this.priceY() + this.lineHeight() * (materialMax + 3),
                      this.contents.height - this.lineHeight());
    }
    return _Window_ShopNumber_buttonY.call(this);
  };

  //-----------------------------------------------------------------------------
  // Window_Material
  //

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

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

  Window_Material.prototype.initialize = function() {
    this._materials = [];
    var width = this.windowWidth();
    var height = this.windowHeight();
    Window_Base.prototype.initialize.call(this, 0, 0, width, height);
    this.hide();
  };

  Window_Material.prototype.windowWidth = function() {
    return materialWindowWidth;
  };

  Window_Material.prototype.windowHeight = function() {
    var n = this._materials.length;
    if (needText) {
      n += 1;
    }
    if (this._price) {
      n += 1;
    }
    return Math.floor(this.fittingHeight(n) * fontRate);
  };

  Window_Material.prototype.standardBackOpacity = function() {
    return backOpacity;
  };

  var _Window_Material_show = Window_Material.prototype.show;
  Window_Material.prototype.show = function() {
    _Window_Material_show.call(this);
    if (this._materials.length === 0) {
      this.visible = false;
    }
  };

  Window_Material.prototype.materials = function() {
    return this._materials;
  };

  Window_Material.prototype.setShopItem = function(item, price) {
    if (this._shopItem !== item) {
      this._shopItem = item;
      this._price = price;
      this._materials = DataManager.getGreedShopMaterials(item);
      if (this._materials.length > 0) {
        this.refresh();
      }
      if (showMaterialWindow) {
        this.show();
      }
    }
  };

  Window_Material.prototype.refresh = function() {
    this.move(this.x, this.y, this.width, this.windowHeight());
    this.createContents();
    this.drawGreedMaterials(0, 0, this._shopItem, 1, fontRate);
/*    for (var i = 0; i < this._materials.length; i++) {
      var material = this._materials[i];
      var item = DataManager.materialToItem(material);
      var need = material.need;
      var n = $gameParty.numItems(item);
      this.changePaintOpacity(n >= need);
      this.drawItemName(item, 0, this.lineHeight() * i);
      var text = DataManager.isConsumableMaterial(item) ? '' + n + '/' : '--/';
      text += ('   ' + need).substr(-3);
      this.drawText(text, 0, this.lineHeight() * i, this.contents.width, 'right');
    }*/
  };

  //-----------------------------------------------------------------------------
  // Scene_Shop
  //

  var _Scene_Shop_terminate = Scene_Shop.prototype.terminate;
  Scene_Shop.prototype.terminate = function() {
    _Scene_Shop_terminate.call(this);
    $gameTemp.setGreedShop(false);
  };

  var _Scene_Shop_create = Scene_Shop.prototype.create;
  Scene_Shop.prototype.create = function() {
    _Scene_Shop_create.call(this);
    if ($gameTemp.isGreedShop()) {
      this.createMaterialWindow();
    }
  };

  Scene_Shop.prototype.createMaterialWindow = function() {
    this._materialWindow = new Window_Material();
    this._buyWindow.setMaterialWindow(this._materialWindow);
    if (overlaid) {
      this.addChild(this._materialWindow);
    } else {
      this.addWindow(this._materialWindow);
    }
  };

  var _Scene_Shop_onBuyOk = Scene_Shop.prototype.onBuyOk;
  Scene_Shop.prototype.onBuyOk = function() {
    _Scene_Shop_onBuyOk.call(this);
    if (this._materialWindow) {
      this._materialWindow.hide();
    }
  };

  var _Scene_Shop_onBuyCancel = Scene_Shop.prototype.onBuyCancel;
  Scene_Shop.prototype.onBuyCancel = function() {
    _Scene_Shop_onBuyCancel.call(this);
    if (this._materialWindow) {
      this._materialWindow.setShopItem(null);
    }
  };

  var _Scene_Shop_onNumberOk = Scene_Shop.prototype.onNumberOk;
  Scene_Shop.prototype.onNumberOk = function() {
    if ($gameTemp.isGreedShop() && this._commandWindow.currentSymbol() === 'buy') {
      AudioManager.playSe(seGreedBuy);
      this.doBuy(this._numberWindow.number());
      this.endNumberInput();
      this._goldWindow.refresh();
      this._statusWindow.refresh();
    } else {
      _Scene_Shop_onNumberOk.call(this);
    }
  };

  var _Scene_Shop_doBuy = Scene_Shop.prototype.doBuy;
  Scene_Shop.prototype.doBuy = function(number) {
    _Scene_Shop_doBuy.call(this, number);
    if (this._materialWindow) {
      var materials = this._materialWindow.materials();
      for (var i = 0; i < materials.length; i++) {
        var material = materials[i];
        var item = DataManager.materialToItem(material);
        if (DataManager.isConsumableMaterial(item)) {
          $gameParty.loseItem(item, material.need * number);
        }
      }
      this._materialWindow.refresh();
    }
  };

  var _Scene_Shop_maxBuy = Scene_Shop.prototype.maxBuy;
  Scene_Shop.prototype.maxBuy = function() {
    var result = _Scene_Shop_maxBuy.call(this);
    if (this._materialWindow) {
      var materials = this._materialWindow.materials();
      for (var i = 0; i < materials.length; i++) {
        var material = materials[i];
        var item = DataManager.materialToItem(material);
        if (DataManager.isConsumableMaterial(item)) {
          var n = $gameParty.numItems(item);
          result = Math.min(result, Math.floor(n / material.need));
        }
      }
    }
    return result;
  };

  var _Scene_Shop_endNumberInput = Scene_Shop.prototype.endNumberInput;
  Scene_Shop.prototype.endNumberInput = function() {
    _Scene_Shop_endNumberInput.call(this);
    if (this._materialWindow && showMaterialWindow) {
      this._materialWindow.show();
    }
  };

})();


code:
//=============================================================================
// TMPlugin - アイテムカテゴリ拡張
// バージョン: 1.0.0
// 最終更新日: 2017/01/31
// 配布元    : http://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2017 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc アイテムカテゴリの追加、削除をおこないます。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param categoryList
 * @desc アイテムカテゴリの一覧 (詳しくはヘルプにて)
 * 初期値: item weapon armor keyItem
 * @default item weapon armor keyItem
 *
 * @help
 * TMPlugin - アイテムカレゴリ拡張 ver1.0.0
 *
 * 使い方:
 *
 *   プラグインパラメータでアイテムカテゴリを設定してください。
 *   item, weapon, armor, keyItem は アイテム, 武器, 防具, 大事なもの に
 *   対応しています。
 *   たとえばアイテムと武器の間に 書物 というカテゴリを追加したい場合は
 *   item 書物 weapon armor keyItem
 *   というような設定になります。
 *
 *   追加したカテゴリは itemCategory タグを使ってアイテムに設定することが
 *   できます。タグを設定したアイテムは通常のアイテムカテゴリには
 *   表示されなくなります。
 *
 *   また、不要なカテゴリを削除することもできます。
 *   カテゴリが 1 個しかない場合はカテゴリ選択の処理自体が省略されます。
 *
 *   プラグインコマンドはありません。
 *
 *   このプラグインは RPGツクールMV Version 1.3.4 で動作確認をしています。
 *
 *
 * メモ欄タグ（アイテム）:
 *
 *   <itemCategory:書物>
 *     このアイテムのカテゴリを 書物 に設定します。
 *     プラグインパラメータ categoryList に 書物 というカテゴリが
 *     あればそこに表示されます。
 */

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

var TMPlugin = TMPlugin || {};
TMPlugin.ItemCategoryEx = {};
TMPlugin.ItemCategoryEx.Parameters = PluginManager.parameters('TMItemCategoryEx');
TMPlugin.ItemCategoryEx.CategoryList = TMPlugin.ItemCategoryEx.Parameters['categoryList'].split(' ');

(function() {

  //-----------------------------------------------------------------------------
  // Window_ItemCategory
  //

  Window_ItemCategory.prototype.maxCols = function() {
    return TMPlugin.ItemCategoryEx.CategoryList.length;
  };

  Window_ItemCategory.prototype.makeCommandList = function() {
    for (var i = 0; i < this.maxCols(); i++) {
      var symbol = TMPlugin.ItemCategoryEx.CategoryList[i];
      if (symbol === 'item') {
        this.addCommand(TextManager.item, 'item');
      } else if (symbol === 'weapon') {
        this.addCommand(TextManager.weapon, 'weapon');
      } else if (symbol === 'armor') {
        this.addCommand(TextManager.armor, 'armor');
      } else if (symbol === 'keyItem') {
        this.addCommand(TextManager.keyItem, 'keyItem');
      } else {
        this.addCommand(symbol, symbol);
      }
    }
  };

  //-----------------------------------------------------------------------------
  // Window_ItemList
  //

  var _Window_ItemList_includes = Window_ItemList.prototype.includes;
  Window_ItemList.prototype.includes = function(item) {
    if (item && item.meta.itemCategory) return this._category === item.meta.itemCategory;
    return _Window_ItemList_includes.call(this, item);
  };

  //-----------------------------------------------------------------------------
  // Scene_Item
  //

  var _Scene_Item_create = Scene_Item.prototype.create;
  Scene_Item.prototype.create = function() {
    _Scene_Item_create.call(this);
    if (TMPlugin.ItemCategoryEx.CategoryList.length === 1) {
      this._categoryWindow.deactivate();
      this._categoryWindow.hide();
      var ww = this._itemWindow.width;
      var wh = this._itemWindow.height + this._categoryWindow.height;
      this._itemWindow.move(this._itemWindow.x, this._categoryWindow.y, ww, wh);
      this._itemWindow.setHandler('cancel', this.popScene.bind(this));
      this._itemWindow.setCategory(this._categoryWindow.currentSymbol());
      this.onCategoryOk();
    }
  };

  //-----------------------------------------------------------------------------
  // Scene_Shop
  //

  var _Scene_Shop_create = Scene_Shop.prototype.create;
  Scene_Shop.prototype.create = function() {
    _Scene_Shop_create.call(this);
    if (TMPlugin.ItemCategoryEx.CategoryList.length === 1) {
      var ww = this._sellWindow.width;
      var wh = this._sellWindow.height + this._categoryWindow.height;
      this._sellWindow.move(this._sellWindow.x, this._categoryWindow.y, ww, wh);
      this._sellWindow.setCategory(this._categoryWindow.currentSymbol());
    }
  };

  var _Scene_Shop_commandSell = Scene_Shop.prototype.commandSell;
  Scene_Shop.prototype.commandSell = function() {
    _Scene_Shop_commandSell.call(this);
    if (TMPlugin.ItemCategoryEx.CategoryList.length === 1) {
      this._sellWindow.activate();
      this._statusWindow.hide();
      this._sellWindow.select(0);
      this._categoryWindow.hide();
    }
  };

  var _Scene_Shop_onSellCancel = Scene_Shop.prototype.onSellCancel;
  Scene_Shop.prototype.onSellCancel = function() {
    _Scene_Shop_onSellCancel.call(this);
    if (TMPlugin.ItemCategoryEx.CategoryList.length === 1) {
      this.onCategoryCancel();
    }
  };

})();


code:
//=============================================================================
// TMPlugin - リンククレジット
// バージョン: 3.0.0
// 最終更新日: 2019/04/17
// 配布元　　: https://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc タイトル画面にクレジットコマンドを追加します。
 * 制作スタッフの紹介をWebサイトへのリンク付きで表示できます。
 *
 * @author tomoaky (https://hikimoki.sakura.ne.jp/)
 *
 * @param credits
 * @type struct<Credit>[]
 * @desc クレジットのデータ
 * @default ["{\"name\":\"名前\",\"help\":\"説明\",\"url\":\"アドレス\"}"]
 *
 * @param versionText
 * @type struct<TitleText>
 * @desc タイトル画面に表示するバージョンテキスト
 * @default {"text":"ver1.0.0","x":"0","y":"0","fontSize":"24","textColor":"#ffffff","outlineWidth":"4","outlineColor":"#000000"}
 *
 * @param licenseText
 * @type struct<TitleText>
 * @desc タイトル画面に表示する著作者情報テキスト
 * @default {"text":"©著作者名 2019","x":"0","y":"592","fontSize":"24","textColor":"#ffffff","outlineWidth":"4","outlineColor":"#000000"}
 *
 * @param creditsCommand
 * @desc タイトルメニューに表示するコマンド名
 * 未設定の場合、クレジットコマンドは表示されません。
 * @default クレジット
 *
 * @param itemHeight
 * @type number
 * @desc ひとつの要素を表示する領域の高さ
 * 初期値: 84
 * @default 84
 *
 * @param helpFontSize
 * @type number
 * @desc 説明表示のフォントサイズ
 * 初期値: 16 ( 0 で説明が非表示になります )
 * @default 16
 *
 * @param urlFontSize
 * @type number
 * @desc アドレス表示のフォントサイズ
 * 初期値: 16 ( 0 でアドレスが非表示になります )
 * @default 16
 *
 * @param urlMaxLength
 * @type number
 * @desc アドレスの最大文字数
 * @default 50
 *
 * @param useHelpWindow
 * @desc ヘルプウィンドウを使うかどうか
 * 初期値: ON ( true = ON 表示 / false = OFF 非表示 )
 * @default true
 *
 * @param helpWindowText
 * @desc ヘルプウィンドウに表示するテキスト ( \n で改行 )
 * 未設定の場合はリンク先Webサイトの説明が表示されます。
 * @default 選択したサイトを開くことができます。\n（ブラウザがポップアップを禁止していると機能しません）
 *
 * @param titleCommandAlign
 * @type select
 * @option left
 * @option center
 * @option right
 * @desc タイトルコマンドのアライメント
 * @default center
 *
 * @help
 * 使い方:
 * TMPlugin - リンククレジット Ver3.0.0
 *
 *   プラグインパラメータ credits に、リンク先Webサイトの情報を
 *   設定してください。
 *   この情報は名前、説明、アドレス、という３つの要素で構成され、
 *   必要な数だけ追加することができます。
 *
 *   ブラウザ側でポップアップが制限されている環境では、リンク機能が
 *   動作しません。
 *
 *   RPGアツマールで実行される場合はアツマールのAPIを利用して
 *   リンク先を開きます。
 *
 *   タイトル画面に著作権情報とバージョン情報を表示する機能もあります、
 *   こちらもプラグインパラメータで文字色や表示位置を調整することが可能です。
 *
 *   このプラグインは RPGツクールMV Version 1.6.1 で動作確認をしています。
 *
 *   このプラグインはMITライセンスのもとに配布しています、商用利用、
 *   改造、再配布など、自由にお使いいただけます。
 *
 *
 * プラグインコマンド:
 *
 *   callCredit
 *     クレジットシーンを呼び出します。
 *
 *
 * プラグインパラメータ補足:
 *
 *   credits
 *     name と help は、制御文字を使って文字色を変更したり、アイコンを
 *     表示することができます。
 *     help は \n があるところで改行されます。
 *
 *   versionText / licenseText
 *     textColor と outlineColor は、black や blue のような色名と、
 *     #000000 や #0000ff のようなカラーコードで指定できます。
 */
/*~struct~Credit:
 *
 * @param name
 * @desc リンク先Webサイトの名前
 * @default
 *
 * @param help
 * @desc リンク先Webサイトの説明
 * @default
 *
 * @param url
 * @desc リンク先Webサイトのアドレス
 * @default
 */
/*~struct~TitleText:
 *
 * @param text
 * @desc 表示するテキスト
 * @default
 *
 * @param x
 * @type number
 * @desc テキストを表示するＸ座標
 * @default 0
 *
 * @param y
 * @type number
 * @desc テキストを表示するＹ座標
 * @default 0
 *
 * @param fontSize
 * @type number
 * @desc テキストのフォントサイズ
 * @default 24
 *
 * @param textColor
 * @desc テキストの文字色
 * @default #ffffff
 *
 * @param outlineWidth
 * @type number
 * @desc テキストの縁取りサイズ
 * @default 4
 *
 * @param outlineColor
 * @desc テキストの縁取り色
 * @default #000000
 */

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

(function() {

	var parameters = PluginManager.parameters('TMLinkCredit');
	var credits = JSON.parse(parameters['credits'] || '[]').map(JSON.parse);
	var versionText = JSON.parse(parameters['versionText'] || '{}');
	var licenseText = JSON.parse(parameters['licenseText'] || '{}');
	var creditsCommand = parameters['creditsCommand'];
	var itemHeight = +(parameters['itemHeight'] || 84);
	var helpFontSize = +(parameters['helpFontSize'] || 16);
	var urlFontSize = +(parameters['urlFontSize'] || 16);
	var urlMaxLength = +(parameters['urlMaxLength'] || 50);
	var useHelpWindow = JSON.parse(parameters['useHelpWindow'] || 'true');
	var helpWindowText = parameters['helpWindowText'].replace(/\\n/g, '\n');
	var titleCommandAlign = parameters['titleCommandAlign'] || 'center';

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

	var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
	Game_Interpreter.prototype.pluginCommand = function(command, args) {
		_Game_Interpreter_pluginCommand.call(this, command, args);
		if (command === 'callCredit') {
			SceneManager.push(Scene_Credits);
		}
	};

	//-----------------------------------------------------------------------------
	// Window_TitleCommand
	//

	var _Window_TitleCommand_makeCommandList = Window_TitleCommand.prototype.makeCommandList;
	Window_TitleCommand.prototype.makeCommandList = function() {
		_Window_TitleCommand_makeCommandList.call(this);
		if (creditsCommand) {
			this.addCommand(creditsCommand, 'credits');
		}
	};

	var _Window_TitleCommand_itemTextAlign = Window_TitleCommand.prototype.itemTextAlign;
	Window_TitleCommand.prototype.itemTextAlign = function() {
		return titleCommandAlign || _Window_TitleCommand_itemTextAlign.call(this);
	};

	//-----------------------------------------------------------------------------
	// Window_Credits
	//

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

	Window_Credits.prototype = Object.create(Window_Selectable.prototype);
	Window_Credits.prototype.constructor = Window_Credits;

	Window_Credits.prototype.initialize = function(x, y, width, height) {
		Window_Selectable.prototype.initialize.call(this, x, y, width, height);
		this.refresh();
		this.select(0);
		this.activate();
	};

	var _Window_Credits_standardFontSize = Window_Credits.prototype.standardFontSize;
	Window_Credits.prototype.standardFontSize = function() {
		return this._standardFontSize || _Window_Credits_standardFontSize.call(this);
	};

	Window_Credits.prototype.itemHeight = function() {
		return itemHeight;
	};

	Window_Credits.prototype.maxItems = function() {
		return credits.length || 1;
	};

	Window_Credits.prototype.item = function() {
		return index >= 0 ? credits[this.index()] : null;
	};

	Window_Credits.prototype.drawItem = function(index) {
		var item = credits[index];
		if (item) {
			var rect = this.itemRectForText(index);
			var lineHeight = this.lineHeight();
			this.resetFontSettings();
			this.drawTextEx(item.name, rect.x, rect.y);
			if (urlFontSize > 0) {
				this.resetFontSettings();
				this.contents.fontSize = urlFontSize;
				var urlLineNums = Math.floor(this.itemHeight() / urlFontSize);
				for (var i = 0; i < urlLineNums; i++) {
					var urlIndex = urlMaxLength * i;
					if (urlIndex >= item.url.length) {
						break;
					}
					var y = rect.y + urlFontSize * i;
					this.contents.drawText(item.url.substr(urlIndex, urlMaxLength), rect.x, y, rect.width, lineHeight, 'right');
				}
			}
			if (helpFontSize > 0) {
				this._standardFontSize = helpFontSize;
				this.resetFontSettings();
				this.drawTextEx(item.help.replace(/\\n/g, '\n'), rect.x, rect.y + lineHeight);
				this._standardFontSize = null;
			}
		}
	};

	Window_Credits.prototype.updateHelp = function() {
		var text = helpWindowText || credits[this.index()].help;
		this._helpWindow.setText(text);
	};

	Window_Credits.prototype.urlOpen = function() {
		if (window.RPGAtsumaru && window.RPGAtsumaru.popups.openLink) {
			window.RPGAtsumaru.popups.openLink(credits[this.index()].url);
		} else {
			window.open(credits[this.index()].url, '_blank');
		}
	};

	//-----------------------------------------------------------------------------
	// Scene_Title
	//

	var _Scene_Title_createCommandWindow = Scene_Title.prototype.createCommandWindow;
	Scene_Title.prototype.createCommandWindow = function() {
		_Scene_Title_createCommandWindow.call(this);
		this._commandWindow.setHandler('credits', this.commandCredits.bind(this));
	};

	Scene_Title.prototype.commandCredits = function() {
		this._commandWindow.close();
		SceneManager.push(Scene_Credits);
	};

	var _Scene_Title_createForeground = Scene_Title.prototype.createForeground;
	Scene_Title.prototype.createForeground = function() {
		_Scene_Title_createForeground.call(this);
		if (versionText.text) {
			this.drawTitleText(versionText);
		}
		if (licenseText.text) {
			this.drawTitleText(licenseText);
		}
	};

	Scene_Title.prototype.drawTitleText = function(titleText) {
		var x = +titleText.x;
		var y = +titleText.y;
		var fontSize = +titleText.fontSize;
		var outlineWidth = +titleText.outlineWidth;
		var textHeight = fontSize + outlineWidth * 2;
		var maxWidth = Graphics.width - x - outlineWidth;
		this._gameTitleSprite.bitmap.fontSize = fontSize;
		this._gameTitleSprite.bitmap.outlineWidth = outlineWidth;
		this._gameTitleSprite.bitmap.textColor = titleText.textColor;
		this._gameTitleSprite.bitmap.outlineColor = titleText.outlineColor;
		this._gameTitleSprite.bitmap.drawText(titleText.text, x + outlineWidth, y, maxWidth, textHeight, 'left');
	};

	//-----------------------------------------------------------------------------
	// Scene_Credits
	//

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

	Scene_Credits.prototype = Object.create(Scene_MenuBase.prototype);
	Scene_Credits.prototype.constructor = Scene_Credits;

	Scene_Credits.prototype.initialize = function() {
		Scene_MenuBase.prototype.initialize.call(this);
	};

	Scene_Credits.prototype.create = function() {
		Scene_MenuBase.prototype.create.call(this);
		if (useHelpWindow) {
			this.createHelpWindow();
		}
		this.createCreditsWindow();
	};

	Scene_Credits.prototype.createCreditsWindow = function() {
		var wy = 0;
		var wh = Graphics.boxHeight;
		if (this._helpWindow) {
			wy = this._helpWindow.height;
			wh -= this._helpWindow.height;
		}
		this._creditsWindow = new Window_Credits(0, wy, Graphics.boxWidth, wh);
		this._creditsWindow.setHandler('ok', this.onCreditsOk.bind(this));
		this._creditsWindow.setHandler('cancel', this.popScene.bind(this));
		if (this._helpWindow) {
			this._creditsWindow.setHelpWindow(this._helpWindow);
		}
		this.addWindow(this._creditsWindow);
	};

	Scene_Credits.prototype.onCreditsOk = function() {
		this._creditsWindow.urlOpen();
		this._creditsWindow.activate();
	};

})();


code:
//=============================================================================
// TMPlugin - ログウィンドウ
// バージョン: 1.1.1
// 最終更新日: 2019/03/11
// 配布元    : https://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2017 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc マップシーンにログウィンドウを表示します。
 *
 * @author tomoaky (https://hikimoki.sakura.ne.jp/)
 *
 * @param logWindowX
 * @type number
 * @min -1000
 * @desc ログウィンドウの X 座標。
 * 初期値: 0
 * @default 0
 *
 * @param logWindowY
 * @type number
 * @min -1000
 * @desc ログウィンドウの Y 座標。
 * 初期値: 460
 * @default 460
 *
 * @param logWindowWidth
 * @type number
 * @desc ログウィンドウの幅。
 * 初期値: 480
 * @default 480
 *
 * @param lines
 * @type number
 * @desc ログウィンドウの行数。
 * 初期値: 6
 * @default 6
 *
 * @param lineHeight
 * @type number
 * @desc ログウィンドウの１行の高さ。
 * 初期値: 24
 * @default 24
 *
 * @param padding
 * @type number
 * @desc ログウィンドウの余白の大きさ。
 * 初期値: 10
 * @default 10
 *
 * @param fontSize
 * @type number
 * @desc ログウィンドウのフォントサイズ。
 * 初期値: 20
 * @default 20
 *
 * @param startVisible
 * @type boolean
 * @desc ゲーム開始時の表示状態。
 * 初期値: ON（ true = ON 表示 / false = OFF 非表示 )
 * @default true
 *
 * @param opacity
 * @type number
 * @max 255
 * @desc ウィンドウフレームと背景の不透明度。
 * 初期値: 255 ( 0 ～ 255 )
 * @default 255
 *
 * @param collideOpacity
 * @type number
 * @max 255
 * @desc プレイヤーと重なったときの不透明度。
 * 初期値: 128（ 0 ～ 255 ）
 * @default 128
 *
 * @param messageBusyHide
 * @type boolean
 * @desc メッセージウィンドウ表示中はログウィンドウを隠す。
 * 初期値: ON（ true = ON 隠す / false = OFF 隠さない )
 * @default true
 *
 * @param eventBusyHide
 * @type boolean
 * @desc イベント起動中はログウィンドウを隠す。
 * 初期値: ON（ true = ON 隠す / false = OFF 隠さない )
 * @default true
 *
 * @param maxLogs
 * @type number
 * @desc 保存するログの最大行数。
 * 初期値: 30
 * @default 30
 *
 * @param autoDelete
 * @type variable
 * @desc 指定したゲーム変数に代入された値の間隔で、自動的にテキストを
 * 削除する。単位はフレーム数（ 60フレーム = 1秒 ）
 * @default 0
 *
 * @help
 * TMPlugin - ログウィンドウ ver1.1.1
 *
 * 使い方:
 *
 *   プラグインを導入するとマップシーンにログウィンドウが追加されます。
 *   プラグインコマンドを使って手動で書き込むか、転記モードで
 *   自動的に書き込むことでログウィンドウにテキストを表示できます。
 *
 *   このプラグインは RPGツクールMV Version 1.6.1 で動作確認をしています。
 *
 *   このプラグインはMITライセンスのもとに配布しています、商用利用、
 *   改造、再配布など、自由にお使いいただけます。
 *
 *
 * プラグインコマンド:
 *
 *   showLogWindow
 *     ログウィンドウを表示する。
 *
 *   hideLogWindow
 *     ログウィンドウを隠す。
 *
 *   addLog テキスト
 *     テキストをログウィンドウに追加する。
 *     一部の制御文字も使えます（\V[n], \N[n], \P[n], \G, \C[n]）
 *
 *   deleteLog
 *     一番古いテキストをひとつ削除する。
 *
 *   startMirrorLogWindow
 *     イベントコマンド『文章の表示』をトレースする転記モードを有効化。
 *
 *   stopMirrorLogWindow
 *     startMirrorLogWindow で有効化した機能を無効化します。
 *
 *   startAutoLogWindow
 *     『TMJumpAction.js』などの対応プラグインと併用した場合に
 *     敵撃破時の報酬情報を自動でログに追記する機能を有効化します。
 *     この機能はゲーム開始時には自動的にオンになっています。
 *
 *   stopAutoLogWindow
 *     startAutoLogWindow で有効化した機能を無効化します。
 *
 *   openLogScene
 *     ログ確認シーンへ移行します。
 *
 *
 * プラグインパラメータ補足:
 *
 *   padding
 *     テキストの表示領域とウィンドウフレーム外側までのドット数です。
 *     ウィンドウの高さ（縦方向の大きさ）は以下の式で算出されます。
 *     １行の高さ(lineHeight) * 行数(lines) + 余白(padding) * 2
 *     画面の下部ぴったりにウィンドウを表示したい場合は縦方向の
 *     画面サイズから上記の式の結果を引いた値を logWindowY に
 *     設定してください。
 *
 *   collideOpacity
 *     opacity よりも大きい値を設定した場合、ログの内容には
 *     collideOpacity を適用し、ウィンドウフレームと背景には
 *     opacity を適用します。
 *
 *   autoDelete
 *     指定したゲーム変数の値が 0 の場合は、自動削除の機能が
 *     停止します。
 */

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

(function() {

	parameters = PluginManager.parameters('TMLogWindow');
	logWindowX = +(parameters['logWindowX'] || 0);
	logWindowY = +(parameters['logWindowY'] || 464);
	logWindowWidth = +(parameters['logWindowWidth'] || 480);
	logWindowLines = +(parameters['lines'] || 6);
	logWindowLineHeight = +(parameters['lineHeight'] || 24);
	logWindowPadding = +(parameters['padding'] || 10);
	logWindowFontSize = +(parameters['fontSize'] || 20);
	logWindowStartVisible = JSON.parse(parameters['startVisible']);
	logWindowOpacity = +(parameters['opacity'] || 255);
	logWindowCollideOpacity = +(parameters['collideOpacity'] || 128);
	logWindowMessageBusyHide = JSON.parse(parameters['messageBusyHide']);
	logWindowEventBusyHide = JSON.parse(parameters['eventBusyHide']);
	logWindowMaxLogs = +(parameters['maxLogs'] || 20);
	logWindowAutoDelete = +(parameters['autoDelete'] || 0);

	//-----------------------------------------------------------------------------
	// Game_Temp
	//

	Game_Temp.prototype.dummyWindow = function() {
		if (!this._dummyWindow) {
			this._dummyWindow = new Window_Base(0, 0, 64, 64);
		}
		return this._dummyWindow;
	};

	//-----------------------------------------------------------------------------
	// Game_System
	//

	var _Game_System_initialize = Game_System.prototype.initialize;
	Game_System.prototype.initialize = function() {
		_Game_System_initialize.call(this);
		this._visibleLogWindow = logWindowStartVisible;
		this._mirrorLogWindow = false;
		this._autoLogWindow = true;
		this._actionLog = [];
	};

	Game_System.prototype.isVisibleLogWindow = function() {
		return this._visibleLogWindow;
	};

	Game_System.prototype.isMirrorLogWindow = function() {
		return this._mirrorLogWindow;
	};

	Game_System.prototype.isAutoLogWindow = function() {
		return this._autoLogWindow;
	};

	Game_System.prototype.setVisibleLogWindow = function(visible) {
		this._visibleLogWindow = visible;
	};

	Game_System.prototype.setMirrorMode = function(flag) {
		this._mirrorLogWindow = flag;
	};

	Game_System.prototype.setAutoMode = function(flag) {
		this._autoLogWindow = flag;
	};

	Game_System.prototype.addLog = function(text) {
		text = $gameTemp.dummyWindow().convertEscapeCharacters(text);
		this._actionLog.push(text);
		if (this._actionLog.length > logWindowMaxLogs) {
			this._actionLog.shift();
		}
		this._needsActionLogRefresh = true;
	};

	Game_System.prototype.deleteLog = function() {
		if (this._actionLog.length > 0) {
			this._actionLog.shift();
			this._needsActionLogRefresh = true;
		}
	};

	Game_System.prototype.actionLog = function() {
		return this._actionLog;
	};

	//-----------------------------------------------------------------------------
	// Game_Message
	//

	var _Game_Message_add = Game_Message.prototype.add;
	Game_Message.prototype.add = function(text) {
		_Game_Message_add.call(this, text);
		if ($gameSystem.isMirrorLogWindow()) {
			$gameSystem.addLog(text);
		}
	};

	//-----------------------------------------------------------------------------
	// Game_Actor
	//

	// レベルアップの表示
	var _Game_Actor_displayLevelUp = Game_Actor.prototype.displayLevelUp;
	Game_Actor.prototype.displayLevelUp = function(newSkills) {
		_Game_Actor_displayLevelUp.call(this, newSkills);
		if ($gameSystem.isAutoLogWindow() && !$gameParty.inBattle()) {
			var text = TextManager.levelUp.format(this._name, TextManager.level, this._level);
			$gameSystem.addLog(text);
		}
	};

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

	var _Game_Event_gainRewards = Game_Event.prototype.gainRewards;
	Game_Event.prototype.gainRewards = function() {
		if ($gameSystem.isAutoLogWindow()) {
			var battler = this.battler();
			var exp = battler.exp();
			var gold = battler.gold();
			var text = battler.name() + $dataStates[battler.deathStateId()].message2;
			var rewardText = '';
			if (exp > 0) {
				rewardText += '' + exp + '\\C[16]' + TextManager.expA + '\\C[0]';
			}
			if (gold > 0) {
				if (exp > 0) {
					rewardText += ' / ';
				}
				rewardText += '' + gold + '\\C[16]' + TextManager.currencyUnit + '\\C[0]';
			}
			if (rewardText) {
				text += ' ( ' + rewardText + ' )';
			}
			$gameSystem.addLog(text)
		}
		_Game_Event_gainRewards.call(this);
	};

	var _Game_Event_gainRewardItem = Game_Event.prototype.gainRewardItem;
	Game_Event.prototype.gainRewardItem = function(item, y) {
		_Game_Event_gainRewardItem.call(this, item, y);
		if ($gameSystem.isAutoLogWindow()) {
			var text = TextManager.obtainItem.format(item.name);
			$gameSystem.addLog(text);
		}
	};

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

	// プラグインコマンド
	var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
	Game_Interpreter.prototype.pluginCommand = function(command, args) {
		_Game_Interpreter_pluginCommand.call(this, command, args);
		if (command === 'showLogWindow') {
			$gameSystem.setVisibleLogWindow(true);
		} else if (command === 'hideLogWindow') {
			$gameSystem.setVisibleLogWindow(false);
		} else if (command === 'addLog') {
			$gameSystem.addLog(args[0]);
		} else if (command === 'deleteLog') {
			$gameSystem.deleteLog();
		} else if (command === 'startMirrorLogWindow') {
			$gameSystem.setMirrorMode(true);
		} else if (command === 'stopMirrorLogWindow') {
			$gameSystem.setMirrorMode(false);
		} else if (command === 'startAutoLogWindow') {
			$gameSystem.setAutoMode(true);
		} else if (command === 'stopAutoLogWindow') {
			$gameSystem.setAutoMode(false);
		} else if (command === 'openLogScene') {
			SceneManager.push(Scene_Log);
		}
	};

	//-----------------------------------------------------------------------------
	// Window_MapLog
	//

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

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

	Window_MapLog.prototype.initialize = function() {
		var x = logWindowX;
		var y = logWindowY;
		var wight = this.windowWidth();
		var height = this.windowHeight();
		Window_Base.prototype.initialize.call(this, x, y, wight, height);
		this.openness = $gameSystem.isVisibleLogWindow() ? 255 : 0;
		this.opacity = 255;
		this.contentsOpacity = 255;
		this._hideCount = 0;
		this._autoDeleteCount = 0;
		this.refresh();
	};

	Window_MapLog.prototype.standardFontSize = function() {
		return logWindowFontSize;
	};

	// ウィンドウの幅を取得
	Window_MapLog.prototype.windowWidth = function() {
		return logWindowWidth;
	};

	// ウィンドウの高さを取得
	Window_MapLog.prototype.windowHeight = function() {
		return this.fittingHeight(logWindowLines);
	};

	// 標準パディングを取得
	Window_MapLog.prototype.standardPadding = function() {
		return logWindowPadding;
	};

	// ウィンドウの１行の高さを取得
	Window_MapLog.prototype.lineHeight = function() {
		return logWindowLineHeight;
	};

	// フレーム更新
	Window_MapLog.prototype.update = function() {
		Window_Base.prototype.update.call(this);
		if (logWindowAutoDelete > 0) {
			var maxCount = $gameVariables.value(logWindowAutoDelete);
			if (maxCount > 0) {
				var actionLog = $gameSystem.actionLog();
				if (actionLog.length > 0) {
					this._autoDeleteCount++;
				}
				if (this._autoDeleteCount >= maxCount) {
					$gameSystem.deleteLog();
					this._autoDeleteCount = 0;
				}
			}
		}
		if (this.updateVisibility()) {
			this.open();
			if ($gameSystem._needsActionLogRefresh) {
				this.refresh();
				$gameSystem._needsActionLogRefresh = false;
			}
			this.updateOpacity();
		} else {
			this.close();
		}
	};

	// ウィンドウ表示状態の更新
	Window_MapLog.prototype.updateVisibility = function() {
		if (!$gameSystem.isVisibleLogWindow()) {
			return false;
		}
		if ((logWindowEventBusyHide && $gameMap.isEventRunning()) ||
				(logWindowMessageBusyHide && $gameMessage.isBusy())) {
			this._hideCount++;
		} else {
			this._hideCount = 0;
		}
		return this._hideCount < 10;
	};

	// 不透明度の更新
	Window_MapLog.prototype.updateOpacity = function() {
		if (this.x < $gamePlayer.screenX() + 24 &&
				this.x + this.windowWidth() > $gamePlayer.screenX() - 24 &&
				this.y < $gamePlayer.screenY() &&
				this.y + this.windowHeight() > $gamePlayer.screenY() - 48) {
			this.opacity = Math.min(logWindowCollideOpacity, logWindowOpacity);
			this.contentsOpacity = logWindowCollideOpacity;
		} else {
			this.opacity = logWindowOpacity;
			this.contentsOpacity = 255;
		}
	};

	// リフレッシュ
	Window_MapLog.prototype.refresh = function() {
		this.contents.clear();
		var actionLog = $gameSystem.actionLog();
		var lh = this.lineHeight();
		var n = Math.min(logWindowLines, actionLog.length);
		for (var i = 0; i < n; i++) {
			this.drawTextEx(actionLog[actionLog.length - n + i], 0, lh * i);
		}
	};

	//-----------------------------------------------------------------------------
	// Window_MenuLog
	//

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

	Window_MenuLog.prototype = Object.create(Window_Selectable.prototype);
	Window_MenuLog.prototype.constructor = Window_MenuLog;

	Window_MenuLog.prototype.initialize = function() {
		Window_Selectable.prototype.initialize.call(this, 0, 0, Graphics.boxWidth, Graphics.boxHeight);
		this._data = $gameSystem.actionLog();
		this.refresh();
		this.select(Math.max(this._data.length - 1, 0));
		this.activate();
	};

	Window_MenuLog.prototype.standardFontSize = function() {
		return logWindowFontSize;
	};

	Window_MenuLog.prototype.standardPadding = function() {
		return logWindowPadding;
	};

	Window_MenuLog.prototype.lineHeight = function() {
		return logWindowLineHeight;
	};

	Window_MenuLog.prototype.maxItems = function() {
		return this._data ? this._data.length : 1;
	};

	Window_MenuLog.prototype.item = function() {
		var index = this.index();
		return this._data && index >= 0 ? this._data[index] : null;
	};

	Window_MenuLog.prototype.drawItem = function(index) {
		var item = this._data[index];
		if (item) {
			var rect = this.itemRectForText(index);
			this.drawTextEx(item, 0, rect.y);
		}
	};

	//-----------------------------------------------------------------------------
	// Scene_Map
	//

	var _Scene_Map_createDisplayObjects = Scene_Map.prototype.createDisplayObjects;
	Scene_Map.prototype.createDisplayObjects = function() {
		_Scene_Map_createDisplayObjects.call(this);
		this.createMapLogWindow();
	};

	// ログウィンドウの作成
	Scene_Map.prototype.createMapLogWindow = function() {
		this._mapLogWindow = new Window_MapLog();
		this.addChild(this._mapLogWindow);
	};

	var _Scene_Map_terminate = Scene_Map.prototype.terminate;
	Scene_Map.prototype.terminate = function() {
		if (!SceneManager.isNextScene(Scene_Battle)) {
			this._mapLogWindow.hide();
		}
		_Scene_Map_terminate.call(this);
	};

	var _Scene_Map_launchBattle = Scene_Map.prototype.launchBattle;
	Scene_Map.prototype.launchBattle = function() {
		this._mapLogWindow.hide();
		this.removeChild(this._mapLogWindow);
		this._mapLogWindow = null;
		_Scene_Map_launchBattle.call(this);
	};

	//-----------------------------------------------------------------------------
	// Scene_Log
	//

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

	Scene_Log.prototype = Object.create(Scene_MenuBase.prototype);
	Scene_Log.prototype.constructor = Scene_Log;

	Scene_Log.prototype.initialize = function() {
		Scene_MenuBase.prototype.initialize.call(this);
	};

	Scene_Log.prototype.create = function() {
		Scene_MenuBase.prototype.create.call(this);
		this.createCreditsWindow();
	};

	Scene_Log.prototype.createCreditsWindow = function() {
		this._logWindow = new Window_MenuLog();
		this._logWindow.setHandler('ok', this.popScene.bind(this));
		this._logWindow.setHandler('cancel', this.popScene.bind(this));
		this.addWindow(this._logWindow);
	};

})();