code:
//=============================================================================
// TMVplugin - カードアイテム
// 作者: tomoaky (http://hikimoki.sakura.ne.jp/)
// Version: 0.11b
// 最終更新日: 2016/04/05
//=============================================================================

/*:
 * @plugindesc 指定したアイテムをカードのように扇状に広げて表示します。
 * カードの画像が別途必要になります。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param maxCardCols
 * @desc 一度に広げられるカードの枚数
 * 初期値: 8
 * @default 8
 *
 * @param cardSpacing
 * @desc カードとカードの間隔（3.141592 で約90度）
 * 初期値: 0.2
 * @default 0.2
 *
 * @param arrowSpacing
 * @desc 矢印とカードの間隔（3.141592 で約90度）
 * 初期値: 0.2
 * @default 0.2
 *
 * @param baseX
 * @desc カードの位置（扇の中心のＸ座標）
 * 初期値: 408
 * @default 408

 * @param baseY
 * @desc カードの位置（扇の中心のＹ座標）
 * 初期値: 880
 * @default 880

 * @param baseDistance
 * @desc カードの位置（扇の中心からの距離）
 * 初期値: 408
 * @default 408

 * @param shiftRadian
 * @desc 扇の回転補正値（3.141592 で約90度）
 * 初期値: 0
 * @default 0

 * @param selectedDistance
 * @desc 選択中カードの位置（扇の中心からの距離）
 * 初期値: 472
 * @default 472

 * @param cardSpeed
 * @desc カードの移動速度（扇の中心から外への移動）
 * 初期値: 24
 * @default 24

 * @param cardSpeedR
 * @desc カードの移動速度（扇を中心に回る移動）
 * 初期値: 0.05
 * @default 0.05

 * @param useHelpWindow
 * @desc ヘルプウィンドウを利用する（ 0 で無効 / 1 で有効）
 * 初期値: 1
 * @default 1

 * @param helpWindowY
 * @desc ヘルプウィンドウのＹ座標
 * 初期値: 0
 * @default 0

 * @param showItemName
 * @desc ヘルプウィンドウにアイテム名を表示（ 0 で無効 / 1 で有効）
 * 初期値: 1
 * @default 1

 * @param numsFormat
 * @desc 個数表示の書式
 * 初期値: ×\d
 * @default ×\d

 * @param blankMessage
 * @desc カードがないときに表示するメッセージ（ \n で改行）
 * 初期値: アイテムがありません。
 * @default アイテムがありません。

 * @param useGoldWindow
 * @desc 所持金ウィンドウを利用する（ 0 で無効 / 1 で有効）
 * 初期値: 0
 * @default 0

 * @param goldWindowX
 * @desc 所持金ウィンドウのＸ座標
 * 初期値: 0
 * @default 0

 * @param goldWindowY
 * @desc 所持金ウィンドウのＹ座標
 * 初期値: 144
 * @default 144

 * @param useWrap
 * @desc 先頭と末尾をカーソル移動できる（ 0 で無効 / 1 で有効）
 * 初期値: 1
 * @default 1

 * @param takeoverMainMenu
 * @desc メインメニューの乗っ取る（ 0 で無効 / 1 で有効）
 * 初期値: 0
 * @default 0

 * @noteParam picture
 * @noteRequire 1
 * @noteDir img/pictures/
 * @noteType file
 * @noteData items

 * @help
 * 準備:
 *   アイテムのメモに <picture:ファイル名> と書き込んでください。
 *   次に img/pictures フォルダに書き込んだファイル名と同名の画像を
 *   置いてください。
 *   <picture:card0> と書き込んだ場合は card0.png という画像が必要になります。
 *
 * 使い方:
 *   プラグインコマンドで cardItemScene を実行すると、所持アイテムの中で
 *   picture タグを書き込んだアイテムがカードアイテムとして一覧表示されます。
 *   表示のされかた以外は普通のアイテムシーンとほぼ同じです。
 *
 *   プラグインパラメータの初期設定は幅128ドット、高さ176ドットのカード画像を
 *   使用する想定で設定されています。お好みで調整してください。
 *
 * プラグインコマンド:
 *   cardItemScene        # カードアイテムメニューをひらく
 *
 */

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

(function () {

  var parameters = PluginManager.parameters('TMCardItem');
  var maxCardCols = +parameters['maxCardCols'];
  var cardSpacing = +parameters['cardSpacing'];
  var arrowSpacing = +parameters['arrowSpacing'];
  var baseX = +parameters['baseX'];
  var baseY = +parameters['baseY'];
  var baseDistance = +parameters['baseDistance'];
  var shiftRadian = +parameters['shiftRadian'];
  var selectedDistance = +parameters['selectedDistance'];
  var cardSpeed = +parameters['cardSpeed'];
  var cardSpeedR = +parameters['cardSpeedR'];
  var useHelpWindow = parameters['useHelpWindow'] === '1' ? true : false;
  var helpWindowY = +parameters['helpWindowY'];
  var showItemName = parameters['showItemName'] === '1' ? true : false;
  var numsFormat = parameters['numsFormat'];
  var useGoldWindow = parameters['useGoldWindow'] === '1' ? true : false;
  var goldWindowX = +parameters['goldWindowX'];
  var goldWindowY = +parameters['goldWindowY'];
  var useWrap = parameters['useWrap'] === '1' ? true : false;
  var takeoverMainMenu = parameters['takeoverMainMenu'] === '1' ? true : false;
  var blankMessage = parameters['blankMessage'];

  //-----------------------------------------------------------------------------
  // 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 === 'cardItemScene') {
      SceneManager.push(Scene_CardItem);
    }
  };

  //-----------------------------------------------------------------------------
  // Sprite_CardItem
  //

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

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

  Sprite_CardItem.prototype.initialize = function () {
    Sprite.prototype.initialize.call(this);
    this.anchor.x = 0.5;
    this.anchor.y = 1.0;
  };

  Sprite_CardItem.prototype.setup = function (index, item) {
    this._index = index;
    this._item = item
    this.bitmap = ImageManager.loadPicture(item.meta.picture);
    this._currentRot = -Math.PI / 2;
    this._targetRot = this._currentRot;
    this._currentDist = 0;
    this._targetDist = baseDistance;
    this.opacity = 128;
  };

  Sprite_CardItem.prototype.setTargetRotation = function (radian) {
    this._targetRot = radian;
  };

  Sprite_CardItem.prototype.refreshRotation = function () {
    this._currentRot = this._targetRot;
  };

  Sprite_CardItem.prototype.update = function () {
    Sprite.prototype.update.call(this);
    this.updateMove();
    this.updateOpacity();
  };

  Sprite_CardItem.prototype.updateMove = function () {
    if (this._currentRot < this._targetRot) {
      this._currentRot = Math.min(this._currentRot + cardSpeedR, this._targetRot);
    } else if (this._currentRot > this._targetRot) {
      this._currentRot = Math.max(this._currentRot - cardSpeedR, this._targetRot);
    }
    this.updateDistance();
    var r = this._currentRot + shiftRadian;
    this.rotation = r + Math.PI / 2;
    this.x = Math.cos(r) * this._currentDist + baseX;
    this.y = Math.sin(r) * this._currentDist + baseY;
  };

  Sprite_CardItem.prototype.updateOpacity = function () {
    if ($gameParty.numItems(this._item) === 0) {
      this.setColorTone([0, 0, 0, 255]);
    } else {
      this.opacity += 8;
    }
  };
  Sprite_CardItem.prototype.updateDistance = function () {
    if (this.parent && this.parent.index() === this._index) {
      this._targetDist = selectedDistance;
    } else {
      this._targetDist = baseDistance;
    }
    if (this._currentDist < this._targetDist) {
      this._currentDist = Math.min(this._currentDist + cardSpeed, this._targetDist);
    } else if (this._currentDist > this._targetDist) {
      this._currentDist = Math.max(this._currentDist - cardSpeed, this._targetDist);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_CardItemList
  //

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

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

  Window_CardItemList.prototype.initialize = function () {
    Window_Selectable.prototype.initialize.call(this, 0, 0, 0, 0);
    this.activate();
    this.makeItemList();
    this.selectLast();
    this.initCardSprites();
  };

  Window_CardItemList.prototype.initCardSprites = function () {
    this._cardSprites = [];
    if (this.maxItems() === 0) return;
    var startIndex = Math.max(this._index - this.maxCols() + 1, 0);
    for (var i = 0, len = this.maxCols(); i < len; i++) {
      var j = (startIndex + i) % this.maxItems();
      if (i > 0 && j === startIndex) break;
      var sprite = new Sprite_CardItem();
      this.addChild(sprite);
      this._cardSprites.push(sprite);
    }
    this.setupCardSprites(startIndex);
    this.setCardTargetRotation();
    this.refreshArrows();
  };

  Window_CardItemList.prototype.setupCardSprites = function (startIndex) {
    for (var i = 0, len = this._cardSprites.length; i < len; i++) {
      var j = (startIndex + i) % this.maxItems();
      this._cardSprites[i].setup(j, this._data[j]);
    }
  };

  Window_CardItemList.prototype.refreshArrows = function () {
    var d = baseDistance + 64;
    var sprite = this._cardSprites[0];
    this._upArrowSprite.rotation = sprite._targetRot + shiftRadian;
    var r = this._upArrowSprite.rotation - arrowSpacing;
    this._upArrowSprite.move(Math.cos(r) * d + baseX, Math.sin(r) * d + baseY);
    var sprite = this._cardSprites[this._cardSprites.length - 1];
    this._downArrowSprite.rotation = sprite._targetRot + shiftRadian;
    var r = this._downArrowSprite.rotation + arrowSpacing;
    this._downArrowSprite.move(Math.cos(r) * d + baseX, Math.sin(r) * d + baseY);
  };

  Window_CardItemList.prototype.maxCols = function () {
    return maxCardCols;
  };

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

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

  Window_CardItemList.prototype.isCurrentItemEnabled = function () {
    return this.isEnabled(this.item());
  };

  Window_CardItemList.prototype.includes = function (item) {
    return item.meta.picture;
  };

  Window_CardItemList.prototype.isEnabled = function (item) {
    return $gameParty.canUse(item);
  };

  Window_CardItemList.prototype.makeItemList = function () {
    this._data = $gameParty.allItems().filter(function (item) {
      return this.includes(item);
    }, this);
  };

  Window_CardItemList.prototype.selectLast = function () {
    var index = this._data.indexOf($gameParty.lastItem());
    this.select(index >= 0 ? index : 0);
  };

  Window_CardItemList.prototype.maxPageRows = function () {
    return 1;
  };

  Window_CardItemList.prototype.drawItem = function (index) {
  };

  Window_CardItemList.prototype.cursorDown = function (wrap) {
    this.cursorPagedown();
  };

  Window_CardItemList.prototype.cursorUp = function (wrap) {
    this.cursorPageup();
  };

  Window_CardItemList.prototype.cursorRight = function (wrap) {
    var lastIndex = this.index();
    Window_Selectable.prototype.cursorRight.call(this, useWrap);
    var newIndex = this.index();
    if (lastIndex != newIndex) {
      if (this._cardSprites.length < this.maxItems() &&
        this._cardSprites[this._cardSprites.length - 1]._index === lastIndex) {
        var sprite = this._cardSprites.shift();
        this.setCardIndex(sprite, newIndex);
        this._cardSprites.push(sprite);
      }
      this.setCardTargetRotation();
    }
  };

  Window_CardItemList.prototype.cursorLeft = function (wrap) {
    var lastIndex = this.index();
    Window_Selectable.prototype.cursorLeft.call(this, useWrap);
    var newIndex = this.index();
    if (lastIndex != newIndex) {
      if (this._cardSprites.length < this.maxItems() &&
        this._cardSprites[0]._index === lastIndex) {
        var sprite = this._cardSprites.pop();
        this.setCardIndex(sprite, newIndex);
        this._cardSprites.unshift(sprite);
      }
      this.setCardTargetRotation();
    }
  };

  Window_CardItemList.prototype.cursorPagedown = function () {
    var lastIndex = this.index();
    var maxItems = this.maxItems();
    var maxCols = this.maxCols();
    if (useWrap && maxCols < maxItems) {
      this.select((lastIndex + maxCols) % maxItems);
    } else {
      Window_Selectable.prototype.cursorPagedown.call(this);
    }
    var newIndex = this.index();
    if (lastIndex !== newIndex) {
      this.setupCardSprites(useWrap ? newIndex :
        Math.min(newIndex, maxItems - maxCols));
      this.setCardTargetRotation();
    }
  };

  Window_CardItemList.prototype.cursorPageup = function () {
    var lastIndex = this.index();
    var maxItems = this.maxItems();
    var maxCols = this.maxCols();
    if (useWrap && maxCols < maxItems) {
      this.select((lastIndex - maxCols + maxItems) % maxItems);
    } else {
      Window_Selectable.prototype.cursorPageup.call(this);
    }
    var newIndex = this.index();
    if (lastIndex !== newIndex) {
      this.setupCardSprites(useWrap ? (newIndex + 1 - maxCols + maxItems) % maxItems :
        Math.max(newIndex + 1 - maxCols, 0));
      this.setCardTargetRotation();
    }
  };

  Window_CardItemList.prototype.updateArrows = function () {
    if (useWrap && this.maxCols() < this.maxItems()) {
      this.downArrowVisible = true;
      this.upArrowVisible = true;
    } else {
      var len = this._cardSprites.length;
      this.downArrowVisible = this._cardSprites[len - 1]._index < this.maxItems() - 1;
      this.upArrowVisible = this._cardSprites[0]._index > 0;
    }
  };

  Window_CardItemList.prototype.isTouchedInsideFrame = function () {
    return true;
  };

  Window_CardItemList.prototype.onTouch = function (triggered) {
    var lastIndex = this.index();
    var len = this._cardSprites.length;
    var spacing = cardSpacing / 2;
    var r = Math.atan2(TouchInput.y - baseY, TouchInput.x - baseX) - shiftRadian;
    var hitIndex = -1;
    for (var i = 0; i < len; i++) {
      var sprite = this._cardSprites[i];
      var d = Math.abs(r - sprite._currentRot);
      if (d > Math.PI * 2) d -= Math.PI * 2;
      if (d < spacing) {
        hitIndex = i;
        break;
      }
    }
    if (hitIndex >= 0) {
      var sprite = this._cardSprites[hitIndex];
      if (sprite._index === this.index()) {
        if (triggered && this.isTouchOkEnabled()) {
          this.processOk();
        }
      } else {
        this.select(sprite._index);
      }
    } else if (this._stayCount >= 10) {
      var maxItems = this.maxItems();
      spacing = arrowSpacing / 2;
      var d = Math.abs(r - (this._cardSprites[0]._targetRot - arrowSpacing));
      if (d > Math.PI * 2) d -= Math.PI * 2;
      if (d < spacing) {
        if (this.upArrowVisible) this.cursorLeft();
      } else {
        d = Math.abs(r - (this._cardSprites[len - 1]._targetRot + arrowSpacing));
        if (d > Math.PI * 2) d -= Math.PI * 2;
        if (d < spacing) {
          if (this.downArrowVisible) this.cursorRight();
        }
      }
    }
    if (this.index() !== lastIndex) {
      this.setCardTargetRotation();
      SoundManager.playCursor();
    }
  };

  Window_CardItemList.prototype.updateHelp = function () {
    if (this._helpWindow) {
      var item = this.item();
      if (item) {
        var text = item.description;
        if (showItemName) {
          var name = '\\I[' + item.iconIndex + ']' + item.name;
          var n = $gameParty.numItems(item);
          text = name + (n !== 1 ? numsFormat.format(n) : '') + '\n' + text;
        }
        this._helpWindow.setText(text);
      } else {
        this._helpWindow.setText(blankMessage);
      }
    }
  };

  Window_CardItemList.prototype.setCardIndex = function (sprite, index) {
    sprite.setup(index, this._data[index]);
    this.addChild(this.removeChild(sprite));
  };

  Window_CardItemList.prototype.setCardTargetRotation = function () {
    var len = this._cardSprites.length;
    var r = -Math.PI / 2 - (len - 1) / 2 * cardSpacing;
    var activeSprite = null;
    for (var i = 0; i < len; i++) {
      var sprite = this._cardSprites[i];
      sprite.setTargetRotation(r);
      this.removeChild(sprite);
      if (sprite._index !== this.index()) {
        this.addChild(sprite);
      } else {
        activeSprite = sprite;
      }
      r += cardSpacing;
    }
    if (activeSprite) this.addChild(activeSprite);
    this.addChild(this.removeChild(this._downArrowSprite));
    this.addChild(this.removeChild(this._upArrowSprite));
  };

  Window_CardItemList.prototype.refresh = function () {
    this.createContents();
  };

  Window_CardItemList.prototype.refreshCardRotation = function () {
    for (var i = 0, len = this._cardSprites.length; i < len; i++) {
      this._cardSprites[i].refreshRotation();
    }
  };

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

  if (takeoverMainMenu) {
    var _Scene_Map_callMenu = Scene_Map.prototype.callMenu;
    Scene_Map.prototype.callMenu = function () {
      _Scene_Map_callMenu.call(this);
      SceneManager.pop();
      SceneManager.push(Scene_CardItem);
    };
  }

  //-----------------------------------------------------------------------------
  // Scene_CardItem
  //

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

  Scene_CardItem.prototype = Object.create(Scene_ItemBase.prototype);
  Scene_CardItem.prototype.constructor = Scene_CardItem;

  Scene_CardItem.prototype.initialize = function () {
    Scene_ItemBase.prototype.initialize.call(this);
  };

  Scene_CardItem.prototype.create = function () {
    Scene_ItemBase.prototype.create.call(this);
    if (useHelpWindow) this.createHelpWindow();
    if (useGoldWindow) this.createGoldWindow();
    this.createItemWindow();
    this.createActorWindow();
  };

  Scene_CardItem.prototype.start = function () {
    Scene_ItemBase.prototype.start.call(this);
    this._actorWindow.refresh();
  };

  Scene_CardItem.prototype.createHelpWindow = function () {
    this._helpWindow = new Window_Help(showItemName ? 3 : 2);
    this._helpWindow.y = helpWindowY;
    this.addWindow(this._helpWindow);
  };

  Scene_CardItem.prototype.createItemWindow = function () {
    this._itemWindow = new Window_CardItemList();
    this._itemWindow.setHelpWindow(this._helpWindow);
    this._itemWindow.setHandler('ok', this.onItemOk.bind(this));
    this._itemWindow.setHandler('cancel', this.popScene.bind(this));
    this.addWindow(this._itemWindow);
  };

  Scene_CardItem.prototype.createGoldWindow = function () {
    this._goldWindow = new Window_Gold(0, 0);
    this._goldWindow.x = goldWindowX;
    this._goldWindow.y = goldWindowY;
    this.addWindow(this._goldWindow);
  };

  Scene_CardItem.prototype.user = function () {
    var members = $gameParty.movableMembers();
    var bestActor = members[0];
    var bestPha = 0;
    for (var i = 0; i < members.length; i++) {
      if (members[i].pha > bestPha) {
        bestPha = members[i].pha;
        bestActor = members[i];
      }
    }
    return bestActor;
  };

  Scene_CardItem.prototype.isCursorLeft = function () {
    return true;
  };

  Scene_CardItem.prototype.onItemOk = function () {
    $gameParty.setLastItem(this.item());
    this.determineItem();
  };

  Scene_CardItem.prototype.playSeForItem = function () {
    SoundManager.playUseItem();
  };

  Scene_CardItem.prototype.useItem = function () {
    Scene_ItemBase.prototype.useItem.call(this);
    this._itemWindow.redrawCurrentItem();
  };

})();


code:
//=============================================================================
// TMPlugin - アイテム選択拡張
// バージョン: 1.1.0
// 最終更新日: 2017/01/24
// 配布元    : 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 helpWindowEnabledItem
 * @desc アイテム選択でヘルプウィンドウを表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param helpWindowEnabledKey
 * @desc 大事なもの選択でヘルプウィンドウを表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param helpWindowEnabledA
 * @desc 隠しアイテムＡ選択でヘルプウィンドウを表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param helpWindowEnabledB
 * @desc 隠しアイテムＢ選択でヘルプウィンドウを表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param showItemNumberItem
 * @desc アイテムの個数を表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param showItemNumberKey
 * @desc 大事なものの個数を表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param showItemNumberA
 * @desc 隠しアイテムＡの個数を表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param showItemNumberB
 * @desc 隠しアイテムＡの個数を表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @param numVisibleRowsItem
 * @desc アイテム選択の表示行数
 * 初期値: 4
 * @default 4
 *
 * @param numVisibleRowsKey
 * @desc 大事なもの選択の表示行数
 * 初期値: 4
 * @default 4
 *
 * @param numVisibleRowsA
 * @desc 隠しアイテムＡ選択の表示行数
 * 初期値: 4
 * @default 4
 *
 * @param numVisibleRowsB
 * @desc 隠しアイテムＢ選択の表示行数
 * 初期値: 4
 * @default 4
 *
 * @param fixPlacement
 * @desc メッセージウィンドウがない場合のウィンドウ位置
 * 初期値: top ( top / bottom / 未設定で固定しない )
 * @default top
 *
 * @help
 * TMPlugin - アイテム選択拡張 ver1.1.0
 *
 * 使い方:
 *
 *   アイテムタイプごとに以下の設定を変更できます。
 *   ・ヘルプウィンドウを表示するかどうか
 *   ・個数を表示するかどうか
 *   ・アイテム選択ウィンドウの表示行数
 *
 *   メモ欄タグとプラグインコマンドを使い、候補として表示するアイテムを
 *   さらに細かく分類することもできます。
 *
 *   このプラグインは RPGツクールMV Version 1.3.4 で動作確認をしています。
 *
 *
 * メモ欄タグ（アイテム）:
 *
 *   <subCategory:card>
 *     このタグがついているアイテムにサブカテゴリーとして card を設定します。
 *
 *
 * プラグインコマンド:
 *
 *   setEventItemSubCategory card
 *     イベントコマンド『アイテム選択の処理』の直前に実行することで、
 *     指定したサブカテゴリーのアイテムのみを表示することができます。
 *     たとえば、イベントコマンド側で 大事なもの が選択されている場合、
 *     所持している大事なものの中からサブカテゴリーに card が設定されている
 *     アイテムのみを表示します。
 *
 *     このコマンドの効果はアイテム選択完了（またはキャンセル）時に
 *     リセットされます。
 */

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

var TMPlugin = TMPlugin || {};
TMPlugin.EventItemEx = {};
TMPlugin.EventItemEx.Parameters = PluginManager.parameters('TMEventItemEx');
TMPlugin.EventItemEx.HelpWindowEnabledItem = TMPlugin.EventItemEx.Parameters['helpWindowEnabledItem'] === '1';
TMPlugin.EventItemEx.HelpWindowEnabledKey = TMPlugin.EventItemEx.Parameters['helpWindowEnabledKey'] === '1';
TMPlugin.EventItemEx.HelpWindowEnabledA = TMPlugin.EventItemEx.Parameters['helpWindowEnabledA'] === '1';
TMPlugin.EventItemEx.HelpWindowEnabledB = TMPlugin.EventItemEx.Parameters['helpWindowEnabledB'] === '1';
TMPlugin.EventItemEx.ShowItemNumberItem = TMPlugin.EventItemEx.Parameters['showItemNumberItem'] === '1';
TMPlugin.EventItemEx.ShowItemNumberKey = TMPlugin.EventItemEx.Parameters['showItemNumberKey'] === '1';
TMPlugin.EventItemEx.ShowItemNumberA = TMPlugin.EventItemEx.Parameters['showItemNumberA'] === '1';
TMPlugin.EventItemEx.ShowItemNumberB = TMPlugin.EventItemEx.Parameters['showItemNumberB'] === '1';
TMPlugin.EventItemEx.NumVisibleRowsItem = +(TMPlugin.EventItemEx.Parameters['numVisibleRowsItem'] || 4);
TMPlugin.EventItemEx.NumVisibleRowsKey = +(TMPlugin.EventItemEx.Parameters['numVisibleRowsKey'] || 4);
TMPlugin.EventItemEx.NumVisibleRowsA = +(TMPlugin.EventItemEx.Parameters['numVisibleRowsA'] || 4);
TMPlugin.EventItemEx.NumVisibleRowsB = +(TMPlugin.EventItemEx.Parameters['numVisibleRowsB'] || 4);
TMPlugin.EventItemEx.FixPlacement = TMPlugin.EventItemEx.Parameters['fixPlacement'];

(function () {

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

  Game_Temp.prototype.setEventItemSubCategory = function (category) {
    this._eventItemSubCategory = category;
  };

  Game_Temp.prototype.eventItemSubCategory = function () {
    return this._eventItemSubCategory;
  };

  //-----------------------------------------------------------------------------
  // 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 === 'setEventItemSubCategory') {
      $gameTemp.setEventItemSubCategory(args[0]);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_EventItem
  //

  Window_EventItem.prototype.isHelpWindowEnabled = function () {
    var itypeId = $gameMessage.itemChoiceItypeId();
    if (itypeId === 1) {
      return TMPlugin.EventItemEx.HelpWindowEnabledItem;
    } else if (itypeId === 2) {
      return TMPlugin.EventItemEx.HelpWindowEnabledKey;
    } else if (itypeId === 3) {
      return TMPlugin.EventItemEx.HelpWindowEnabledA;
    } else if (itypeId === 4) {
      return TMPlugin.EventItemEx.HelpWindowEnabledB;
    }
    return false;
  };

  var _Window_EventItem_start = Window_EventItem.prototype.start;
  Window_EventItem.prototype.start = function () {
    this.height = this.fittingHeight(this.numVisibleRows());
    _Window_EventItem_start.call(this);
    if (this.isHelpWindowEnabled()) this._helpWindow.open();
  };

  var _Window_EventItem_numVisibleRows = Window_EventItem.prototype.numVisibleRows;
  Window_EventItem.prototype.numVisibleRows = function () {
    var itypeId = $gameMessage.itemChoiceItypeId();
    if (itypeId === 1) {
      return TMPlugin.EventItemEx.NumVisibleRowsItem;
    } else if (itypeId === 2) {
      return TMPlugin.EventItemEx.NumVisibleRowsKey;
    } else if (itypeId === 3) {
      return TMPlugin.EventItemEx.NumVisibleRowsA;
    } else if (itypeId === 4) {
      return TMPlugin.EventItemEx.NumVisibleRowsB;
    }
    return _Window_EventItem_numVisibleRows.call(this);
  };

  var _Window_EventItem_updatePlacement = Window_EventItem.prototype.updatePlacement;
  Window_EventItem.prototype.updatePlacement = function () {
    var enabled = this.isHelpWindowEnabled();
    if (!$gameMessage.hasText() && TMPlugin.EventItemEx.FixPlacement) {
      if (TMPlugin.EventItemEx.FixPlacement === 'top') {
        this.y = enabled ? this._helpWindow.height : 0;
      } else {
        this.y = Graphics.boxHeight - this.height;
      }
    } else if (enabled) {
      if (this._messageWindow.y >= Graphics.boxHeight / 2) {
        this.y = this._helpWindow.height;
      } else {
        this.y = Graphics.boxHeight - this.height;
      }
    } else {
      _Window_EventItem_updatePlacement.call(this);
    }
    if (enabled) this._helpWindow.y = this.y - this._helpWindow.height;
  };

  var _Window_EventItem_includes = Window_EventItem.prototype.includes;
  Window_EventItem.prototype.includes = function (item) {
    if (!_Window_EventItem_includes.call(this, item)) return false;
    var subCategory = $gameTemp.eventItemSubCategory();
    return !subCategory || item.meta.subCategory === subCategory;
  };

  var _Window_EventItem_onOk = Window_EventItem.prototype.onOk;
  Window_EventItem.prototype.onOk = function () {
    _Window_EventItem_onOk.call(this);
    this._helpWindow.close();
    $gameTemp.setEventItemSubCategory(null);
  };

  var _Window_EventItem_onCancel = Window_EventItem.prototype.onCancel;
  Window_EventItem.prototype.onCancel = function () {
    _Window_EventItem_onCancel.call(this);
    this._helpWindow.close();
    $gameTemp.setEventItemSubCategory(null);
  };

  Window_EventItem.prototype.needsNumber = function () {
    var itypeId = $gameMessage.itemChoiceItypeId();
    return (itypeId === 1 && TMPlugin.EventItemEx.ShowItemNumberItem) ||
      (itypeId === 2 && TMPlugin.EventItemEx.ShowItemNumberKey) ||
      (itypeId === 3 && TMPlugin.EventItemEx.ShowItemNumberA) ||
      (itypeId === 4 && TMPlugin.EventItemEx.ShowItemNumberB);
  };

  //-----------------------------------------------------------------------------
  // Window_Message
  //

  var _Window_Message_subWindows = Window_Message.prototype.subWindows;
  Window_Message.prototype.subWindows = function () {
    var subWindows = _Window_Message_subWindows.call(this);
    subWindows.push(this._helpWindow);
    return subWindows;
  };

  var _Window_Message_createSubWindows = Window_Message.prototype.createSubWindows;
  Window_Message.prototype.createSubWindows = function () {
    _Window_Message_createSubWindows.call(this);
    this._helpWindow = new Window_Help();
    this._helpWindow.openness = 0;
    this._itemWindow.setHelpWindow(this._helpWindow);
  };

})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// TMVplugin - お金でレベルアップ
// 作者: tomoaky (http://hikimoki.sakura.ne.jp/)
// Version: 1.11
// 最終更新日: 2016/01/26
//=============================================================================

/*:
 * @plugindesc 経験値ではなくお金を消費して任意のタイミングで
 * アクターをレベルアップさせることができます。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param levelUpCommand
 * @desc メニューに表示するレベルアップコマンド（空にすれば無効）
 * 初期値: レベルアップ
 * @default レベルアップ
 *
 * @param currentGold
 * @desc ステータスに表示するお金の項目名
 * 初期値: 所持金
 * @default 所持金
 *
 * @param learnSkill
 * @desc ステータスに表示する覚えるスキルの項目名
 * 初期値: 覚えるスキル
 * @default 覚えるスキル
 *
 * @param levelUpSe
 * @desc レベルアップ時に鳴らす効果音（ファイル名 音量 ピッチ パン）
 * 初期値: Up4 90 100 0
 * @default Up4 90 100 0
 *
 * @param useButton
 * @desc アクター変更のボタンを表示するかどうか
 * 初期値: 1（ 0 で表示しない）
 * @default 1
 *
 * @help
 * lavelUpCommand のコマンド名を削除して空にすれば
 * メニューからレベルアップコマンドを削除することができます。
 * この場合はプラグインコマンドを使ってイベントからレベルアップシーンを
 * 呼び出してください。
 *
 * プラグインコマンド:
 *   callLevelUp        # レベルアップシーンを呼び出す
 *
 */

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

var TMParam = TMParam || {};

(function () {

  var parameters = PluginManager.parameters('TMGoldLevelUp');
  var levelUpCommand = parameters['levelUpCommand'];
  var currentGold = parameters['currentGold'];
  var learnSkill = parameters['learnSkill'];
  var a = parameters['levelUpSe'].split(' ');
  var levelUpSe = {};
  levelUpSe.name = a[0];
  levelUpSe.volume = Number(a[1]);
  levelUpSe.pitch = Number(a[2]);
  levelUpSe.pan = Number(a[3]);
  var useButton = parameters['useButton'] === '1' ? true : false;

  //-----------------------------------------------------------------------------
  // TextManager
  //

  Object.defineProperty(TextManager, 'goldLevelUp', {
    get: function () { return levelUpCommand; },
    configurable: true
  });

  //-----------------------------------------------------------------------------
  // 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 === 'callLevelUp') {
      SceneManager.push(Scene_GoldLevelUp);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_MenuCommand
  //

  var _Window_MenuCommand_addOriginalCommands = Window_MenuCommand.prototype.addOriginalCommands;
  Window_MenuCommand.prototype.addOriginalCommands = function () {
    _Window_MenuCommand_addOriginalCommands.call(this);
    if (levelUpCommand) {
      this.addCommand(levelUpCommand, 'levelUp', true);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_Status
  //

  Window_Status.prototype.drawExpInfo = function (x, y) {
    var lineHeight = this.lineHeight();
    var expNext = TextManager.expNext.format(TextManager.level);
    var value = this._actor.nextRequiredExp();
    if (this._actor.isMaxLevel()) {
      value = '-------';
    }
    this.changeTextColor(this.systemColor());
    this.drawText(expNext, x, y + lineHeight * 0, 270);
    this.drawText(currentGold, x, y + lineHeight * 2, 270);
    this.resetTextColor();
    this.drawCurrencyValue(value, TextManager.currencyUnit,
      x, y + lineHeight * 1, 270);
    this.drawCurrencyValue($gameParty.gold(), TextManager.currencyUnit,
      x, y + lineHeight * 3, 270);
  };

  //-----------------------------------------------------------------------------
  // Window_GoldLevelUpCommand
  //

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

  Window_GoldLevelUpCommand.prototype = Object.create(Window_HorzCommand.prototype);
  Window_GoldLevelUpCommand.prototype.constructor = Window_GoldLevelUpCommand;

  Window_GoldLevelUpCommand.prototype.initialize = function () {
    Window_HorzCommand.prototype.initialize.call(this, 0, 0);
  };

  Window_GoldLevelUpCommand.prototype.windowWidth = function () {
    return Graphics.boxWidth;
  };

  Window_GoldLevelUpCommand.prototype.maxCols = function () {
    return 2;
  };

  Window_GoldLevelUpCommand.prototype.makeCommandList = function () {
    this.addCommand('レベルアップ', 'levelUp', this.canLevelUp());
    this.addCommand('キャンセル', 'cancelCommand');
  };

  Window_GoldLevelUpCommand.prototype.canLevelUp = function () {
    return this._actor && !this._actor.isMaxLevel() &&
      $gameParty.gold() >= this._actor.nextRequiredExp();
  };

  Window_GoldLevelUpCommand.prototype.setActor = function (actor) {
    this._actor = actor;
    this.refresh();
  };

  Window_GoldLevelUpCommand.prototype.playOkSound = function () {
    if (this.currentSymbol() === 'levelUp') {
      AudioManager.playSe(levelUpSe);     // レベルアップ効果音を鳴らす
    } else {
      SoundManager.playOk();
    }
  };

  //-----------------------------------------------------------------------------
  // Window_GoldLevelUpStatus
  //

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

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

  Window_GoldLevelUpStatus.prototype.initialize = function (x, y, width, height) {
    Window_Selectable.prototype.initialize.call(this, x, y, width, height);
    this.refresh();
  };

  Window_GoldLevelUpStatus.prototype.setActor = function (actor) {
    if (this._actor !== actor) {
      this._actor = actor;
      this.refresh();
    }
  };

  Window_GoldLevelUpStatus.prototype.refresh = function () {
    this.contents.clear();
    if (this._actor) {
      if (!this._actor.isMaxLevel()) {
        this._tempActor = JsonEx.makeDeepCopy(this._actor);
        this._tempActor.levelUp();
      } else {
        this._tempActor = null;
      }
      var lineHeight = this.lineHeight();
      this.drawBlock1(lineHeight * 0);
      this.drawHorzLine(lineHeight * 1);
      this.drawBlock2(lineHeight * 2 - 20);
      this.drawHorzLine(lineHeight * 6 - 20);
      this.drawBlock3(lineHeight * 7 - 40);
    }
  };

  Window_GoldLevelUpStatus.prototype.drawBlock1 = function (y) {
    this.drawActorName(this._actor, 6, y);
    this.drawActorClass(this._actor, 192, y);
    this.drawActorNickname(this._actor, 432, y);
  };

  Window_GoldLevelUpStatus.prototype.drawBlock2 = function (y) {
    this.drawActorFace(this._actor, 12, y);
    if (useButton && $gameParty.size() > 1) {
      this.drawButton(140, y);
    }
    this.drawBasicInfo(204, y);
    this.drawExpInfo(456, y);
  };

  Window_GoldLevelUpStatus.prototype.drawButton = function (x, y) {
    var bitmap = ImageManager.loadSystem('ButtonSet');
    this.contents.blt(bitmap, 96, 0, 48, 48, x, y);
    this.contents.blt(bitmap, 48, 0, 48, 48, x, y + 96);
  };

  Window_GoldLevelUpStatus.prototype.drawBlock3 = function (y) {
    this.drawParameters(48, y);
    this.drawSkills(432, y);
  };

  Window_GoldLevelUpStatus.prototype.drawHorzLine = function (y) {
    var lineY = y + 7;
    this.contents.paintOpacity = 48;
    this.contents.fillRect(0, lineY, this.contentsWidth(), 2, this.lineColor());
    this.contents.paintOpacity = 255;
  };

  Window_GoldLevelUpStatus.prototype.lineColor = function () {
    return this.normalColor();
  };

  Window_GoldLevelUpStatus.prototype.drawBasicInfo = function (x, y) {
    var lineHeight = this.lineHeight();
    this.drawActorLevel(this._actor, x, y + lineHeight * 0);
    this.drawActorIcons(this._actor, x, y + lineHeight * 1);
    this.drawActorHp(this._actor, x, y + lineHeight * 2);
    this.drawActorMp(this._actor, x, y + lineHeight * 3);
  };

  Window_GoldLevelUpStatus.prototype.drawParameters = function (x, y) {
    var lineHeight = this.lineHeight();
    for (var i = 0; i < 8; i++) {
      var y2 = y + lineHeight * i;
      this.changeTextColor(this.systemColor());
      this.drawText(TextManager.param(i), x, y2, 120);
      this.resetTextColor();
      this.drawText(this._actor.param(i), x + 140, y2, 48, 'right');
      if (this._tempActor) {
        this.drawRightArrow(x + 188, y2);
        this.drawNewParam(x + 222, y2, i);
      }
    }
  };

  Window_GoldLevelUpStatus.prototype.drawRightArrow = function (x, y) {
    this.changeTextColor(this.systemColor());
    this.drawText('\u2192', x, y, 32, 'center');
  };

  Window_GoldLevelUpStatus.prototype.drawNewParam = function (x, y, paramId) {
    var newValue = this._tempActor.param(paramId);
    var diffvalue = newValue - this._actor.param(paramId);
    this.changeTextColor(this.paramchangeTextColor(diffvalue));
    this.drawText(newValue, x, y, 48, 'right');
  };

  Window_GoldLevelUpStatus.prototype.drawExpInfo = function (x, y) {
    var lineHeight = this.lineHeight();
    var expNext = TextManager.expNext.format(TextManager.level);
    var value = this._actor.nextRequiredExp();
    if (this._actor.isMaxLevel()) {
      value = '-------';
    }
    this.changeTextColor(this.systemColor());
    this.drawText(expNext, x, y + lineHeight * 0, 270);
    this.drawText(currentGold, x, y + lineHeight * 2, 270);
    this.resetTextColor();
    this.drawCurrencyValue(value, TextManager.currencyUnit,
      x, y + lineHeight * 1, 270);
    this.drawCurrencyValue($gameParty.gold(), TextManager.currencyUnit,
      x, y + lineHeight * 3, 270);
  };

  Window_GoldLevelUpStatus.prototype.drawSkills = function (x, y) {
    var lineHeight = this.lineHeight();
    this.changeTextColor(this.systemColor());
    this.drawText(learnSkill, x, y + lineHeight * 0, 270);
    this.resetTextColor();
    if (this._tempActor) {
      var i = 0;
      this._tempActor.currentClass().learnings.forEach(function (learning) {
        if (learning.level === this._tempActor._level) {
          i++;
          var skill = $dataSkills[learning.skillId];
          this.drawItemName(skill, x, y + lineHeight * i);
        }
      }, this);
    }
  };

  Window_GoldLevelUpStatus.prototype.isHitUpButton = function () {
    var x = this.parent.x + this.x + this.standardPadding() + 140;
    var y = this.parent.y + this.y + this.standardPadding() + this.lineHeight() * 2 - 20;
    return TouchInput.x >= x && TouchInput.x < x + 48 &&
      TouchInput.y >= y && TouchInput.y < y + 48;
  };

  Window_GoldLevelUpStatus.prototype.isHitDownButton = function () {
    var x = this.parent.x + this.x + this.standardPadding() + 140;
    var y = this.parent.y + this.y + this.standardPadding() + this.lineHeight() * 2 + 76;
    return TouchInput.x >= x && TouchInput.x < x + 48 &&
      TouchInput.y >= y && TouchInput.y < y + 48;
  };

  //-----------------------------------------------------------------------------
  // Scene_Menu
  //

  var _Scene_Menu_createCommandWindow = Scene_Menu.prototype.createCommandWindow;
  Scene_Menu.prototype.createCommandWindow = function () {
    _Scene_Menu_createCommandWindow.call(this);
    this._commandWindow.setHandler('levelUp', this.commandPersonal.bind(this));
  };

  var _Scene_Menu_onPersonalOk = Scene_Menu.prototype.onPersonalOk;
  Scene_Menu.prototype.onPersonalOk = function () {
    switch (this._commandWindow.currentSymbol()) {
      case 'levelUp':
        SceneManager.push(Scene_GoldLevelUp);
        break;
      default:
        _Scene_Menu_onPersonalOk.call(this);
        break;
    }
  };

  //-----------------------------------------------------------------------------
  // Scene_GoldLevelUp
  //

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

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

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

  Scene_GoldLevelUp.prototype.create = function () {
    Scene_MenuBase.prototype.create.call(this);
    this.createCommandWindow();
    this.createStatusWindow();
  };

  Scene_GoldLevelUp.prototype.start = function () {
    Scene_MenuBase.prototype.start.call(this);
    this._statusWindow.refresh();
  };

  Scene_GoldLevelUp.prototype.createCommandWindow = function () {
    this._commandWindow = new Window_GoldLevelUpCommand();
    this._commandWindow.setHandler('levelUp', this.commandLevelUp.bind(this));
    this._commandWindow.setHandler('cancelCommand', this.popScene.bind(this));
    this._commandWindow.setHandler('pagedown', this.nextActor.bind(this));
    this._commandWindow.setHandler('pageup', this.previousActor.bind(this));
    this._commandWindow.setHandler('cancel', this.popScene.bind(this));
    this.addWindow(this._commandWindow);
  };

  Scene_GoldLevelUp.prototype.createStatusWindow = function () {
    var wy = this._commandWindow.height;
    var ww = Graphics.boxWidth;
    var wh = Graphics.boxHeight - this._commandWindow.height;
    this._statusWindow = new Window_GoldLevelUpStatus(0, wy, ww, wh);
    this.addWindow(this._statusWindow);
    this.refreshActor();
  };

  Scene_GoldLevelUp.prototype.commandLevelUp = function () {
    var actor = this.actor();
    $gameParty.loseGold(actor.nextRequiredExp());
    actor.changeExp(actor.currentExp() + actor.nextRequiredExp(), false);
    this._commandWindow.refresh();
    this._statusWindow.refresh();
    //    this._commandWindow.deselect();
    this._commandWindow.activate();
  };

  Scene_GoldLevelUp.prototype.refreshActor = function () {
    var actor = this.actor();
    this._commandWindow.setActor(actor);
    this._statusWindow.setActor(actor);
  };

  Scene_GoldLevelUp.prototype.onActorChange = function () {
    this.refreshActor();
    this._commandWindow.activate();
  };

  Scene_GoldLevelUp.prototype.update = function () {
    Scene_MenuBase.prototype.update.call(this);
    if (useButton && $gameParty.size() > 1 && TouchInput.isTriggered()) {
      if (this._statusWindow.isHitUpButton()) {
        this.previousActor();
        SoundManager.playCursor();
      } else if (this._statusWindow.isHitDownButton()) {
        this.nextActor();
        SoundManager.playCursor();
      }
    }
  };

  TMParam.Scene_GoldLevelUp = Scene_GoldLevelUp;

})();


code:
//=============================================================================
// TMVplugin - 欲張りショップ
// 作者: tomoaky (http://hikimoki.sakura.ne.jp/)
// Version: 1.01
// 最終更新日: 2015/12/11
//=============================================================================

/*:
 * @plugindesc お金以外にアイテムも要求されるショップ機能を追加します。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param materialWindowWidth
 * @desc 素材ウィンドウの幅。
 * 初期値: 408
 * @default 408
 *
 * @param materialMax
 * @desc 設定できる素材の最大数。
 * 初期値: 5
 * @default 5
 *
 * @param greedCommand
 * @desc 欲張りショップの購入コマンド名。
 * 初期値: 購入する
 * @default 購入する
 *
 * @help
 * アイテム、武器、防具のメモに以下のタグを使って素材を設定します。
 * <mat1:I1*3>    # お金以外にアイテム１番が３個必要になります
 *                  mat2, mat3... と素材を追加していくことができます
 *                  I の部分が W で武器、A で防具です
 * <matG:50>      # 価格を50に設定します、この設定は欲張りショップが
 *                  有効になっている場合にのみ購入価格として反映されます
 *
 * プラグインコマンド:
 *   greedShop    # このコマンドが実行された直後にショップの処理を
 *                  実行することで欲張りショップになります
 *   greedCommand 買っちゃう    # 欲張りショップの購入コマンド名を
 *                                指定したテキストに変更します。
 *                                この変更はセーブデータには保存されません
 *
 * 消耗設定が『しない』になっているアイテムを素材に設定した場合、
 * 消耗しないが必要なものとして機能します。
 */

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

(function () {

  var parameters = PluginManager.parameters('TMGreedShop');
  var materialWindowWidth = Number(parameters['materialWindowWidth']);
  var materialMax = Number(parameters['materialMax']);
  var greedCommand = parameters['greedCommand'];

  //-----------------------------------------------------------------------------
  // 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 = Number(match[2]);
            material.need = Number(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;
  };

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

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

  Game_Temp.prototype.isGreedShop = function () {
    return this._greedShop ? true : false;
  };

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

  Game_Temp.prototype.greedCommand = function () {
    if (this._greedCommand) {
      return this._greedCommand;
    } else {
      return 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_ShopCommand
  //

  var _Window_ShopCommand_makeCommandList = Window_ShopCommand.prototype.makeCommandList;
  Window_ShopCommand.prototype.makeCommandList = function () {
    if ($gameTemp.isGreedShop()) {
      this.addCommand($gameTemp.greedCommand(), 'buy');
      this.addCommand(TextManager.sell, 'sell', !this._purchaseOnly);
      this.addCommand(TextManager.cancel, 'cancel');
    } else {
      _Window_ShopCommand_makeCommandList.call(this);
    }
  };

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

  var _Window_ShopBuy_price = Window_ShopBuy.prototype.price;
  Window_ShopBuy.prototype.price = function (item) {
    if ($gameTemp.isGreedShop() && item.meta.matG) {
      return Number(item.meta.matG);
    } else {
      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 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 type = match[1].toUpperCase();
            if (type === 'I') {
              var matItem = $dataItems[Number(match[2])];
            } else if (type === 'W') {
              var matItem = $dataWeapons[Number(match[2])];
            } else if (type === 'A') {
              var matItem = $dataArmors[Number(match[2])];
            }
            if (matItem && $gameParty.numItems(matItem) < Number(match[3])) {
              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());
      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.setPosition(x, y, lineHeight);
    }
  };

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

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

  var _Window_ShopNumber_refresh = Window_ShopNumber.prototype.refresh;
  Window_ShopNumber.prototype.refresh = function () {
    _Window_ShopNumber_refresh.call(this);
    if ($gameTemp.isGreedShop()) {
      this.drawTotalMaterial();
    }
  };

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

  var _Window_ShopNumber_priceY = Window_ShopNumber.prototype.priceY;
  Window_ShopNumber.prototype.priceY = function () {
    if ($gameTemp.isGreedShop()) {
      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()) {
      return this.priceY() + this.lineHeight() * (materialMax + 3);
    }
    return _Window_ShopNumber_buttonY.call(this);
  };

  Window_ShopNumber.prototype.drawTotalMaterial = function () {
    var materials = DataManager.getGreedShopMaterials(this._item);
    for (var i = 0; i < materials.length; i++) {
      var material = materials[i];
      var item = DataManager.materialToItem(material);
      var y = this.lineHeight() * (i + 2.5);
      this.drawItemName(item, 0, y);
      var need = material.need * this._number;
      var n = $gameParty.numItems(item);
      var text = item.consumable ? '' + need + '/' : '--/';
      text += ('   ' + n).substr(-3);
      this.drawText(text, 0, y, this.contents.width - this.textPadding(), 'right');
    }
  };

  //-----------------------------------------------------------------------------
  // 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;
    return this.fittingHeight(n);
  };

  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) {
    if (this._shopItem !== item) {
      this._shopItem = item;
      this._materials = DataManager.getGreedShopMaterials(item);
      if (this._materials.length > 0) {
        this.refresh();
      }
      this.show();
    }
  };

  Window_Material.prototype.setPosition = function (x, y, lineHeight) {
    if (this.visible) {
      this.x = x - this.width / 2;
      this.y = y;
      if (this.y + this.height > Graphics.boxHeight) {
        this.y = y - this.height - lineHeight;
      }
    }
  };

  Window_Material.prototype.refresh = function () {
    this.move(this.x, this.y, this.width, this.windowHeight());
    this.createContents();
    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 = item.consumable ? '' + need + '/' : '--/';
      text += ('   ' + n).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);
    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_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 (item.consumable) {
          $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 (item.consumable) {
          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) {
      this._materialWindow.show();
    }
  };

})();


code:
//=============================================================================
// TMPlugin - マップＨＰゲージ
// バージョン: 1.4.4
// 最終更新日: 2019/11/04
// 配布元　　: https://hikimoki.sakura.ne.jp/
//-----------------------------------------------------------------------------
// Copyright (c) 2016 tomoaky
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
//=============================================================================

/*:
 * @plugindesc マップシーンに顔グラフィックとＨＰゲージを表示します。
 * 必要に応じてＭＰや変数などをゲージで表示することもできます。
 *
 * @author tomoaky (https://hikimoki.sakura.ne.jp/)
 *
 * @param gaugeWindowX
 * @type number
 * @min -1000
 * @desc ＨＰゲージウィンドウのＸ座標
 * 初期値: 0
 * @default 0
 *
 * @param gaugeWindowY
 * @type number
 * @min -1000
 * @desc ＨＰゲージウィンドウのＹ座標
 * 初期値: 0
 * @default 0
 *
 * @param gaugeWindowWidth
 * @type number
 * @desc ＨＰゲージウィンドウの幅
 * 初期値: 288
 * @default 288
 *
 * @param gaugeWindowHeight
 * @type number
 * @desc ＨＰゲージウィンドウの高さ
 * 初期値: 64
 * @default 64
 *
 * @param gaugeA
 * @type struct<Gauge>
 * @desc ゲージＡのパラメータ
 * @default {"type":"HP","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param gaugeB
 * @type struct<Gauge>
 * @desc ゲージＢのパラメータ
 * @default {"type":"","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param gaugeC
 * @type struct<Gauge>
 * @desc ゲージＣのパラメータ
 * @default {"type":"","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param gaugeD
 * @type struct<Gauge>
 * @desc ゲージＤのパラメータ
 * @default {"type":"","x":"12","y":"12","width":"144","height":"36","fontSize":"28","param":"0","max":"0","name":"AP","color":"#ff60c0 #ffa0e0"}
 *
 * @param faceOffsetX
 * @type number
 * @min -1000
 * @desc 顔グラフィックのＸ座標補正値
 * 初期値: -4 ( -1000 で顔グラフィックを使用しない)
 * @default -4
 *
 * @param faceOffsetY
 * @type number
 * @min -1000
 * @desc 顔グラフィックのＹ座標補正値
 * 初期値: -4
 * @default -4
 *
 * @param stateIconMax
 * @type number
 * @desc ステートアイコンを表示する個数
 * 初期値: 4
 * @default 4
 *
 * @param stateIconX
 * @type number
 * @min -1000
 * @desc ステートアイコンのＸ座標
 * 初期値: 156
 * @default 156
 *
 * @param stateIconY
 * @type number
 * @min -1000
 * @desc ステートアイコンのＹ座標
 * 初期値: 24
 * @default 24
 *
 * @param stateIconScale
 * @type number
 * @desc ステートアイコンの拡大率（ % ）
 * 初期値: 100
 * @default 100
 *
 * @param stateIconOpacity
 * @type number
 * @desc ステートアイコンの不透明度（ 0 ~ 255 ）
 * 初期値: 255
 * @default 255
 *
 * @param goldWidth
 * @type number
 * @desc 所持金表示の幅
 * 初期値: 0 ( 0 で非表示 )
 * @default 0
 *
 * @param goldX
 * @type number
 * @min -9999
 * @desc 所持金表示のＸ座標
 * 初期値: 12
 * @default 12
 *
 * @param goldY
 * @type number
 * @min -1000
 * @desc 所持金表示のＹ座標
 * 初期値: 12
 * @default 12
 *
 * @param vnMax
 * @type boolean
 * @desc ゲージタイプ VN の最大値を表示するかどうか
 * 初期値: OFF ( true = ON 表示 / false = OFF 非表示 )
 * @default false
 *
 * @param shakeTime
 * @type number
 * @desc ダメージを受けたときにウィンドウを揺らす時間（フレーム）
 * 初期値: 20 ( 0 で揺らさない )
 * @default 20
 *
 * @param startVisible
 * @type boolean
 * @desc ゲーム開始時の表示状態
 * 初期値: ON（ true = ON 表示 / false = OFF 非表示 ）
 * @default true
 *
 * @param windowOpacity
 * @type number
 * @desc ＨＰゲージウィンドウの不透明度
 * 初期値: 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 useBattleScene
 * @type boolean
 * @desc 戦闘シーンでもＨＰゲージウィンドウを表示する。
 * 初期値: OFF（ true = ON 表示 / false = OFF 非表示 )
 * @default false
 *
 * @param gaugeWindowBattleX
 * @type number
 * @min -1000
 * @desc 戦闘シーンのＨＰゲージウィンドウのＸ座標
 * 初期値: 0
 * @default 0
 *
 * @param gaugeWindowBattleY
 * @type number
 * @min -1000
 * @desc 戦闘シーンのＨＰゲージウィンドウのＹ座標
 * 初期値: 0
 * @default 0
 *
 * @help
 * TMPlugin - マップＨＰゲージ ver1.4.4
 *
 * 使い方:
 *
 *   プラグインパラメータをいじってお好みのＨＰゲージを表示してください。
 *
 *   このプラグインは RPGツクールMV Version 1.6.2 で動作確認をしています。
 *
 *   このプラグインはMITライセンスのもとに配布しています、商用利用、
 *   改造、再配布など、自由にお使いいただけます。
 *
 *
 * プラグインコマンド:
 *
 *   showHpGauge
 *     ＨＰゲージウィンドウを表示します。
 *     プラグインパラメータ startVisible が 0 の場合、
 *     このコマンドが実行されるまでＨＰゲージは表示されません。
 *
 *   showHpGauge A
 *     ゲージＡを表示します。プラグインパラメータでタイプが設定されている場合、
 *     ゲーム開始時に自動的に表示状態になります。
 *
 *   hideHpGauge
 *     ＨＰゲージウィンドウを隠します。showHpGauge コマンドが実行されるまで
 *     表示されないままです。
 *
 *   hideHpGauge B
 *     ゲージＢを隠します。showHpGauge B コマンドが実行されるまで
 *     表示されないままです。
 *
 *   moveHpGaugeWindow 100 200
 *     ＨＰゲージウィンドウの位置を X座標 = 100 / Y座標 = 200 の位置へ
 *     移動します。
 *
 *
 * プラグインパラメータ補足:
 *
 *   gaugeA ～ gaugeD
 *
 *     param
 *       ゲージのタイプが VN の場合に、ゲージの現在値として扱う
 *       ゲーム変数番号を設定してください。
 *
 *     max
 *       ゲージのタイプが VN の場合に、ゲージの最大値として扱う
 *       ゲーム変数番号を指定してください。
 *       このパラメータに設定した番号のゲーム変数に値を代入することで、
 *       初めて最大値として機能します。
 *       この設定はゲージの長さにのみ影響します、変数の値が最大値を
 *       超えなくなるような機能はありません。
 *
 *   windowOpacity / collideOpacity
 *     windowOpacity はウィンドウフレーム及び背景に影響し、collideOpacity
 *     はゲージや顔グラフィックにも影響します。
 *     windowOpacity の値が collideOpacity よりも低い場合、プレイヤーと
 *     重なった際の不透明度として windowOpacity の値が適用されます。
 *     ただし、ゲージと顔グラフィックに関しては通常どおり collideOpacity の
 *     値が適用されます。
 *
 *   faceOffsetX
 *     この値を -1000 に設定すると顔グラフィックが非表示となります。
 *
 *   vnMax
 *     値が true なら最大値も表示しますが、現在値と最大値を表示するための
 *     スペースが足りない（ゲージの長さが短い）場合は vnMax の設定に関わらず
 *     強制的に現在値のみの表示になります。
 */
/*~struct~Gauge:
 *
 * @param type
 * @type select
 * @option なし
 * @value
 * @option HP
 * @option MP
 * @option TP
 * @option LV
 * @option VN
 * @desc ゲージのタイプ（HP / MP / TP / LV / VN）
 * 初期値: HP
 * @default HP
 *
 * @param x
 * @type number
 * @min -1000
 * @desc ゲージのＸ座標（ウィンドウ内の左端が 0 ）
 * 初期値: 12
 * @default 12
 *
 * @param y
 * @type number
 * @min -1000
 * @desc ゲージのＹ座標（ウィンドウ内の上端が 0 ）
 * 初期値: 12
 * @default 12
 *
 * @param width
 * @type number
 * @desc ゲージの長さ
 * 初期値: 144
 * @default 144
 *
 * @param height
 * @type number
 * @desc ゲージの表示領域（数値とゲージ合わせて）の高さ
 * 初期値: 36
 * @default 36
 *
 * @param fontSize
 * @type number
 * @desc フォントサイズ
 * 初期値: 28
 * @default 28
 *
 * @param param
 * @type variable
 * @desc ゲージのタイプが VN のときに現在値とするゲーム変数番号
 * 初期値: 0
 * @default 0
 *
 * @param max
 * @type variable
 * @desc ゲージのタイプが VN のときに最大値とするゲーム変数番号
 * 初期値: 0
 * @default 0
 *
 * @param name
 * @type string
 * @desc ゲージのタイプが VN のときに表示するパラメータ名
 * 初期値: AP
 * @default AP
 *
 * @param color
 * @type string
 * @desc ゲージのタイプが LV / VN のときのゲージカラー
 * 初期値: #ff60c0 #ffa0e0
 * @default #ff60c0 #ffa0e0
 */

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

(function () {

	var parameters = PluginManager.parameters('TMMapHpGauge');
	var gaugeWindowX = +(parameters['gaugeWindowX'] || 0);
	var gaugeWindowY = +(parameters['gaugeWindowY'] || 0);
	var gaugeWindowWidth = +(parameters['gaugeWindowWidth'] || 288);
	var gaugeWindowHeight = +(parameters['gaugeWindowHeight'] || 64);
	var gauges = [];
	['A', 'B', 'C', 'D'].forEach(function (code, i) {
		gauges[i] = JSON.parse(parameters['gauge' + code]);
		gauges[i].x = +gauges[i].x;
		gauges[i].y = +gauges[i].y;
		gauges[i].width = +gauges[i].width;
		gauges[i].height = +gauges[i].height;
		gauges[i].fontSize = +gauges[i].fontSize;
		gauges[i].param = +gauges[i].param;
		gauges[i].max = +gauges[i].max;
		gauges[i].color = gauges[i].color.split(' ');
	});
	var faceOffsetX = +(parameters['faceOffsetX'] || -4);
	var faceOffsetY = +(parameters['faceOffsetY'] || -4);
	var stateIconMax = +(parameters['stateIconMax'] || 4);
	var stateIconX = +(parameters['stateIconX'] || 156);
	var stateIconY = +(parameters['stateIconY'] || 24);
	var stateIconScale = +(parameters['stateIconScale'] || 100);
	var stateIconOpacity = +(parameters['stateIconOpacity'] || 255);
	var goldWidth = +(parameters['goldWidth'] || 0);
	var goldX = +(parameters['goldX'] || 0);
	var goldY = +(parameters['goldY'] || 0);
	var vnMax = JSON.parse(parameters['vnMax'] || 'false');
	var shakeTime = +(parameters['shakeTime'] || 20);
	var collideOpacity = +(parameters['collideOpacity'] || 128);
	var startVisible = JSON.parse(parameters['startVisible'] || 'true');
	var windowOpacity = +(parameters['windowOpacity'] || 255);
	var messageBusyHide = JSON.parse(parameters['messageBusyHide'] || 'true');
	var eventBusyHide = JSON.parse(parameters['eventBusyHide'] || 'true');
	var useBattleScene = JSON.parse(parameters['useBattleScene'] || 'false');
	var gaugeWindowBattleX = +(parameters['gaugeWindowBattleX'] || 0);
	var gaugeWindowBattleY = +(parameters['gaugeWindowBattleY'] || 0);

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

	Game_System.prototype.isVisibleMapHpGauge = function () {
		if (this._visibleMapHpGauge == null) this._visibleMapHpGauge = startVisible;
		return this._visibleMapHpGauge;
	};

	Game_System.prototype.setVisibleMapHpGauge = function (flag) {
		this._visibleMapHpGauge = flag;
	};

	Game_System.prototype.isVisibleMapHpGauges = function (gaugeId) {
		if (this._visibleMapHpGauges == null) {
			this._visibleMapHpGauges = [];
			for (var i = 0; i < gauges.length; i++) {
				this._visibleMapHpGauges[i] = gauges[i].type !== '';
			}
		}
		return this._visibleMapHpGauges[gaugeId];
	};

	Game_System.prototype.setVisibleMapHpGauges = function (gaugeId, flag) {
		this._visibleMapHpGauges[gaugeId] = flag;
	};

	//-----------------------------------------------------------------------------
	// 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 === 'showHpGauge') {
			if (args[0]) {
				var gaugeId = ['A', 'B', 'C', 'D'].indexOf(args[0]);
				$gameSystem.setVisibleMapHpGauges(gaugeId, true);
			} else {
				$gameSystem.setVisibleMapHpGauge(true);
			}
		} else if (command === 'hideHpGauge') {
			if (args[0]) {
				var gaugeId = ['A', 'B', 'C', 'D'].indexOf(args[0]);
				$gameSystem.setVisibleMapHpGauges(gaugeId, false);
			} else {
				$gameSystem.setVisibleMapHpGauge(false);
			}
		} else if (command === 'moveHpGaugeWindow') {
			$gameSystem._mapHpGaugeWindowX = +args[0];
			$gameSystem._mapHpGaugeWindowY = +args[1];
			if (SceneManager._scene._mapHpGaugeWindow) {
				SceneManager._scene._mapHpGaugeWindow.x = +args[0];
				SceneManager._scene._mapHpGaugeWindow.y = +args[1];
				SceneManager._scene._mapHpGaugeWindow._baseX = +args[0];
			}
		}
	};

	//-----------------------------------------------------------------------------
	// Window_MapHpGauge
	//

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

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

	Window_MapHpGauge.prototype.initialize = function () {
		if (SceneManager.isNextScene(Scene_Battle)) {
			var x = gaugeWindowBattleX;
			var y = gaugeWindowBattleY;
		} else {
			var x = $gameSystem._mapHpGaugeWindowX != null ? $gameSystem._mapHpGaugeWindowX : gaugeWindowX;
			var y = $gameSystem._mapHpGaugeWindowY != null ? $gameSystem._mapHpGaugeWindowY : gaugeWindowY;
		}
		var wight = gaugeWindowWidth;
		var height = gaugeWindowHeight;
		Window_Base.prototype.initialize.call(this, x, y, wight, height);
		this.openness = $gameSystem.isVisibleMapHpGauge() ? 255 : 0;
		this.opacity = windowOpacity;
		this._gaugeParams = [];
		this._gaugeVisible = [];
		for (var i = 0; i < gauges.length; i++) {
			this._gaugeParams.push({ param: -1, max: -1 });
			this._gaugeVisible[i] = $gameSystem.isVisibleMapHpGauges(i);
		}
		this._icons = [];
		this._gold = 0;
		this._actorId = -1;
		this._faceName = '';
		this._faceIndex = '';
		this._shakeDuration = 0;
		this._baseX = x;
		this._needFaceRefresh = false;
		this._hideCount = 0;
	};

	Window_MapHpGauge.prototype.lineHeight = function () {
		return this._lineHeight || 36;
	};

	Window_MapHpGauge.prototype.standardPadding = function () {
		return 0;
	};

	Window_MapHpGauge.prototype.setShake = function (power) {
		this._shakeDuration = power;
	};

	Window_MapHpGauge.prototype.update = function () {
		Window_Base.prototype.update.call(this);
		if (this.updateVisibility()) {
			this.open();
			if (this.isNeedRefresh()) {
				var actor = $gameParty.leader();
				for (var i = 0; i < gauges.length; i++) {
					this._gaugeVisible[i] = $gameSystem.isVisibleMapHpGauges(i);
					var gauge = gauges[i];
					if (gauge.type === 'HP') {
						this._gaugeParams[i].param = actor.hp;
						this._gaugeParams[i].max = actor.mhp;
					} else if (gauge.type === 'MP') {
						this._gaugeParams[i].param = actor.mp;
						this._gaugeParams[i].max = actor.mmp;
					} else if (gauge.type === 'TP') {
						this._gaugeParams[i].param = actor.tp;
						this._gaugeParams[i].max = actor.maxTp();
					} else if (gauge.type === 'LV') {
						this._gaugeParams[i].param = actor.currentExp();
						this._gaugeParams[i].max = actor.nextLevelExp();
						this._gaugeParams[i].subParam = actor.level;
					} else if (gauge.type === 'VN') {
						this._gaugeParams[i].param = $gameVariables.value(gauge.param);
						this._gaugeParams[i].max = $gameVariables.value(gauge.max);
					}
				}
				this._icons = actor.stateIcons().concat(actor.buffIcons());
				this._gold = $gameParty.gold();
				this._actorId = actor.actorId();
				this._faceName = actor.faceName();
				this._faceIndex = actor.faceIndex();
				this.refresh();
			}
			this.updateShake();
			this.updateOpacity();
		} else {
			this.close();
		}
	};

	Window_MapHpGauge.prototype.updateVisibility = function () {
		if (!$gameSystem.isVisibleMapHpGauge()) {
			return false;
		}
		if ($gameParty.inBattle()) {
			return true;
		}
		if ((eventBusyHide && $gameMap.isEventRunning()) ||
			(messageBusyHide && $gameMessage.isBusy())) {
			this._hideCount++;
		} else {
			this._hideCount = 0;
		}
		return this._hideCount < 10 && $gameParty.leader();
	};

	Window_MapHpGauge.prototype.isNeedRefresh = function () {
		var actor = $gameParty.leader();
		if (actor) {
			var result = false;
			if (this._actorId !== actor.actorId()) {
				this.setShake(1);
				return true;
			}
			for (var i = 0; i < gauges.length; i++) {
				if (this._gaugeVisible[i] !== $gameSystem.isVisibleMapHpGauges(i)) {
					result = true;
				}
				var gauge = gauges[i];
				var gaugeParam = this._gaugeParams[i];
				if (gauge.type === 'HP') {
					if (gaugeParam.param !== actor.hp || gaugeParam.max !== actor.mhp) {
						if (gaugeParam.param > actor.hp) {
							this.setShake(shakeTime);
						}
						result = true;
					}
				} else if (gauge.type === 'MP') {
					if (gaugeParam.param !== actor.mp || gaugeParam.max !== actor.mmp) {
						result = true;
					}
				} else if (gauge.type === 'TP') {
					if (gaugeParam.param !== actor.tp || gaugeParam.max !== actor.maxTp()) {
						result = true;
					}
				} else if (gauge.type === 'LV') {
					if (gaugeParam.param !== actor.currentExp() ||
						gaugeParam.max !== actor.nextLevelExp() ||
						gaugeParam.subParam !== actor.level) {
						result = true;
					}
				} else if (gauge.type === 'VN') {
					if (gaugeParam.param !== $gameVariables.value(gauge.param) ||
						gaugeParam.max !== $gameVariables.value(gauge.max)) {
						result = true;
					}
				}
			}
			if (stateIconMax > 0) {
				var icons = actor.stateIcons().concat(actor.buffIcons());
				if (this._icons.toString() !== icons.toString()) {
					result = true;
				}
			}
			if (goldWidth > 0 && this._gold !== $gameParty.gold()) {
				result = true;
			}
		}
		if (this._needFaceRefresh) {
			this.refreshFace();
			if (!this._needFaceRefresh) {
				result = true;
			}
		}
		return result;
	};

	Window_MapHpGauge.prototype.updateShake = function () {
		if (this._shakeDuration > 0) {
			this._shakeDuration--;
			this.x = this._baseX;
			if (this._shakeDuration > 0) {
				this.x += Math.floor(Math.sin((this._shakeDuration % 10) * Math.PI / 5) * 8);
			}
		}
	};

	Window_MapHpGauge.prototype.updateOpacity = function () {
		if (this.x < $gamePlayer.screenX() + 24 &&
			this.x + gaugeWindowWidth > $gamePlayer.screenX() - 24 &&
			this.y < $gamePlayer.screenY() &&
			this.y + gaugeWindowHeight > $gamePlayer.screenY() - 48) {
			this.opacity = Math.min(collideOpacity, windowOpacity);
			this.contentsOpacity = collideOpacity;
		} else {
			this.opacity = windowOpacity;
			this.contentsOpacity = 255;
		}
	};

	Window_MapHpGauge.prototype.refresh = function () {
		this.contents.clear();
		var actor = $gameParty.leader();
		if (actor) {
			this.refreshFace();
			for (var i = 0; i < gauges.length; i++) {
				if (!$gameSystem.isVisibleMapHpGauges(i)) {
					continue;
				}
				var gauge = gauges[i];
				this._lineHeight = gauge.height;
				this.contents.fontSize = gauge.fontSize;
				if (gauge.type === 'HP') {
					this.drawActorHp(actor, gauge.x, gauge.y, gauge.width);
				} else if (gauge.type === 'MP') {
					this.drawActorMp(actor, gauge.x, gauge.y, gauge.width);
				} else if (gauge.type === 'TP') {
					this.drawActorTp(actor, gauge.x, gauge.y, gauge.width);
				} else if (gauge.type === 'LV') {
					this.drawLvGauge(actor, gauge);
				} else if (gauge.type === 'VN') {
					this.drawVnGauge(this._gaugeParams[i], gauge);
				}
			}
			for (var i = 0; i < stateIconMax; i++) {
				if (!this._icons[i]) break;
				var x = stateIconX + i * Math.floor(Window_Base._iconWidth * stateIconScale / 100);
				this.drawIcon(this._icons[i], x, stateIconY);
			}
			if (goldWidth > 0) {
				this.drawCurrencyValue(this._gold, TextManager.currencyUnit, goldX, goldY, goldWidth);
			}
			this._lineHeight = 36;
		}
	};

	Window_MapHpGauge.prototype.drawIcon = function (iconIndex, x, y) {
		var bitmap = ImageManager.loadSystem('IconSet');
		var pw = Window_Base._iconWidth;
		var ph = Window_Base._iconHeight;
		var sx = iconIndex % 16 * pw;
		var sy = Math.floor(iconIndex / 16) * ph;
		var dw = Math.floor(pw * stateIconScale / 100);
		var dh = Math.floor(ph * stateIconScale / 100);
		var lastPaintOpacity = this.contents.paintOpacity;
		this.contents.paintOpacity = stateIconOpacity;
		this.contents.blt(bitmap, sx, sy, pw, ph, x, y, dw, dh);
		this.contents.paintOpacity = lastPaintOpacity;
	};

	Window_MapHpGauge.prototype.drawLvGauge = function (actor, gauge) {
		if (actor.isMaxLevel()) {
			var value1 = '-------';
			var value2 = '-------';
			var rate = 1;
		} else {
			var n = actor.currentLevelExp();
			var value1 = actor.currentExp() - n;
			var value2 = actor.nextLevelExp() - n;
			var rate = value1 / value2;
		}
		this.drawGauge(gauge.x, gauge.y, gauge.width, rate, gauge.color[0], gauge.color[1]);
		this.changeTextColor(this.systemColor());
		this.drawText(TextManager.levelA, gauge.x, gauge.y, 44);
		var color = this.normalColor();
		this.changeTextColor(color);
		var width = this.textWidth(TextManager.levelA) + 4;
		this.drawText(actor.level, gauge.x + width, gauge.y, 44)
		width = gauge.width - width - this.textWidth('' + actor.level);
		this.drawCurrentAndMax(value1, value2, gauge.x + gauge.width - width, gauge.y, width, color, color);
	};

	Window_MapHpGauge.prototype.drawVnGauge = function (params, gauge) {
		var rate = params.max === 0 ? 0 : params.param / params.max;
		this.drawGauge(gauge.x, gauge.y, gauge.width, rate, gauge.color[0], gauge.color[1]);
		this.changeTextColor(this.systemColor());
		this.drawText(gauge.name, gauge.x, gauge.y, this.textWidth(gauge.name));
		this.changeTextColor(this.normalColor());
		if (vnMax) {
			this.drawVnCurrentAndMax(gauge.name, params.param, params.max, gauge.x, gauge.y, gauge.width);
		} else {
			this.drawText(params.param, gauge.x + gauge.width - 64, gauge.y, 64, 'right');
		}
	};

	Window_MapHpGauge.prototype.drawVnCurrentAndMax = function (name, current, max, x, y, width) {
		var labelWidth = this.textWidth(name);
		var valueWidth = this.textWidth('0' + max);
		var slashWidth = this.textWidth('/');
		var x1 = x + width - valueWidth;
		var x2 = x1 - slashWidth;
		var x3 = x2 - valueWidth;
		this.changeTextColor(this.normalColor());
		if (x3 >= x + labelWidth) {
			this.drawText(current, x3, y, valueWidth, 'right');
			this.drawText('/', x2, y, slashWidth, 'right');
			this.drawText(max, x1, y, valueWidth, 'right');
		} else {
			this.drawText(current, x1, y, valueWidth, 'right');
		}
	};

	Window_MapHpGauge.prototype.refreshFace = function () {
		if (faceOffsetX === -1000) {
			return;
		}
		var actor = $gameParty.leader();
		var bitmap = ImageManager.loadFace(actor.faceName());
		this._needFaceRefresh = bitmap.width === 0;
		if (!this._needFaceRefresh) {
			var x = gaugeWindowWidth - 144 + faceOffsetX;
			var y = faceOffsetY;
			var height = Math.min(gaugeWindowHeight, 144);
			this.drawFace(actor.faceName(), actor.faceIndex(), x, y, 144, height);
		}
	};

	//-----------------------------------------------------------------------------
	// Scene_Base
	//

	Scene_Base.prototype.createMapHpGaugeWindow = function () {
		this._mapHpGaugeWindow = new Window_MapHpGauge();
		this.addChild(this._mapHpGaugeWindow);
	};

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

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

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

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

	//-----------------------------------------------------------------------------
	// Scene_Battle
	//

	var _Scene_Battle_createDisplayObjects = Scene_Battle.prototype.createDisplayObjects;
	Scene_Battle.prototype.createDisplayObjects = function () {
		_Scene_Battle_createDisplayObjects.call(this);
		if (useBattleScene) {
			this.createMapHpGaugeWindow();
		}
	};

	var _Scene_Battle_terminate = Scene_Battle.prototype.terminate;
	Scene_Battle.prototype.terminate = function () {
		_Scene_Battle_terminate.call(this);
		if (this._mapHpGaugeWindow) {
			this.removeChild(this._mapHpGaugeWindow);
		}
	};

})();


code:
//=============================================================================
// TMVplugin - レベル上限操作
// 作者: tomoaky (http://hikimoki.sakura.ne.jp/)
// Version: 1.0
// 最終更新日: 2015/12/29
//=============================================================================

/*:
 * @plugindesc v1.0.1 レベル上限をゲーム中に増やすことができます。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param maxMaxLevel
 * @text レベル上限
 * @type number
 * @min 1
 * @max 99
 * @desc 加算値込みのレベル上限
 * 初期値: 99
 * @default 99
 *
 * @help
 * プラグインコマンド:
 * gainMaxLevel 1 5
 *      # アクター１番のレベル上限を５増やす
 * getMaxLevel 2 10
 *      # アクター２番のレベル上限を変数１０番に代入
 * getMaxLevelPlus 2 3
 *      # アクター２番のレベル上限(加算値)を変数３番に代入
 *
 * v1.0.1 プラグインパラメーターの調整と、ヘルプの誤字を修正 by ムノクラ
 */

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

(function () {

  var parameters = PluginManager.parameters('TMMaxLevel');
  var maxMaxLevel = parameters['maxMaxLevel'];

  //-----------------------------------------------------------------------------
  // 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 === 'gainMaxLevel') {
      var actor = $gameActors.actor(args[0]);
      if (actor) {
        actor.gainMaxLevel(Number(args[1]));
      }
    } else
      if (command === 'getMaxLevel') {
        var actor = $gameActors.actor(args[0]);
        if (actor) {
          $gameVariables.setValue(args[1], actor.maxLevel())
        }
      }
    if (command === 'getMaxLevelPlus') {
      var actor = $gameActors.actor(args[0]);
      if (actor) {
        if (actor._maxLevelPlus === undefined) {
          actor.gainMaxLevel(0);
        }
        $gameVariables.setValue(args[1], actor._maxLevelPlus)
      }
    }
  };

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

  var _Game_Actor_initMembers = Game_Actor.prototype.initMembers;
  Game_Actor.prototype.initMembers = function () {
    _Game_Actor_initMembers.call(this);
    this._maxLevelPlus = 0;
  };

  var _Game_Actor_maxLevel = Game_Actor.prototype.maxLevel;
  Game_Actor.prototype.maxLevel = function () {
    if (this._maxLevelPlus === undefined) {
      this._maxLevelPlus = 0;
    }
    return _Game_Actor_maxLevel.call(this) + this._maxLevelPlus;
  };

  Game_Actor.prototype.gainMaxLevel = function (n) {
    if (this._maxLevelPlus === undefined) {
      this._maxLevelPlus = 0;
    }
    this._maxLevelPlus += n;
    var m = maxMaxLevel - this.actor().maxLevel;
    this._maxLevelPlus = this._maxLevelPlus.clamp(0, m);
  };

})();


code:
//=============================================================================
// TMVplugin - マインスウィーパ
// 作者: tomoaky (http://hikimoki.sakura.ne.jp/)
// Version: 0.11b
// 最終更新日: 2016/03/04
//=============================================================================

/*:
 * @plugindesc 有名な地雷撤去ゲームっぽいものを追加します。
 *
 * @author tomoaky (http://hikimoki.sakura.ne.jp/)
 *
 * @param mineSweeperCommand
 * @desc 『選択肢の表示』コマンドで使用するマインスウィーパ起動文字列。
 * 初期値: [マインスウィーパ]
 * @default [マインスウィーパ]
 *
 * @param bombSe
 * @desc 地雷爆発時に鳴らす効果音（ファイル名 音量 ピッチ パン）
 * 初期値: Explosion2 90 100 0
 * @default Explosion2 90 100 0
 *
 * @param clearSe
 * @desc 地雷撤去完了時に鳴らす効果音（ファイル名 音量 ピッチ パン）
 * 初期値: Applause1 90 100 0
 * @default Applause1 90 100 0
 *
 * @requiredAssets img/system/MineSweeper
 *
 * @help
 * 準備:
 *   画像ファイル MineSweeper.png を img/system フォルダに置いてください。
 *   このプラグインの配布元ページで一緒に配布しています。
 *
 * 使い方:
 *   イベントコマンド『選択肢の表示』の選択肢１番に [マインスウィーパ] と
 *   入力することでマインスウィーパが起動します。（括弧は半角です）
 *   選択肢２番には以下の５つの数値を半角スペースで区切って入力します。
 *   ・横に並ぶマスの数
 *   ・縦に並ぶマスの数
 *   ・マス１つの幅（ドット数）
 *   ・マス１つの高さ（ドット数）
 *   ・地雷の数
 *   例）14 8 32 32 20
 *   この例では１つが32*32ドットのマスを横に１４、縦に８、計１１２個並べ、
 *   そのうち２０個のマスに地雷が隠されている状態でスタートします。
 *
 *   地雷の埋まっていないマスをすべて調査すれば選択肢１番の処理が実行されます。
 *   また、途中で地雷のあるマスを調査してしまった場合は２番が実行されます。
 *
 *   選択肢３番に半角数字で制限時間を設定することができます。
 *   入力した秒数が経過するとマインスウィーパが強制終了し、
 *   選択肢３番の処理が実行されます。
 *
 * プラグインコマンド:
 *   mineTime 1       # 直前のマインスウィーパの所要時間を変数１番に代入
 *
 *   mineTime コマンドで得られる値の単位はミリ秒になっていますので、
 *   秒に変換したい場合はイベントコマンド『変数の操作』を使い、この値を
 *   1000 で割ってください。
 *
 *   mineTime で得られる結果は直前に実行されたマインスウィーパのものになります。
 *   また、マインスウィーパとプラグインコマンド実行までの間に
 *   セーブ＆ロードをはさむと結果が取得できなくなります。
 *
 * 注意事項:
 *   『文章の表示』コマンドの直後にマインスウィーパを起動した場合、
 *   メッセージウィンドウが閉じずにそのままマインスウィーパが起動します。
 *   メッセージウィンドウを閉じてからマインスウィーパを起動したい場合は
 *   『文章の表示』と『選択肢の表示』の間に『ウェイト』を 1 フレーム以上
 *   入れてください。
 *
 *   また、マインスウィーパウィンドウの上下位置はメッセージウィンドウの
 *   上下位置に影響を受けるので、背景が透明で内容が空のメッセージウィンドウを
 *   使えばマインスウィーパウィンドウの上下位置を変更することができます。
 *
 */

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

(function () {

  var parameters = PluginManager.parameters('TMMineSweeper');
  var mineSweeperCommand = parameters['mineSweeperCommand'];
  var a = parameters['bombSe'].split(' ');
  var bombSe = { name: a[0], volume: a[1], pitch: a[2], pan: a[3] };
  var a = parameters['clearSe'].split(' ');
  var clearSe = { name: a[0], volume: a[1], pitch: a[2], pan: a[3] };

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

  var _Game_Temp_initialize = Game_Temp.prototype.initialize;
  Game_Temp.prototype.initialize = function () {
    _Game_Temp_initialize.call(this);
    this._mineTime = 0;
  };

  Game_Temp.prototype.setMineScore = function (time) {
    this._mineTime = time;
  };

  Game_Temp.prototype.mineTime = function () {
    return this._mineTime;
  };

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

  var _Game_Message_clear = Game_Message.prototype.clear;
  Game_Message.prototype.clear = function () {
    _Game_Message_clear.call(this);
    this._mineWidth = 0;
    this._mineHeight = 0;
    this._mineCellWidth = 0;
    this._mineCellHeight = 0;
    this._mineTimeLimit = 0;
    this._mineNumber = 0;
  };

  Game_Message.prototype.mineWidth = function () {
    return this._mineWidth;
  };

  Game_Message.prototype.mineHeight = function () {
    return this._mineHeight;
  };

  Game_Message.prototype.mineCellWidth = function () {
    return this._mineCellWidth;
  };

  Game_Message.prototype.mineCellHeight = function () {
    return this._mineCellHeight;
  };

  Game_Message.prototype.mineNumber = function () {
    return this._mineNumber;
  };

  Game_Message.prototype.setMine = function (choices, cancelType) {
    var a = choices[1].split(' ');
    this._mineWidth = Number(a[0]);
    this._mineHeight = Number(a[1]);
    this._mineCellWidth = Number(a[2]);
    this._mineCellHeight = Number(a[3]);
    this._mineNumber = Number(a[4]);
    this._mineTimeLimit = choices[2] ? Number(choices[2]) * 1000 : 0;
    this._choiceCancelType = cancelType;
  };

  Game_Message.prototype.isMineSweeper = function () {
    return this._mineWidth > 0;
  };

  var _Game_Message_isBusy = Game_Message.prototype.isBusy;
  Game_Message.prototype.isBusy = function () {
    return (_Game_Message_isBusy.call(this) || this.isMineSweeper());
  };

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

  var _Game_Interpreter_setupChoices = Game_Interpreter.prototype.setupChoices;
  Game_Interpreter.prototype.setupChoices = function (params) {
    var choices = params[0].clone();
    if (choices[0] === mineSweeperCommand) {
      var cancelType = params[1];
      var defaultType = params.length > 2 ? params[2] : 0;
      var positionType = params.length > 3 ? params[3] : 2;
      var background = params.length > 4 ? params[4] : 0;
      if (cancelType >= choices.length) {
        cancelType = -2;
      }
      $gameMessage.setMine(choices, cancelType);
      $gameMessage.setChoiceBackground(background);
      $gameMessage.setChoicePositionType(positionType);
      $gameMessage.setChoiceCallback(function (n) {
        this._branch[this._indent] = n;
      }.bind(this));
    } else {
      _Game_Interpreter_setupChoices.call(this, params);
    }
  };

  var _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    if (command === 'mineTime') {
      $gameVariables.setValue(Number(args[0]), $gameTemp.mineTime());
    } else {
      _Game_Interpreter_pluginCommand.call(this, command, args);
    }
  };

  //-----------------------------------------------------------------------------
  // Window_MineSweeper
  //

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

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

  Window_MineSweeper.prototype.initialize = function (messageWindow) {
    this._messageWindow = messageWindow;
    Window_Selectable.prototype.initialize.call(this, 0, 0, 0, 0);
    this.openness = 0;
    this.deactivate();
  };

  Window_MineSweeper.prototype.maxCols = function () {
    return this._mineWidth || 1;
  };

  Window_MineSweeper.prototype.maxItems = function () {
    return this._mineCellNumber || 0;
  };

  Window_MineSweeper.prototype.spacing = function () {
    return 0;
  };

  Window_MineSweeper.prototype.isCursorMovable = function () {
    return Window_Selectable.prototype.isCursorMovable &&
      this._mineState === -1;
  };

  Window_MineSweeper.prototype.start = function () {
    this._mineWidth = $gameMessage.mineWidth();
    this._mineHeight = $gameMessage.mineHeight();
    this._mineCellWidth = $gameMessage.mineCellWidth();
    this._mineCellHeight = $gameMessage.mineCellHeight();
    this._mineNumber = $gameMessage.mineNumber();
    this._mineCellNumber = this._mineWidth * this._mineHeight;
    this.clearMine();
    this._mineState = -1;
    this._mineStartTime = new Date();
    this._lastRefreshTime = this._mineStartTime;
    this._sweepCount = 0;
    this.updatePlacement();
    this.updateBackground();
    this.select(0);
    this.refresh();
    this.open();
    this.activate();
  };

  Window_MineSweeper.prototype.clearMine = function () {
    this._mineMap = [];
    for (var i = 0; i < this._mineCellNumber; i++) {
      this._mineMap[i] = { value: 0, mine: 0, flag: false, sweeped: false };
    }
  };

  Window_MineSweeper.prototype.setupMine = function () {
    var a = [];
    for (var i = 0; i < this._mineCellNumber; i++) {
      a[i] = i;
    }
    for (var i = -1; i < 2; i++) {
      if ((i >= 0 || this.index() % this._mineWidth > 0) &&
        (i < 1 || this.index() % this._mineWidth < this._mineWidth - 1)) {
        for (var j = -1; j < 2; j++) {
          var index = this.index() + i + this._mineWidth * j;
          if (this.isIndexValid(index)) {
            a.splice(a.indexOf(index), 1);
          }
        }
      }
    }
    for (var i = 0; i < this._mineNumber; i++) {
      var index = a.splice(Math.randomInt(a.length), 1)[0];
      this._mineMap[index].mine = 1;
      for (var j = -1; j < 2; j++) {
        this.increaseMineCount(index + this._mineWidth * j);
        if (index % this._mineWidth > 0) {
          this.increaseMineCount(index - 1 + this._mineWidth * j);
        }
        if (index % this._mineWidth < this._mineWidth - 1) {
          this.increaseMineCount(index + 1 + this._mineWidth * j);
        }
      }
    }
  };

  Window_MineSweeper.prototype.increaseMineCount = function (index) {
    if (this.isIndexValid(index)) {
      this._mineMap[index].value++;
    }
  };

  Window_MineSweeper.prototype.isIndexValid = function (index) {
    return index >= 0 && index < this._mineCellNumber;
  };

  Window_MineSweeper.prototype.updatePlacement = function () {
    var positionType = $gameMessage.choicePositionType();
    var messageY = this._messageWindow.y;
    this.width = this.windowWidth();
    this.height = this.windowHeight();
    switch (positionType) {
      case 0:
        this.x = 0;
        break;
      case 1:
        this.x = (Graphics.boxWidth - this.width) / 2;
        break;
      case 2:
        this.x = Graphics.boxWidth - this.width;
        break;
    }
    if (messageY >= Graphics.boxHeight / 2) {
      this.y = messageY - this.height;
    } else {
      this.y = messageY + this._messageWindow.height;
    }
  };

  Window_MineSweeper.prototype.updateBackground = function () {
    this._background = $gameMessage.choiceBackground();
    this.setBackgroundType(this._background);
  };

  Window_MineSweeper.prototype.windowWidth = function () {
    var width = $gameMessage.mineWidth() * $gameMessage.mineCellWidth() +
      this.padding * 2;
    return Math.min(width, Graphics.boxWidth);
  };

  Window_MineSweeper.prototype.windowHeight = function () {
    return this.fittingHeight($gameMessage.mineHeight()) + 36;
  };

  Window_MineSweeper.prototype.update = function () {
    var lastIndex = this.index();
    Window_Selectable.prototype.update.call(this);
    if (this.active) {
      if (this._mineState === -1) {
        this.updateTime();
      } else if (Input.isTriggered('ok') || (TouchInput.isTriggered())) {
        $gameMessage.onChoice(this._mineState);
        this.endMineSweeper();
        SoundManager.playOk();
      } else if (Input.isTriggered('escape') || (TouchInput.isCancelled())) {
        $gameMessage.onChoice(this._mineState);
        this.endMineSweeper();
        SoundManager.playCancel();
      }
      if (lastIndex !== this.index()) {
        this.redrawItem(lastIndex);
        this.redrawItem(this.index());
      }
    }
  };

  Window_MineSweeper.prototype.updateTime = function () {
    var currentTime = new Date();
    if (currentTime - this._lastRefreshTime > 1000) {
      this.refreshTime();
      this._lastRefreshTime = currentTime;
    }
  };

  Window_MineSweeper.prototype.gameOver = function (state) {
    this._mineState = state;
    var time = new Date();
    $gameTemp.setMineScore(time - this._mineStartTime);
    if (this._mineState >= 1) {
      for (var i = 0; i < this._mineCellNumber; i++) {
        var data = this._mineMap[i];
        if (data.mine && !data.sweeped) {
          this._mineMap[i].sweeped = true;
          this.redrawItem(i);
        }
      }
      AudioManager.playSe(bombSe);
    } else {
      AudioManager.playSe(clearSe);
    }
  };

  Window_MineSweeper.prototype.endMineSweeper = function () {
    this._messageWindow.terminateMessage();
    this.deactivate();
    this.close();
  };

  Window_MineSweeper.prototype.drawItem = function (index) {
    var rect = this.itemRect(index);
    var bitmap = ImageManager.loadSystem('MineSweeper');
    var data = this._mineMap[index];
    var sx = 12;
    if (data.sweeped) {
      if (data.mine) {
        sx = 8 + data.mine;
      } else {
        sx = data.value;
      }
    }
    this.contents.blt(bitmap, sx * 32, 0, 32, 32, rect.x, rect.y,
      rect.width, rect.height);
    if (data.flag) {
      this.contents.blt(bitmap, 416, 0, 32, 32, rect.x, rect.y,
        rect.width, rect.height);
    }
    if (index === this.index()) {
      this.contents.blt(bitmap, 448, 0, 32, 32, rect.x, rect.y,
        rect.width, rect.height);
    }
  };

  Window_MineSweeper.prototype.refresh = function () {
    this.createContents();
    this.drawAllItems();
    this.refreshTime();
  };

  Window_MineSweeper.prototype.refreshTime = function () {
    var time = new Date();
    time -= this._mineStartTime;
    if ($gameMessage._mineTimeLimit) {
      time = $gameMessage._mineTimeLimit - time;
      if (time < 0) {
        time = 0;
        this.gameOver(2);
      }
    }
    var width = this.contents.width - this.textPadding();
    var height = 36;
    var y = this.contents.height - height;
    this.contents.clearRect(0, y, width, height);
    this.drawText(Math.floor(time / 1000) + ' 秒', 0, y, width, 'right');
  };

  Window_MineSweeper.prototype.isCurrentItemEnabled = function () {
    return this.index() >= 0 && !this._mineMap[this.index()].sweeped;
  };

  Window_MineSweeper.prototype.isOkEnabled = function () {
    return true;
  };

  Window_MineSweeper.prototype.isCancelEnabled = function () {
    return true;
  };

  Window_MineSweeper.prototype.processOk = function () {
    if (this._mineState === -1) {
      Window_Selectable.prototype.processOk.call(this);
    }
  };

  Window_MineSweeper.prototype.callOkHandler = function () {
    if (this._sweepCount === 0) {
      this.setupMine();
    }
    this._mineSweepTargets = [this.index()];
    while (this._mineSweepTargets.length > 0) {
      this.sweep(this._mineSweepTargets.pop());
    }
    if (this._mineState === -1) {
      this.checkGameComplete();
    }
    this.activate();
  };

  Window_MineSweeper.prototype.sweep = function (index) {
    var data = this._mineMap[index];
    if (data.mine) {
      this.gameOver(1);
      this._mineMap[index].mine = 2;
    }
    this._mineMap[index].sweeped = true;
    this._mineMap[index].flag = false;
    this._sweepCount++;
    this.redrawItem(index);
    if (data.value > 0) {
      return;
    }
    this.addSweepTarget(index - this._mineWidth);
    this.addSweepTarget(index + this._mineWidth);
    for (var i = -1; i < 2; i++) {
      if (index % this._mineWidth > 0) {
        this.addSweepTarget(index - 1 + this._mineWidth * i);
      }
      if (index % this._mineWidth < this._mineWidth - 1) {
        this.addSweepTarget(index + 1 + this._mineWidth * i);
      }
    }
  };

  Window_MineSweeper.prototype.addSweepTarget = function (index) {
    if (index >= 0 && index < this._mineCellNumber &&
      this._mineSweepTargets.indexOf(index) === -1 &&
      !this._mineMap[index].sweeped) {
      this._mineSweepTargets.push(index);
    }
  };

  Window_MineSweeper.prototype.checkGameComplete = function (index) {
    if (this._sweepCount === this._mineCellNumber - this._mineNumber) {
      this.gameOver(0);
    }
  };

  Window_MineSweeper.prototype.processCancel = function () {
    if (this._mineState === -1) {
      Window_Selectable.prototype.processCancel.call(this);
    }
  };

  Window_MineSweeper.prototype.callCancelHandler = function () {
    if (this.index() >= 0 && !this._mineMap[this.index()].sweeped) {
      this._mineMap[this.index()].flag = !this._mineMap[this.index()].flag;
      this.redrawItem(this.index());
    } else {
      SoundManager.playBuzzer();
    }
    this.activate();
  };
  //-----------------------------------------------------------------------------
  // Window_Message
  //

  var _Window_Message_subWindows = Window_Message.prototype.subWindows;
  Window_Message.prototype.subWindows = function () {
    return _Window_Message_subWindows.call(this).concat(this._mineSweeperWindow);
  };

  var _Window_Message_createSubWindows = Window_Message.prototype.createSubWindows;
  Window_Message.prototype.createSubWindows = function () {
    _Window_Message_createSubWindows.call(this);
    this._mineSweeperWindow = new Window_MineSweeper(this);
  };

  var _Window_Message_isAnySubWindowActive = Window_Message.prototype.isAnySubWindowActive;
  Window_Message.prototype.isAnySubWindowActive = function () {
    return (_Window_Message_isAnySubWindowActive.call(this) ||
      this._mineSweeperWindow.active);
  };

  var _Window_Message_startInput = Window_Message.prototype.startInput;
  Window_Message.prototype.startInput = function () {
    if ($gameMessage.isMineSweeper()) {
      this._mineSweeperWindow.start();
      return true;
    }
    return _Window_Message_startInput.call(this);
  };

  //-----------------------------------------------------------------------------
  // Scene_Boot
  //

  var _Scene_Boot_loadSystemImages = Scene_Boot.prototype.loadSystemImages;
  Scene_Boot.prototype.loadSystemImages = function () {
    _Scene_Boot_loadSystemImages.call(this);
    ImageManager.loadSystem('MineSweeper');
  };

})();


code:
//=============================================================================
// TMPlugin - ぽよウィンドウ
// バージョン: 1.0.0
// 最終更新日: 2016/10/21
// 配布元    : 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 openSpeed
 * @desc ウィンドウが開く速度。
 * 初期値: 16
 * @default 16
 *
 * @help
 * 使い方:
 *
 *   ウィンドウのオープン演出の最後が少しやわらかくなります。
 *   プラグインを導入していない状態と比べて、完全に開くまでの時間が
 *   倍になっています。
 *   プラグインパラメータ openSpeed を 32 にすると同じ時間になります。
 *
 *   タイトルコマンドやメッセージウィンドウなど、元々オープン演出のある
 *   一部のウィンドウのみが対象となります。
 *
 *   プラグインコマンドはありません。
 *
 *   このプラグインは RPGツクールMV Version 1.3.2 で動作確認をしています。
 */

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

var TMPlugin = TMPlugin || {};
TMPlugin.PoyoWindow = {};
TMPlugin.PoyoWindow.Parameters = PluginManager.parameters('TMPoyoWindow');
TMPlugin.PoyoWindow.OpenSpeed = +(TMPlugin.PoyoWindow.Parameters['openSpeed'] || 16);

(function () {

  //-----------------------------------------------------------------------------
  // Window
  //

  Object.defineProperty(Window.prototype, 'openness', {
    get: function () {
      return this._openness;
    },
    set: function (value) {
      if (this._openness !== value) {
        this._openness = value.clamp(0, 255);
        if (this._opening) {
          if (this._openness < 64) {
            this._windowSpriteContainer.scale.y = this._openness / 64;
            this._windowSpriteContainer.y = this.height / 2 * (1 - this._openness / 64);
          } else {
            if (this._openness === 255) {
              var scale = 1;
            } else {
              var scale = 1 + Math.sin(Math.PI * ((this._openness - 64) / 96)) * 0.3;
            }
            this._windowSpriteContainer.scale.y = scale;
            this._windowSpriteContainer.y = this.height / 2 * (1 - scale);
          }
        } else {
          this._windowSpriteContainer.scale.y = this._openness / 255;
          this._windowSpriteContainer.y = this.height / 2 * (1 - this._openness / 255);
        }
      }
    },
    configurable: true
  });

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

  Window_Base.prototype.updateOpen = function () {
    if (this._opening) {
      this.openness += TMPlugin.PoyoWindow.OpenSpeed;
      if (this.isOpen()) {
        this._opening = false;
      }
    }
  };

})();