code:
/*:
 * @plugindesc タグをつけたイベントの一覧を表示し、選択したイベントを実行します。
 * @author hiz
 *
 * @param Window Position
 * @desc イベント一覧の表示位置を設定します。（left:左端 right:右端）
 * @default left
 *
 * @param Window Sort
 * @desc イベント一覧の並び順を設定します。（id:イベントID dist:主人公からの距離 x:X座標 y:Y座標）
 * @default id
 *
 * @param Show Range
 * @desc 主人公から一定範囲のイベントのみを対象とする場合に、範囲の表示有無を設定します。（0:表示しない 1:表示する）
 *
 * @help
 * タグをつけたイベントの一覧を表示し、選択したイベントを実行します。
 * イベントの選択方法は、イベント名の一覧から選択する方法と直接選択する方法の二種類から選択できます。
 *
 * スクリプトコマンド
 *   hzChoiceEvent list [tag] [varNo] [resetScroll] [maxDist]
 *                                          # [tag]（必須）で指定したタグのついたイベント名の一覧を表示し、
 *                                          # 選択されたイベントを起動します。
 *                                          # [varNo]（必須）には、初期選択するイベントのIDおよび選択されたイベントのIDを
 *                                          # 保管する変数の番号を指定します。（イベント選択がキャンセルされた場合、-1がセットされます）
 *                                          # [resetScroll]（任意）は、イベント起動前にスクロール位置を主人公の位置に戻すか否かを指定します。
 *                                          # true:戻す false:戻さない（指定しなかった場合、true）
 *                                          # [maxDist]（任意）は、主人公から一定範囲のイベントのみを対象とする場合に指定します。
 *                                          # 指定した値分のタイルを半径とする円内のイベントのみをイベント一覧に表示します。
 *
 *   hzChoiceEvent cursor [tag] [varNo] [resetScroll] [maxDist]
 *                                          # [tag]（必須）で指定したタグのついたイベントをカーソルで選択し、
 *                                          # 選択されたイベントを起動します。
 *                                          # パラメータは上記「hzChoiceEvent list」と同様です。
 *
 *   hzResetScroll                          # スクロール位置を主人公の位置に戻します。
 *                                          # hzChoiceEventにて[resetScroll]をfalseに設定した際、
 *                                          # 手動でスクロール位置を主人公の位置に戻すために使用します。
 *
 *  例）
 *   hzChoiceEvent list land 1              # タグ「land」のイベント名一覧を表示し、
 *                                          # 選択されたイベントを起動します。
 *                                          # 選択されたイベントの番号は変数1に保管されます。
 *
 *   hzChoiceEvent cursor chest 1 false 5   # 半径5マス以内のタグ「chest」のイベントをカーソルで選択し、
 *                                          # 選択されたイベントを起動します。
 *                                          # ※ [resetScroll]にfalseを指定しているため起動後はスクロール位置は戻りません。
 *                                          #   起動されたイベント側で「hzResetScroll」を呼び出す必要があります。
 *                                          # 選択されたイベントの番号は変数1に保管されます。
 *
 *   hzResetScroll                          # スクロール位置を主人公の位置に戻します。
 *                                          # 起動されたイベント側で呼び出します。
 *
 * イベントメモ：
 *   <hzChoice:[tag]>                       # イベントに[tag]タグを付けます。
 *   <hzChoice:[tag],[condition]>           # イベントに[tag]タグを付けます。選択条件を満たす場合のみ、
 *                                          # イベントが選択対象となります。
 *
 *【選択条件（[condition]）の設定方法】
 *   選択条件には、スイッチとイベントのセルフスイッチを使用できます。
 *   ・特定のスイッチONを条件とする場合、スイッチの番号[1-9999]を指定します。
 *   ・特定のセルフスイッチONを条件とする場合、スイッチのID[A-D]を指定します。
 *   ・スイッチ・セルフスイッチOFFを条件とする場合、先頭に!(ビックリマーク)をつけます。
 *   例）
 *   　<hzChoice:tag>                        # タグ「tag」を無条件で付与。
 *   　<hzChoice:tag,31>                     # スイッチ31がONの場合、タグ「tag」を付与。
 *   　<hzChoice:tag,B>                      # セルフスイッチBがONの場合、タグ「tag」を付与。
 *   　<hzChoice:tag,!25>                    # スイッチ25がOFFの場合、タグ「tag」を付与。
 *   　<hzChoice:tag,!D>                     # セルフスイッチDがOFFの場合、タグ「tag」を付与。
 *
 * 【注意点】
 * 　「hzChoiceEvent」を実行するイベントでは、「hzChoiceEvent」実行後はそのまま処理を終了させて下さい。
 * 　別のコマンドを実行すると、選択したイベントの起動が正しく行われない場合があります。
 *   「hzChoiceEvent」の実行を繰り返し行いたい場合は、セルフスイッチと自動実行を使用して、
 *   イベント終了後に再度「hzChoiceEvent」のイベントが実行されるように設定して下さい。
 *
 * 【使用素材】
 * ・矢印デザイン様(http://yajidesign.com/)のカーソルアイコン素材を使用しています。
 *
 * 【修正履歴】
 * 　・2017/02/05 ツクールMV v1.3.4に対応
 *
 */

function HzChoiceEvent(){}

(function() {
    function convertEscape(txt) {return Window_Base.prototype.convertEscapeCharacters(txt)};

    var TYPE_LIST = 'list';
    var TYPE_CURSOR = 'cursor';

    var parameters = PluginManager.parameters('HzChoiceEvent');
    var windowPosition = String(parameters['Window Position'] || 'left');
    var windowSort = String(parameters['Window Sort'] || 'id');
    var showRange = parameters['Show Range'] != null ? parameters['Show Range'] : 1;

    //-----------------------------------------------------------------------------
    // 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.toUpperCase() === 'HZCHOICEEVENT') {
			this.setWaitMode("hzChoiceEvent");
            var type           = args[0];
            var tag            = convertEscape(args[1]);
            var resultVarNo    = convertEscape(args[2]);
            var resetScroll    = args[3] == 'false' ? false : true;
            var maxDist        = !!args[4] ? Number(convertEscape(args[4])) : null;
			this._hzChoceEvent = new HzChoiceEvent(tag, resultVarNo, resetScroll, maxDist, type);
        } else if(command.toUpperCase() === 'HZRESETSCROLL') {
            scrollToPlayer();
        }
    };

    // 待機状態の更新用関数に機能追加
    var _Game_Interpreter_updateWaitMode = Game_Interpreter.prototype.updateWaitMode;
    Game_Interpreter.prototype.updateWaitMode = function() {
        var waiting = null;
        switch (this._waitMode) {
        case 'hzChoiceEvent':
            // 待機状態の更新
            // ※ waitingには必ずtrueかfalseをセットすること！
            waiting = this._hzChoceEvent.update();
            if(!waiting) {
                // 終了処理
                this._hzChoceEvent.terminate();
                this._hzChoceEvent = null;
            }
            break;
        }
        if (waiting !== null) {
            if(!waiting) {
                this._waitMode = '';
            }
            return waiting;
        }
        return _Game_Interpreter_updateWaitMode.call(this);
    };

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

    //-----------------------------------------------------------------------------
    // HzChoiceEvent
    //

    // 初期化処理
    HzChoiceEvent.prototype.initialize = function(tag, resultVarNo, resetScroll, maxDist, type) {
        this._resultVarNo = resultVarNo;
        this._resetScroll = resetScroll;
        this._maxDist = maxDist;
        this._type = type;

        // 選択対象のイベントを取得
        this._choiceEvents = $gameMap.events().filter(function(event) {
            // 特定の変数がON/OFFの場合のみ選択対象に含める
            // 特定のセルフ変数がON/OFFの場合のみ選択対象に含める
            // 一定の距離内のイベントのみ選択対象に含める
            if(maxDist != null) {
                if(Math.sqrt((event.x - $gamePlayer.x) * (event.x - $gamePlayer.x) +
                             (event.y - $gamePlayer.y) * (event.y - $gamePlayer.y)) > maxDist) {
                             return false;
                             };
            }

            var hzChoice = event.event().meta.hzChoice;

            if(hzChoice == null) {
                return false;
            } else if(hzChoice.indexOf(',') < 0) {
                return tag == hzChoice.trim();
            } else {
                var parms = hzChoice.split(',');
                var condVariable = parms[1].trim();

                var not = false;
                var variable;
                if(condVariable.startsWith('!')) {
                    not = true;
                    variable = condVariable.substr(1);
                } else {
                    variable = condVariable;
                }

                if(variable == 'A' || variable == 'B' || variable == 'C' || variable == 'D') {
                    // セルフスイッチ
                    var key = [$gameMap.mapId(), event.eventId(), variable];
                    console.log($gameSelfSwitches.value(key));
                    if($gameSelfSwitches.value(key) != !not) return false;
                } else {
                    // スイッチ
                    if($gameSwitches.value(Number(variable)) != !not) return false;
                }
                return parms[0].trim() == tag;
            }
            return false;
        });

        this._cancelCount = -1;
        this._forceCancel = false;
        if(this._choiceEvents.length == 0) {
            this._forceCancel = true;
            return;
        }

        // 変数の値が1以上の場合、IDが一致するイベントを初期選択
        var preEvent;
        if(this._resultVarNo > 0) {
            var eventId = $gameVariables.value(this._resultVarNo);
            var event = $gameMap.event(eventId);
            var index = this._choiceEvents.indexOf(event);
            if(index >= 0) {
                preEvent = this._choiceEvents[index];
            }
        }
        if(preEvent) {
            this._selectedEvent = preEvent;
        } else {
            if(type === TYPE_LIST) {
                if(windowSort === 'id') {
                    // ソートしない
                } else if(windowSort === 'dist') {
                    // 主人公からの距離でソート
                    this._choiceEvents.sort(sortByDistancePlayer);
                } else if(windowSort === 'x') {
                    // X座標でソート
                    this._choiceEvents.sort(function(e1, e2) {
                        if(e1.x < e2.x) return -1;
                        if(e1.x > e2.x) return 1;
                        return e1.y < e2.y ? -1 : 1;
                    });
                } else if(windowSort === 'y') {
                    // Y座標でソート
                    this._choiceEvents.sort(function(e1, e2) {
                        if(e1.y < e2.y) return -1;
                        if(e1.y > e2.y) return 1;
                        return e1.x < e2.x ? -1 : 1;
                    });
                }
                this._selectedEvent = this._choiceEvents[0];
            } else if(type === TYPE_CURSOR) {
                // 主人公からの距離でソート
                this._choiceEvents.sort(sortByDistancePlayer);
                // 主人公から最も近いイベントを選択
                this._selectedEvent = this._choiceEvents[0];
            }
        }

        this.startScroll(this._selectedEvent, 10);

        if(type === TYPE_LIST) {
            // 一覧選択の場合、イベント一覧ウインドウを作成
            var window = SceneManager._scene._hzChoiceEventWindow;
            window.setEvents(this._choiceEvents);
            for(var i=0;i<this._choiceEvents.length;i++) {
                if(this._choiceEvents[i].eventId() == this._selectedEvent.eventId()) {
                    window.setSelectedIndex(i);
                    break;
                }
            }
            window.activate();
            window.show();

            window.setHandler('ok', this.processWindowOk.bind(this));
            window.setHandler('cancel', this.processWindowCancel.bind(this));
            // カーソル移動時に表示を更新
            window.setHandler('select', this.processWindowSelect.bind(this));
        }
        this._decided = false;
    };

    // 更新処理（終了時はfalseを返す）
    HzChoiceEvent.prototype.update = function() {
        var self = this;

        if(this._decided || this._forceCancel) {
            return false;
        }

        if(this._cancelCount >= 0) {
            if(this._cancelCount == 0) {
                // 結果変数に0をセット
                $gameVariables.setValue(this._resultVarNo, 0);
                // プレイヤーの位置までスクロール
                scrollToPlayer();
                return false;
            }
            this._cancelCount --;
        }

        // スクロール
        this.updateScroll();

        var ok     = false;
        var cancel = false;
        var left   = false;
        var right  = false;
        var up     = false;
        var down   = false;

        if(this._type === TYPE_CURSOR) {
            // カーソル選択の場合

            // キーボード入力
            if(Input.isTriggered('ok')     ) ok     = true;
            if(Input.isTriggered('cancel') ) cancel = true;
            if(Input.isTriggered ('left')  ) left   = true;
            if(Input.isTriggered ('right') ) right  = true;
            if(Input.isTriggered ('up')    ) up     = true;
            if(Input.isTriggered ('down')  ) down   = true;

            // タッチ入力
            if(TouchInput.isCancelled()) cancel = true;
            if(TouchInput.isTriggered()) {
                var x = $gameMap.canvasToMapX(TouchInput.x);
                var y = $gameMap.canvasToMapY(TouchInput.y);
                var events = $gameMap.eventsXy(x, y);
                var self = this;
                var choiceEvents = events.filter(function(event) {
                    return self._choiceEvents.indexOf(event) >= 0;
                });
                if(choiceEvents.length > 0) {
                    // イベントをタッチした場合、そのイベントを選択してOKボタン押下時処理実施
                    this._selectedEvent = choiceEvents[0];
                    ok = true;
                } else {
                    // イベント以外をタッチした場合、タッチ位置に応じて上下左右に移動
                    var xrate = (TouchInput.x - Graphics.width  / 2) / Graphics.width;
                    var yrate = (TouchInput.y - Graphics.height / 2) / Graphics.height;
                    if(Math.abs(xrate) < Math.abs(yrate)) {
                        if(yrate < 0) up = true;
                        else down = true;
                    } else {
                        if(xrate < 0) left = true;
                        else right = true;
                    }
                }
            }

            // イベント選択
            if(ok) {
                this.processOk();
                return false;
            }

            // キャンセル
            if(cancel) {
                this.processCancel();
                return true;
            }

            // カーソル選択

            if(left) {
                // カーソル左側の最も近いイベントを選択
                var sortedEvents = this._choiceEvents.filter(function(event) {
                    if(event === self._selectedEvent) return false;
                    var dx = event.x - self._selectedEvent.x;
                    var dy = event.y - self._selectedEvent.y;
                    return dx < 0 && Math.abs(dy/3) < Math.abs(dx);
                }).sort(createEventSort(this._selectedEvent, true));
                if(sortedEvents != null && sortedEvents.length > 0) {
                    this._selectedEvent = sortedEvents[0];
                    // イベントの位置にスクロール
                    this.startScroll(this._selectedEvent,10);
                    SoundManager.playCursor();
                } else {
                    SoundManager.playBuzzer();
                }

            } else if(right) {
                // カーソル右側の最も近いイベントを選択
                var sortedEvents = this._choiceEvents.filter(function(event) {
                    if(event === self._selectedEvent) return false;
                    var dx = event.x - self._selectedEvent.x;
                    var dy = event.y - self._selectedEvent.y;
                    return dx > 0 && Math.abs(dy/3) < Math.abs(dx);
                }).sort(createEventSort(this._selectedEvent, true));
                if(sortedEvents != null && sortedEvents.length > 0) {
                    this._selectedEvent = sortedEvents[0];
                    // イベントの位置にスクロール
                    this.startScroll(this._selectedEvent,10);
                    SoundManager.playCursor();
                } else {
                    SoundManager.playBuzzer();
                }
            } else if(up) {
                // カーソル上側の最も近いイベントを選択
                var sortedEvents = this._choiceEvents.filter(function(event) {
                    if(event === self._selectedEvent) return false;
                    var dx = event.x - self._selectedEvent.x;
                    var dy = event.y - self._selectedEvent.y;
                    return dy < 0 && Math.abs(dx/3) < Math.abs(dy);
                }).sort(createEventSort(this._selectedEvent, false));
                if(sortedEvents != null && sortedEvents.length > 0) {
                    this._selectedEvent = sortedEvents[0];
                    // イベントの位置にスクロール
                    this.startScroll(this._selectedEvent,10);
                    SoundManager.playCursor();
                } else {
                    SoundManager.playBuzzer();
                }
            } else if(down) {
                // カーソル下側の最も近いイベントを選択
                var sortedEvents = this._choiceEvents.filter(function(event) {
                    if(event === self._selectedEvent) return false;
                    var dx = event.x - self._selectedEvent.x;
                    var dy = event.y - self._selectedEvent.y;
                    return dy > 0 && Math.abs(dx/3) < Math.abs(dy);
                }).sort(createEventSort(this._selectedEvent, false));
                if(sortedEvents != null && sortedEvents.length > 0) {
                    this._selectedEvent = sortedEvents[0];
                    // イベントの位置にスクロール
                    this.startScroll(this._selectedEvent,10);
                    SoundManager.playCursor();
                } else {
                    SoundManager.playBuzzer();
                }
            }
        }

        // UIのクリア
        var bitmap = SceneManager._scene._spriteset._hzChoiceScreen.bitmap;
        bitmap.clear();
        // フォント設定
        var ctx = SceneManager._scene._spriteset._hzChoiceScreen.bitmap.context;
        ctx.textAlign = "center";
        ctx.textBaseLine = "middle";

        // 範囲表示
        if(showRange == 1 && this._maxDist != null) {
            ctx.fillStyle   = "rgba(255,255,255,0.1)";
            ctx.strokeStyle = "rgba(255,255,255,1.0)";
            ctx.beginPath();
            ctx.arc($gamePlayer.screenX(),$gamePlayer.screenY(), (this._maxDist + 0.5) * $gameMap.tileWidth(),0,2*Math.PI);
            ctx.stroke();
            ctx.fill();
        }

        // イベント毎の描画
        this._choiceEvents.forEach(function(ev, idx) {
            var event = ev.event();
            var x = ev.screenX();
            var y = ev.screenY() - 64;

            var w = 90;
            var alpha = 0.5;
            ctx.font = '12px "GameFont"';
            if(ev === self._selectedEvent) {
                alpha = 0.8;
                ctx.font = '16px "GameFont"';
                w = 120;
            }

            // イベント名描画
            if(event.name) {
                // 枠描画
                ctx.fillStyle   = "rgba(255,255,255," + alpha + ")";
                ctx.strokeStyle = "rgba(255,255,255," + alpha + ")";

                roundedRectangle(ctx, x-w/2, y-14, w, 18, 6);
                ctx.fill();

                // イベント名描画
                ctx.fillStyle   = "rgba(0,0,0,1.0)";
                ctx.fillText(event.name, x, y);
            }

            // 矢印描画
            ctx.fillStyle   = "rgba(255,255,255," + alpha + ")";
            drawTriangle(ctx, x, y+12, 12, -8);
            ctx.fill();

            // カーソル描画
            if(ev === self._selectedEvent) {
                ctx.save();
                ctx.fillStyle   = "rgba(255,255,255,1.0)";
                ctx.translate(ev.screenX()-12, ev.screenY()-24);
                drawCursor(ctx);
                ctx.restore();
            }
        });
        return true;
    };

    // 決定時の処理
    HzChoiceEvent.prototype.processOk = function() {
        // イベント起動
        this._selectedEvent.start();
        // 結果変数にイベントIDをセット
        $gameVariables.setValue(this._resultVarNo, this._selectedEvent.eventId());
        // プレイヤーの位置までスクロール
        if(this._resetScroll) {
            scrollToPlayer();
        }
        this._decided = true;
    };

    // イベント一覧ウインドウでの決定時処理
    HzChoiceEvent.prototype.processWindowOk = function() {
        var window = SceneManager._scene._hzChoiceEventWindow;
        window.deactivate();
        window.hide();
        this.processOk();
    };

    // キャンセル時の処理
    HzChoiceEvent.prototype.processCancel = function() {
        this._cancelCount = 1;
        SoundManager.playCancel();
    };

    // イベント一覧ウインドウでのキャンセル時処理
    HzChoiceEvent.prototype.processWindowCancel = function() {
        var window = SceneManager._scene._hzChoiceEventWindow;
        window.deactivate();
        window.hide();
        this.processCancel();
        this._cancelCount = 0;
    };

    // イベント一覧ウインドウでの行選択時処理
    HzChoiceEvent.prototype.processWindowSelect = function() {
        var window = SceneManager._scene._hzChoiceEventWindow;
        this._selectedEvent = this._choiceEvents[window._index];
        this.startScroll(this._selectedEvent,1);
    };

     // 終了処理
    HzChoiceEvent.prototype.terminate = function() {
        var bitmap = SceneManager._scene._spriteset._hzChoiceScreen.bitmap;
        bitmap.clear();
    };

    // プレイヤーからの距離でソート
    function sortByDistancePlayer(e1, e2) {
        var dist1 =  (e1.x - $gamePlayer.x) * (e1.x - $gamePlayer.x) +
                     (e1.y - $gamePlayer.y) * (e1.y - $gamePlayer.y);
        var dist2 =  (e2.x - $gamePlayer.x) * (e2.x - $gamePlayer.x) +
                     (e2.y - $gamePlayer.y) * (e2.y - $gamePlayer.y);
        if(dist1 < dist2) return -1;
        if(dist1 > dist2) return  1;
        return 0;
    }

    // 特定の対象からの距離でソート
    function createEventSort(origin, horz) {
        return function(e1, e2) {
            var dist1, dist2;
            if(horz) {
                dist1 =  Math.abs(e1.x - origin.x) * 0.5 +
                         Math.abs(e1.y - origin.y);
                dist2 =  Math.abs(e2.x - origin.x) * 0.5 +
                         Math.abs(e2.y - origin.y);
            } else {
                dist1 =  Math.abs(e1.x - origin.x) +
                         Math.abs(e1.y - origin.y) * 0.5;
                dist2 =  Math.abs(e2.x - origin.x) +
                         Math.abs(e2.y - origin.y) * 0.5;
            }
            if(dist1 < dist2) return -1;
            if(dist1 > dist2) return  1;
            return 0;
        };
    }

    // 特定のイベントまでスクロール開始
    HzChoiceEvent.prototype.startScroll = function(event, frame) {
        this._scrollSpeedX = 0;
        this._scrollSpeedY = 0;
        this._scrollCount = 0;

        var dx = event.x - ($gameMap.displayX() + (Graphics.boxWidth  / $gameMap.tileWidth() ) / 2);
        var dy = event.y - ($gameMap.displayY() +(Graphics.boxHeight / $gameMap.tileHeight()) / 2);
        if(dx != 0) {
            this._scrollCount = frame;
            this._scrollSpeedX = dx / this._scrollCount;
        }
        if(dy != 0) {
            this._scrollCount = frame;
            this._scrollSpeedY = dy / this._scrollCount;
        }
    };

    // スクロール更新
    HzChoiceEvent.prototype.updateScroll = function() {
        this._scrollCount --;
        if(this._scrollCount >= 0) {
            if(this._scrollSpeedX > 0) {
                $gameMap.scrollRight(Math.abs(this._scrollSpeedX));
            } else if(this._scrollSpeedX < 0) {
                $gameMap.scrollLeft(Math.abs(this._scrollSpeedX));
            }
            if(this._scrollSpeedY > 0) {
                $gameMap.scrollDown(Math.abs(this._scrollSpeedY));
            } else if(this._scrollSpeedY < 0) {
                $gameMap.scrollUp(Math.abs(this._scrollSpeedY));
            }
        }
    };

    // プレイヤーの位置までスクロール
    function scrollToPlayer() {
        var dx = $gamePlayer.x - ($gameMap.displayX() + (Graphics.boxWidth  / $gameMap.tileWidth() ) / 2);
        var dy = $gamePlayer.y - ($gameMap.displayY() +(Graphics.boxHeight / $gameMap.tileHeight()) / 2);
        if(dx > 0) {
            $gameMap.scrollRight(Math.abs(dx));
        } else if(dx < 0) {
            $gameMap.scrollLeft(Math.abs(dx));
        }
        if(dy > 0) {
            $gameMap.scrollDown(Math.abs(dy));
        } else if(dy < 0) {
            $gameMap.scrollUp(Math.abs(dy));
        }
    };

    //-----------------------------------------------------------------------------
    // Window_EventList
    //
    // イベント選択用ウインドウ

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

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

    // 初期化処理
    Window_EventList.prototype.initialize = function(x, y, width, height) {
        this._listevents = [];
        Window_Selectable.prototype.initialize.call(this, x, y, width, height);
        this.deactivate();
        this.hide();
    };

    // イベント一覧の設定
    Window_EventList.prototype.setEvents = function(events) {
        this._listevents = events;
        this.refresh();
    };

    // 選択行の設定
    Window_EventList.prototype.setSelectedIndex = function(index) {
        this._index = index;
        this.refresh();
    };

    // 項目数
    Window_EventList.prototype.maxItems = function() {
        return this._listevents.length;
    };

    // 列数
    Window_EventList.prototype.maxCols = function() {
        return 1;
    };

    // 項目の描画
    Window_EventList.prototype.drawItem = function(index) {
        var event = this._listevents[index].event();
        var rect = this.itemRect(index);
        this.resetTextColor();
        this.drawText(event.name, rect.x, rect.y, rect.width);
    };

    // 行選択
    Window_EventList.prototype.select = function(index) {
        Window_Selectable.prototype.select.call(this, index);
        this.callHandler('select');
    };

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

    // マップのSpriteSetに選択UI表示用のSpriteを追加
    var _Spriteset_Map_createUpperLayer = Spriteset_Map.prototype.createUpperLayer;
    Spriteset_Map.prototype.createUpperLayer = function() {
        _Spriteset_Map_createUpperLayer.call(this);
        this._hzChoiceScreen = new Sprite();
        this._hzChoiceScreen.bitmap = new Bitmap(Graphics.boxWidth, Graphics.boxHeight);
        this.addChild(this._hzChoiceScreen);
    };

    //-----------------------------------------------------------------------------
    // Scene_Map
    //
    // The scene class of the map screen.

    // イベント選択ウインドウを追加
    var _Scene_Map_createAllWindows = Scene_Map.prototype.createAllWindows;
    Scene_Map.prototype.createAllWindows = function() {
        _Scene_Map_createAllWindows.call(this);
        var w = 200;
        var x = windowPosition == 'left' ? 0 : Graphics.boxWidth - w;
        this._hzChoiceEventWindow = new Window_EventList(x, 0, w, Graphics.boxHeight);
        this.addWindow(this._hzChoiceEventWindow);
    };

    //-----------------------------------------------------------------------------
    // 描画用関数
    //

    // 三角形を描画
    function drawTriangle(ctx, x, y, triangleWidth, triangleHeight){
        ctx.beginPath();
        ctx.moveTo(x, y);
        ctx.lineTo(x + triangleWidth / 2, y + triangleHeight);
        ctx.lineTo(x - triangleWidth / 2, y + triangleHeight);
        ctx.closePath();
    }

    // 角丸長方形を描画
    function roundedRectangle(ctx, left, top, width, height, borderRadius) {
        ctx.beginPath();
        ctx.moveTo(left + borderRadius, top);
        ctx.lineTo(left + width - borderRadius, top);
        ctx.quadraticCurveTo(left + width, top, left + width, top + borderRadius);
        ctx.lineTo(left + width, top + height - borderRadius);
        ctx.quadraticCurveTo(left + width, top + height, left + width - borderRadius, top + height);
        ctx.lineTo(left + borderRadius, top + height);
        ctx.quadraticCurveTo(left, top + height, left, top + height - borderRadius);
        ctx.lineTo(left, top + borderRadius);
        ctx.quadraticCurveTo(left, top, left + borderRadius, top);
        ctx.closePath();
    }

    // カーソルを描画
    // ※ 矢印デザイン様(http://yajidesign.com/)のカーソルアイコン素材を使用
    function drawCursor(ctx) {
        // #g3
        ctx.save();
        ctx.transform(0.288098, 0.000000, 0.000000, 0.288098, -29.876393, -7.580578);

        // #path5
        ctx.beginPath();
        ctx.fillStyle = 'rgb(53, 53, 53)';
        ctx.moveTo(105.853000, 29.093000);
        ctx.bezierCurveTo(105.816000, 27.569000, 105.486000, 26.186000, 104.906000, 25.001000);
        ctx.bezierCurveTo(104.040000, 23.215000, 102.623000, 21.935000, 101.090000, 21.162000);
        ctx.bezierCurveTo(99.551000, 20.382000, 97.897000, 20.060000, 96.326000, 20.058000);
        ctx.lineTo(58.264000, 20.058000);
        ctx.bezierCurveTo(59.280000, 19.246000, 60.204000, 18.407000, 61.022000, 17.536000);
        ctx.bezierCurveTo(62.151000, 16.327000, 63.080000, 15.052000, 63.743000, 13.682000);
        ctx.bezierCurveTo(64.405000, 12.317000, 64.793000, 10.844000, 64.793000, 9.328000);
        ctx.bezierCurveTo(64.797000, 7.724000, 64.349000, 6.102000, 63.489000, 4.599000);
        ctx.bezierCurveTo(62.544000, 2.928000, 61.230000, 1.713000, 59.798000, 0.987000);
        ctx.bezierCurveTo(58.363000, 0.258000, 56.857000, 0.000000, 55.468000, 0.000000);
        ctx.bezierCurveTo(54.058000, 0.002000, 52.748000, 0.258000, 51.614000, 0.603000);
        ctx.bezierCurveTo(50.476000, 0.954000, 49.527000, 1.385000, 48.790000, 1.826000);
        ctx.bezierCurveTo(47.695000, 2.482000, 37.691000, 8.474000, 27.753000, 14.295000);
        ctx.bezierCurveTo(22.785000, 17.204000, 17.830000, 20.073000, 14.024000, 22.204000);
        ctx.bezierCurveTo(12.124000, 23.269000, 10.505000, 24.151000, 9.341000, 24.752000);
        ctx.bezierCurveTo(8.759000, 25.052000, 8.287000, 25.282000, 7.980000, 25.418000);
        ctx.bezierCurveTo(7.920000, 25.445000, 7.872000, 25.465000, 7.828000, 25.483000);
        ctx.bezierCurveTo(5.932000, 25.483000, 2.200000, 25.483000, 2.200000, 25.483000);
        ctx.bezierCurveTo(1.621000, 25.483000, 1.054000, 25.717000, 0.645000, 26.128000);
        ctx.bezierCurveTo(0.234000, 26.536000, 0.000000, 27.103000, 0.000000, 27.682000);
        ctx.lineTo(0.000000, 71.446000);
        ctx.bezierCurveTo(0.000000, 72.025000, 0.234000, 72.592000, 0.645000, 73.002000);
        ctx.bezierCurveTo(1.054000, 73.411000, 1.621000, 73.646000, 2.200000, 73.646000);
        ctx.lineTo(9.807000, 73.646000);
        ctx.bezierCurveTo(9.828000, 73.639000, 10.231000, 73.730000, 10.767000, 73.965000);
        ctx.bezierCurveTo(11.732000, 74.373000, 13.157000, 75.154000, 14.809000, 76.081000);
        ctx.bezierCurveTo(17.297000, 77.475000, 20.334000, 79.202000, 23.611000, 80.603000);
        ctx.bezierCurveTo(26.891000, 81.998000, 30.423000, 83.095000, 34.014000, 83.102000);
        ctx.bezierCurveTo(34.014000, 83.102000, 53.148000, 83.102000, 54.760000, 83.102000);
        ctx.bezierCurveTo(56.253000, 83.100000, 57.959000, 83.060000, 59.730000, 82.738000);
        ctx.bezierCurveTo(61.054000, 82.495000, 62.421000, 82.090000, 63.737000, 81.396000);
        ctx.bezierCurveTo(65.713000, 80.367000, 67.528000, 78.638000, 68.731000, 76.145000);
        ctx.bezierCurveTo(69.729000, 74.091000, 70.338000, 71.552000, 70.526000, 68.419000);
        ctx.bezierCurveTo(70.849000, 68.344000, 71.178000, 68.246000, 71.519000, 68.112000);
        ctx.bezierCurveTo(72.739000, 67.631000, 74.069000, 66.707000, 75.065000, 65.209000);
        ctx.bezierCurveTo(76.065000, 63.713000, 76.684000, 61.695000, 76.678000, 59.204000);
        ctx.bezierCurveTo(76.680000, 57.493000, 76.344000, 55.996000, 75.770000, 54.751000);
        ctx.bezierCurveTo(75.644000, 54.476000, 75.505000, 54.220000, 75.359000, 53.972000);
        ctx.bezierCurveTo(75.918000, 53.861000, 76.453000, 53.663000, 76.994000, 53.383000);
        ctx.bezierCurveTo(78.203000, 52.738000, 79.409000, 51.650000, 80.320000, 50.069000);
        ctx.bezierCurveTo(81.228000, 48.492000, 81.812000, 46.437000, 81.810000, 43.957000);
        ctx.bezierCurveTo(81.811000, 42.256000, 81.490000, 40.773000, 80.931000, 39.538000);
        ctx.bezierCurveTo(80.861000, 39.383000, 80.784000, 39.240000, 80.707000, 39.095000);
        ctx.lineTo(96.031000, 39.095000);
        ctx.bezierCurveTo(97.131000, 39.094000, 98.265000, 38.948000, 99.383000, 38.607000);
        ctx.bezierCurveTo(101.051000, 38.101000, 102.705000, 37.135000, 103.927000, 35.570000);
        ctx.bezierCurveTo(105.156000, 34.009000, 105.865000, 31.901000, 105.857000, 29.444000);
        ctx.bezierCurveTo(105.856000, 29.326000, 105.855000, 29.209000, 105.853000, 29.093000);
        ctx.fill();

        // #path7
        ctx.beginPath();
        ctx.fillStyle = 'rgb(255, 255, 255)';
        ctx.moveTo(100.971000, 32.016000);
        ctx.bezierCurveTo(100.531000, 32.969000, 99.885000, 33.578000, 99.023000, 34.029000);
        ctx.bezierCurveTo(98.167000, 34.472000, 97.085000, 34.698000, 96.032000, 34.696000);
        ctx.lineTo(59.817000, 34.696000);
        ctx.bezierCurveTo(58.602000, 34.696000, 57.618000, 35.680000, 57.618000, 36.895000);
        ctx.bezierCurveTo(57.618000, 38.110000, 58.602000, 39.094000, 59.817000, 39.094000);
        ctx.bezierCurveTo(59.817000, 39.094000, 66.435000, 39.094000, 74.036000, 39.094000);
        ctx.bezierCurveTo(74.063000, 39.090000, 74.398000, 39.133000, 74.757000, 39.276000);
        ctx.bezierCurveTo(75.315000, 39.492000, 75.967000, 39.895000, 76.470000, 40.574000);
        ctx.bezierCurveTo(76.969000, 41.258000, 77.403000, 42.244000, 77.411000, 43.957000);
        ctx.bezierCurveTo(77.403000, 46.365000, 76.698000, 47.776000, 75.976000, 48.630000);
        ctx.bezierCurveTo(75.614000, 49.055000, 75.234000, 49.338000, 74.928000, 49.499000);
        ctx.bezierCurveTo(74.778000, 49.578000, 74.647000, 49.628000, 74.560000, 49.653000);
        ctx.lineTo(74.469000, 49.674000);
        ctx.lineTo(74.462000, 49.675000);
        ctx.bezierCurveTo(72.791000, 49.675000, 59.963000, 49.675000, 59.963000, 49.675000);
        ctx.bezierCurveTo(58.749000, 49.675000, 57.764000, 50.659000, 57.764000, 51.874000);
        ctx.bezierCurveTo(57.764000, 53.089000, 58.749000, 54.073000, 59.963000, 54.073000);
        ctx.lineTo(67.988000, 54.073000);
        ctx.bezierCurveTo(68.225000, 54.162000, 68.482000, 54.218000, 68.752000, 54.219000);
        ctx.lineTo(68.752000, 54.220000);
        ctx.bezierCurveTo(68.752000, 54.219000, 68.847000, 54.226000, 68.981000, 54.257000);
        ctx.bezierCurveTo(69.219000, 54.311000, 69.577000, 54.432000, 69.941000, 54.630000);
        ctx.bezierCurveTo(70.493000, 54.931000, 71.059000, 55.387000, 71.494000, 56.076000);
        ctx.bezierCurveTo(71.928000, 56.769000, 72.274000, 57.721000, 72.280000, 59.205000);
        ctx.bezierCurveTo(72.280000, 60.400000, 72.089000, 61.282000, 71.833000, 61.936000);
        ctx.bezierCurveTo(71.444000, 62.915000, 70.919000, 63.429000, 70.400000, 63.766000);
        ctx.bezierCurveTo(70.142000, 63.931000, 69.881000, 64.040000, 69.661000, 64.106000);
        ctx.bezierCurveTo(69.442000, 64.173000, 69.256000, 64.190000, 69.201000, 64.189000);
        ctx.lineTo(55.419000, 64.189000);
        ctx.bezierCurveTo(54.204000, 64.189000, 53.220000, 65.173000, 53.220000, 66.388000);
        ctx.bezierCurveTo(53.220000, 67.602000, 54.204000, 68.587000, 55.419000, 68.587000);
        ctx.bezierCurveTo(55.419000, 68.587000, 61.988000, 68.587000, 66.113000, 68.587000);
        ctx.bezierCurveTo(65.952000, 70.714000, 65.560000, 72.363000, 65.043000, 73.620000);
        ctx.bezierCurveTo(64.526000, 74.876000, 63.899000, 75.753000, 63.201000, 76.420000);
        ctx.bezierCurveTo(62.158000, 77.412000, 60.899000, 77.977000, 59.430000, 78.311000);
        ctx.bezierCurveTo(57.969000, 78.641000, 56.336000, 78.706000, 54.760000, 78.704000);
        ctx.lineTo(34.014000, 78.704000);
        ctx.bezierCurveTo(31.955000, 78.707000, 29.669000, 78.189000, 27.361000, 77.356000);
        ctx.bezierCurveTo(23.894000, 76.111000, 20.408000, 74.179000, 17.452000, 72.520000);
        ctx.bezierCurveTo(15.970000, 71.689000, 14.621000, 70.928000, 13.413000, 70.340000);
        ctx.bezierCurveTo(12.806000, 70.045000, 12.234000, 69.794000, 11.664000, 69.599000);
        ctx.bezierCurveTo(11.090000, 69.409000, 10.525000, 69.253000, 9.824000, 69.246000);
        ctx.lineTo(4.398000, 69.246000);
        ctx.lineTo(4.398000, 29.881000);
        ctx.lineTo(8.136000, 29.881000);
        ctx.bezierCurveTo(8.453000, 29.878000, 8.616000, 29.835000, 8.764000, 29.802000);
        ctx.bezierCurveTo(9.040000, 29.734000, 9.223000, 29.661000, 9.432000, 29.579000);
        ctx.bezierCurveTo(9.827000, 29.417000, 10.268000, 29.208000, 10.811000, 28.937000);
        ctx.bezierCurveTo(12.822000, 27.929000, 16.166000, 26.065000, 20.151000, 23.787000);
        ctx.bezierCurveTo(32.079000, 16.961000, 49.570000, 6.486000, 51.053000, 5.597000);
        ctx.bezierCurveTo(51.421000, 5.374000, 52.108000, 5.050000, 52.900000, 4.810000);
        ctx.bezierCurveTo(53.696000, 4.565000, 54.606000, 4.398000, 55.468000, 4.399000);
        ctx.bezierCurveTo(56.324000, 4.400000, 57.114000, 4.557000, 57.796000, 4.906000);
        ctx.bezierCurveTo(58.477000, 5.261000, 59.095000, 5.791000, 59.665000, 6.779000);
        ctx.bezierCurveTo(60.188000, 7.705000, 60.391000, 8.517000, 60.394000, 9.330000);
        ctx.bezierCurveTo(60.392000, 10.098000, 60.203000, 10.894000, 59.782000, 11.769000);
        ctx.bezierCurveTo(59.155000, 13.077000, 57.976000, 14.528000, 56.298000, 15.978000);
        ctx.bezierCurveTo(54.702000, 17.361000, 52.660000, 18.741000, 50.306000, 20.059000);
        ctx.lineTo(42.517000, 20.059000);
        ctx.bezierCurveTo(41.302000, 20.059000, 40.319000, 21.043000, 40.319000, 22.258000);
        ctx.bezierCurveTo(40.319000, 23.473000, 41.302000, 24.457000, 42.517000, 24.457000);
        ctx.lineTo(96.326000, 24.457000);
        ctx.bezierCurveTo(97.608000, 24.452000, 98.946000, 24.837000, 99.846000, 25.559000);
        ctx.bezierCurveTo(100.303000, 25.921000, 100.673000, 26.358000, 100.954000, 26.932000);
        ctx.bezierCurveTo(101.233000, 27.505000, 101.430000, 28.233000, 101.457000, 29.204000);
        ctx.bezierCurveTo(101.458000, 29.285000, 101.459000, 29.364000, 101.459000, 29.442000);
        ctx.bezierCurveTo(101.457000, 30.550000, 101.259000, 31.375000, 100.971000, 32.016000);
        ctx.fill();
        ctx.restore();
    }

})();


code:
//=============================================================================
// ItemBook.js
//=============================================================================

/*:
 * @plugindesc Displays detailed statuses of items.
 * @author Yoji Ojima
 *
 * @param Unknown Data
 * @desc The index name for an unknown item.
 * @default ??????
 *
 * @param Price Text
 * @desc The text for "Price".
 * @default Price
 *
 * @param Equip Text
 * @desc The text for "Equip".
 * @default Equip
 *
 * @param Type Text
 * @desc The text for "Type".
 * @default Type
 *
 * @help
 *
 * Plugin Command:
 *   ItemBook open            # Open the item book screen
 *   ItemBook add weapon 3    # Add weapon #3 to the item book
 *   ItemBook add armor 4     # Add armor #4 to the item book
 *   ItemBook remove armor 5  # Remove armor #5 from the item book
 *   ItemBook remove item 6   # Remove item #6 from the item book
 *   ItemBook complete        # Complete the item book
 *   ItemBook clear           # Clear the item book
 *
 * Item (Weapon, Armor) Note:
 *   <book:no>                # This item does not appear in the item book
 */

/*:ja
 * @plugindesc アイテム図鑑です。アイテムの詳細なステータスを表示します。
 * @author Yoji Ojima
 *
 * @param Unknown Data
 * @desc 未確認のアイテムの索引名です。
 * @default ？？？？？？
 *
 * @param Price Text
 * @desc 「価格」の文字列です。
 * @default 価格
 *
 * @param Equip Text
 * @desc 「装備」の文字列です。
 * @default 装備
 *
 * @param Type Text
 * @desc 「タイプ」の文字列です。
 * @default タイプ
 *
 * @help
 *
 * プラグインコマンド:
 *   ItemBook open            # 図鑑画面を開く
 *   ItemBook add weapon 3    # 武器３番を図鑑に追加
 *   ItemBook add armor 4     # 防具４番を図鑑に追加
 *   ItemBook remove armor 5  # 防具５番を図鑑から削除
 *   ItemBook remove item 6   # アイテム６番を図鑑から削除
 *   ItemBook complete        # 図鑑を完成させる
 *   ItemBook clear           # 図鑑をクリアする
 *
 * アイテム（武器、防具）のメモ:
 *   <book:no>                # 図鑑に載せない場合
 */

(function() {

    var parameters = PluginManager.parameters('ItemBook');
    var unknownData = String(parameters['Unknown Data'] || '??????');
    var priceText = String(parameters['Price Text'] || 'Price');
    var equipText = String(parameters['Equip Text'] || 'Equip');
    var typeText = String(parameters['Type Text'] || 'Type');

    var _Game_Interpreter_pluginCommand =
            Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === 'ItemBook') {
            switch (args[0]) {
            case 'open':
                SceneManager.push(Scene_ItemBook);
                break;
            case 'add':
                $gameSystem.addToItemBook(args[1], Number(args[2]));
                break;
            case 'remove':
                $gameSystem.removeFromItemBook(args[1], Number(args[2]));
                break;
            case 'complete':
                $gameSystem.completeItemBook();
                break;
            case 'clear':
                $gameSystem.clearItemBook();
                break;
            }
        }
    };

    Game_System.prototype.addToItemBook = function(type, dataId) {
        if (!this._ItemBookFlags) {
            this.clearItemBook();
        }
        var typeIndex = this.itemBookTypeToIndex(type);
        if (typeIndex >= 0) {
            this._ItemBookFlags[typeIndex][dataId] = true;
        }
    };

    Game_System.prototype.removeFromItemBook = function(type, dataId) {
        if (this._ItemBookFlags) {
            var typeIndex = this.itemBookTypeToIndex(type);
            if (typeIndex >= 0) {
                this._ItemBookFlags[typeIndex][dataId] = false;
            }
        }
    };

    Game_System.prototype.itemBookTypeToIndex = function(type) {
        switch (type) {
        case 'item':
            return 0;
        case 'weapon':
            return 1;
        case 'armor':
            return 2;
        default:
            return -1;
        }
    };

    Game_System.prototype.completeItemBook = function() {
        var i;
        this.clearItemBook();
        for (i = 1; i < $dataItems.length; i++) {
            this._ItemBookFlags[0][i] = true;
        }
        for (i = 1; i < $dataWeapons.length; i++) {
            this._ItemBookFlags[1][i] = true;
        }
        for (i = 1; i < $dataArmors.length; i++) {
            this._ItemBookFlags[2][i] = true;
        }
    };

    Game_System.prototype.clearItemBook = function() {
        this._ItemBookFlags = [[], [], []];
    };

    Game_System.prototype.isInItemBook = function(item) {
        if (this._ItemBookFlags && item) {
            var typeIndex = -1;
            if (DataManager.isItem(item)) {
                typeIndex = 0;
            } else if (DataManager.isWeapon(item)) {
                typeIndex = 1;
            } else if (DataManager.isArmor(item)) {
                typeIndex = 2;
            }
            if (typeIndex >= 0) {
                return !!this._ItemBookFlags[typeIndex][item.id];
            } else {
                return false;
            }
        } else {
            return false;
        }
    };

    var _Game_Party_gainItem = Game_Party.prototype.gainItem;
    Game_Party.prototype.gainItem = function(item, amount, includeEquip) {
        _Game_Party_gainItem.call(this, item, amount, includeEquip);
        if (item && amount > 0) {
            var type;
            if (DataManager.isItem(item)) {
                type = 'item';
            } else if (DataManager.isWeapon(item)) {
                type = 'weapon';
            } else if (DataManager.isArmor(item)) {
                type = 'armor';
            }
            $gameSystem.addToItemBook(type, item.id);
        }
    };

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

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

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

    Scene_ItemBook.prototype.create = function() {
        Scene_MenuBase.prototype.create.call(this);
        this._indexWindow = new Window_ItemBookIndex(0, 0);
        this._indexWindow.setHandler('cancel', this.popScene.bind(this));
        var wy = this._indexWindow.height;
        var ww = Graphics.boxWidth;
        var wh = Graphics.boxHeight - wy;
        this._statusWindow = new Window_ItemBookStatus(0, wy, ww, wh);
        this.addWindow(this._indexWindow);
        this.addWindow(this._statusWindow);
        this._indexWindow.setStatusWindow(this._statusWindow);
    };

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

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

    Window_ItemBookIndex.lastTopRow = 0;
    Window_ItemBookIndex.lastIndex  = 0;

    Window_ItemBookIndex.prototype.initialize = function(x, y) {
        var width = Graphics.boxWidth;
        var height = this.fittingHeight(6);
        Window_Selectable.prototype.initialize.call(this, x, y, width, height);
        this.refresh();
        this.setTopRow(Window_ItemBookIndex.lastTopRow);
        this.select(Window_ItemBookIndex.lastIndex);
        this.activate();
    };

    Window_ItemBookIndex.prototype.maxCols = function() {
        return 3;
    };

    Window_ItemBookIndex.prototype.maxItems = function() {
        return this._list ? this._list.length : 0;
    };

    Window_ItemBookIndex.prototype.setStatusWindow = function(statusWindow) {
        this._statusWindow = statusWindow;
        this.updateStatus();
    };

    Window_ItemBookIndex.prototype.update = function() {
        Window_Selectable.prototype.update.call(this);
        this.updateStatus();
    };

    Window_ItemBookIndex.prototype.updateStatus = function() {
        if (this._statusWindow) {
            var item = this._list[this.index()];
            this._statusWindow.setItem(item);
        }
    };

    Window_ItemBookIndex.prototype.refresh = function() {
        var i, item;
        this._list = [];
        for (i = 1; i < $dataItems.length; i++) {
            item = $dataItems[i];
            if (item.name && item.itypeId === 1 && item.meta.book !== 'no') {
                this._list.push(item);
            }
        }
        for (i = 1; i < $dataWeapons.length; i++) {
            item = $dataWeapons[i];
            if (item.name && item.meta.book !== 'no') {
                this._list.push(item);
            }
        }
        for (i = 1; i < $dataArmors.length; i++) {
            item = $dataArmors[i];
            if (item.name && item.meta.book !== 'no') {
                this._list.push(item);
            }
        }
        this.createContents();
        this.drawAllItems();
    };

    Window_ItemBookIndex.prototype.drawItem = function(index) {
        var item = this._list[index];
        var rect = this.itemRect(index);
        var width = rect.width - this.textPadding();
        if ($gameSystem.isInItemBook(item)) {
            this.drawItemName(item, rect.x, rect.y, width);
        } else {
            var iw = Window_Base._iconWidth + 4;
            this.drawText(unknownData, rect.x + iw, rect.y, width - iw);
        }
    };

    Window_ItemBookIndex.prototype.processCancel = function() {
        Window_Selectable.prototype.processCancel.call(this);
        Window_ItemBookIndex.lastTopRow = this.topRow();
        Window_ItemBookIndex.lastIndex = this.index();
    };

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

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

    Window_ItemBookStatus.prototype.initialize = function(x, y, width, height) {
        Window_Base.prototype.initialize.call(this, x, y, width, height);
    };

    Window_ItemBookStatus.prototype.setItem = function(item) {
        if (this._item !== item) {
            this._item = item;
            this.refresh();
        }
    };

    Window_ItemBookStatus.prototype.refresh = function() {
        var item = this._item;
        var x = 0;
        var y = 0;
        var lineHeight = this.lineHeight();

        this.contents.clear();

        if (!item || !$gameSystem.isInItemBook(item)) {
            return;
        }

        this.drawItemName(item, x, y);

        x = this.textPadding();
        y = lineHeight + this.textPadding();

        var price = item.price > 0 ? item.price : '-';
        this.changeTextColor(this.systemColor());
        this.drawText(priceText, x, y, 120);
        this.resetTextColor();
        this.drawText(price, x + 120, y, 120, 'right');
        y += lineHeight;

        if (DataManager.isWeapon(item) || DataManager.isArmor(item)) {
            var etype = $dataSystem.equipTypes[item.etypeId];
            this.changeTextColor(this.systemColor());
            this.drawText(equipText, x, y, 120);
            this.resetTextColor();
            this.drawText(etype, x + 120, y, 120, 'right');
            y += lineHeight;

            var type;
            if (DataManager.isWeapon(item)) {
                type = $dataSystem.weaponTypes[item.wtypeId];
            } else {
                type = $dataSystem.armorTypes[item.atypeId];
            }
            this.changeTextColor(this.systemColor());
            this.drawText(typeText, x, y, 120);
            this.resetTextColor();
            this.drawText(type, x + 120, y, 120, 'right');

            x = this.textPadding() + 300;
            y = lineHeight + this.textPadding();
            for (var i = 2; i < 8; i++) {
                this.changeTextColor(this.systemColor());
                this.drawText(TextManager.param(i), x, y, 160);
                this.resetTextColor();
                this.drawText(item.params[i], x + 160, y, 60, 'right');
                y += lineHeight;
            }
        }

        x = 0;
        y = this.textPadding() * 2 + lineHeight * 7;
        this.drawTextEx(item.description, x, y);
    };

})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// KMS_Minimap.js
//  last update: 2019/01/01
//=============================================================================

/*:
 * @plugindesc
 * [v0.2.0] Display minimap.
 *
 * @author TOMY (Kamesoft)
 *
 * @param Map rect
 * @default 524, 32, 260, 200
 * @desc
 * Specify minimap position and its size.
 * Format: X, Y, Width, Height
 *
 * @param Grid size
 * @default 10
 * @desc Grid size of the minimap in pixel.
 *
 * @param Blink time
 * @default 180
 * @desc Blinking interval of icons on the minimap in frames.
 *
 * @param Foreground color
 * @default rgba(224, 224, 240, 0.6)
 * @desc
 * Format: rgba(Red, Green, Blue, Alpha)
 *
 * @param Background color
 * @default rgba(0, 0, 160, 0.6)
 * @desc
 * Format: rgba(Red, Green, Blue, Alpha)
 *
 * @param Mask style
 * @default 0
 * @desc
 * Mask style for minimap.
 * 0: None  1: Ellipse  2: Rounded rectangle  3, 4: Hex
 *
 * @param Mask radius
 * @default 48
 * @desc
 * The radius of each of the corners.
 * (Rounded rectangle style only)
 *
 * @help
 * ## Disable minimap
 *
 * Add <NoMinimap> to the note field in a map, the minimap will be disabled on that map.
 *
 *
 * ## Plugin command
 *
 * Minimap show     # Show minimap. If <NoMinimap> is specified, the minimap can't be shown.
 * Minimap hide     # Hide minimap.
 * Minimap refresh  # Redraw minimap.
 *
 * @requiredAssets img/system/MinimapPlayerIcon
 * @requiredAssets img/system/MinimapObjectIcon
 */

/*:ja
 * @plugindesc
 * [v0.2.0] 画面上にミニマップを表示します。
 *
 * @author TOMY (Kamesoft)
 *
 * @param Map rect
 * @default 524, 32, 260, 200
 * @desc
 * ミニマップの表示位置とサイズをピクセル単位で指定します。
 * 書式: X, Y, 幅, 高さ
 *
 * @param Grid size
 * @default 10
 * @desc ミニマップの 1 マスのサイズをピクセル単位で指定します。
 *
 * @param Blink time
 * @default 180
 * @desc ミニマップ上のアイコンを点滅させる時間をフレーム単位で指定します。
 *
 * @param Foreground color
 * @default rgba(224, 224, 240, 0.6)
 * @desc
 * ミニマップの通行可能領域の色を CSS カラーで指定します。
 * 書式: rgba(赤, 緑, 青, 不透明度)
 *
 * @param Background color
 * @default rgba(0, 0, 160, 0.6)
 * @desc
 * ミニマップの通行不可領域の色を CSS カラーで指定します。
 * 書式: rgba(赤, 緑, 青, 不透明度)
 *
 * @param Mask style
 * @default 0
 * @desc
 * ミニマップの表示領域のマスク方法を指定します。
 * 0: なし  1: 楕円  2: 角丸矩形  3: 六角形1  4: 六角形2
 *
 * @param Mask radius
 * @default 48
 * @desc
 * 角丸矩形マスクを指定した場合の、角の丸め具合を指定します。
 *
 * @help
 * ## ミニマップの非表示
 *
 * マップのメモ欄に <NoMinimap> を追加すると、そのマップではミニマップが表示されなくなります。
 *
 *
 * ## プラグインコマンド
 *
 * Minimap show     # ミニマップを表示します。<NoMinimap> を指定したマップでは表示できません。
 * Minimap hide     # ミニマップを隠します。
 * Minimap refresh  # ミニマップを再描画します。
 *
 * @requiredAssets img/system/MinimapPlayerIcon
 * @requiredAssets img/system/MinimapObjectIcon
 */

var KMS = KMS || {};

(function()
{

'use strict';

KMS.imported = KMS.imported || {};
KMS.imported['Minimap'] = true;

/**
 * 矩形を表す文字列を解析
 */
var parseRect = function(str)
{
    var rectReg = /([-]?\d+),\s*([-]?\d+),\s*([-]?\d+),\s*([-]?\d+)/;
    var rect = new PIXI.Rectangle(524, 32, 260, 200);
    var match = rectReg.exec(str);
    if (match)
    {
        rect.x      = Number(match[1]);
        rect.y      = Number(match[2]);
        rect.width  = Number(match[3]);
        rect.height = Number(match[4]);
    }

    return rect;
};

var pluginParams = PluginManager.parameters('KMS_Minimap');
var Params = {};
Params.mapRect = parseRect(pluginParams['Map rect']);
Params.gridSize = Number(pluginParams['Grid size'] || 10);
Params.blinkTime = Number(pluginParams['Blink time'] || 180);
Params.foregroundColor = pluginParams['Foreground color'] || 'rgba(224, 224, 240, 0.6)';
Params.backgroundColor = pluginParams['Background color'] || 'rgba(  0,   0, 160, 0.6)';
Params.playerIconImage = pluginParams['Player icon'] || 'MinimapPlayerIcon';
Params.objectIconImage = pluginParams['Object icon'] || 'MinimapObjectIcon';
Params.displayTileImage = pluginParams['Display tile'];
Params.maskStyle = Number(pluginParams['Mask style'] || 0);
Params.maskRadius = Number(pluginParams['Mask radius'] || 48);

var Minimap = {};
Minimap.passageCacheCountMax = 5;
Minimap.regex = {
    wallEvent: /<(?:ミニマップ|MINIMAP)\s*[:\s]\s*(?:壁|障害物|WALL)>/i,
    moveEvent: /<(?:ミニマップ|MINIMAP)\s*[:\s]\s*(?:移動|MOVE)>/i,
    person:    /<(?:ミニマップ|MINIMAP)\s*[:\s]\s*(?:人物|PERSON)\s*(\d+)>/i,
    object:    /<(?:ミニマップ|MINIMAP)\s*[:\s]\s*OBJ(?:ECT)?\s*(\d+)>/i
};
Minimap.keysRequireNumber = [ 'person', 'object' ];
Minimap.dirFlags = { down: 0x01, left: 0x02, right: 0x04, up: 0x08 };
Minimap.maskStyles = { none: 0, ellipse: 1, roundedRect: 2, hex1: 3, hex2: 4 };

/**
 * 指定した円に内接する正 n 角形の塗り潰し
 */
var fillRegularPolygon = function(graphics, x, y, width, height, startRad, vertexCount)
{
    if (vertexCount < 1)
    {
        return;
    }

    var points = [];
    for (var i = 0; i < vertexCount; i++)
    {
        var angle = i * Math.PI * 2 / vertexCount - Math.PI / 2 + startRad;
        points.push(x + Math.cos(angle) * width);
        points.push(y + Math.sin(angle) * height);
    }

    graphics.drawPolygon(points);
};

//-----------------------------------------------------------------------------
// Plugin commands

var _KMS_Game_Interpreter_pluginCommand =
        Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function(command, args)
{
    _KMS_Game_Interpreter_pluginCommand.call(this, command, args);

    if (command !== 'Minimap')
    {
        return;
    }

    switch (args[0])
    {
    case 'show':
        $gameSystem.setMinimapEnabled(true);
        break;
    case 'hide':
        $gameSystem.setMinimapEnabled(false);
        break;
    case 'refresh':
        $gameMap.refreshMinimapCache();
        break;
    default:
        // 不明なコマンド
        console.log('[Minimap %1] Unknown command.'.format(args[0]));
        break;
    }
};

//-----------------------------------------------------------------------------
// Tilemap

Tilemap.prototype.getTileCount = function()
{
    return {
        x: Math.ceil(this._width  / this._tileWidth)  + 1,
        y: Math.ceil(this._height / this._tileHeight) + 1
    };
};

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

var _KMS_Game_Temp_initialize = Game_Temp.prototype.initialize;
Game_Temp.prototype.initialize = function()
{
    _KMS_Game_Temp_initialize.call(this);

    this._minimapPassageCache     = [];
    this._minimapCacheRefreshFlag = false;
};

Object.defineProperty(Game_Temp.prototype, 'minimapCacheRefreshFlag', {
    get: function()
    {
        return this._minimapCacheRefreshFlag;
    },
    set: function(value)
    {
        this._minimapCacheRefreshFlag = value;
    },
    configurable: true
});

Game_Temp.prototype.getMinimapPassageCache = function(mapId)
{
    return null;
};

/**
 * 通行可否キャッシュの登録
 */
Game_Temp.prototype.registerMinimapPassageCache = function(mapId, passage)
{
    // 最新のキャッシュは先頭に置く
    var newCache = [ { mapId: mapId, passage: passage } ].concat(
        this._minimapPassageCache.filter(function(cache)
        {
            return cache.mapId !== mapId;
        }));

    // しばらく参照されていないキャッシュは消す
    this._minimapPassageCache = newCache.slice(0, Minimap.passageCacheCountMax);
};

/**
 * 通行可否キャッシュの取得
 */
Game_Temp.prototype.getMinimapPassageCache = function(mapId)
{
    for (var i = 0; i < this._minimapPassageCache.length; i++)
    {
        var tempCache = this._minimapPassageCache[i];
        if (tempCache.mapId !== mapId)
        {
            continue;
        }

        if (i > 0)
        {
            // 取得したキャッシュは先頭に移す
            this.registerMinimapPassageCache(mapId, tempCache);

        }
        return tempCache;
    }

    return null;
};

/**
 * 通行可否キャッシュをクリア
 */
Game_Temp.prototype.clearMinimapPassageCache = function(mapId)
{
    this._minimapPassageCache     = [];
    this._minimapCacheRefreshFlag = true;
};

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

/**
 * ミニマップの有効状態を取得
 */
Game_System.prototype.isMinimapEnabled = function()
{
    return this._minimapEnabled != null ? this._minimapEnabled : true;
};

/**
 * ミニマップの有効状態を設定
 */
Game_System.prototype.setMinimapEnabled = function(enabled)
{
    this._minimapEnabled = !!enabled;
};

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

var _KMS_Game_Map_setup = Game_Map.prototype.setup;
Game_Map.prototype.setup = function(mapId)
{
    _KMS_Game_Map_setup.call(this, mapId);

    this.setupMinimap();
};

/**
 * ミニマップに関する設定
 */
Game_Map.prototype.setupMinimap = function()
{
    this._minimapEnabled = !$dataMap.meta.NoMinimap;
};

/**
 * ミニマップの表示可否を取得
 */
Game_Map.prototype.isMinimapEnabled = function()
{
    return this._minimapEnabled;
};

/**
 * ミニマップのキャッシュを再構築
 */
Game_Map.prototype.refreshMinimapCache = function()
{
    $gameTemp.clearMinimapPassageCache();
};

//-----------------------------------------------------------------------------
// Game_Character

Game_Character.prototype.isMinimapAttributeDirty = function()
{
    // 何もしない
};

Game_Character.prototype.setMinimapAttributeDirty = function()
{
    // 何もしない
};

Game_Character.prototype.clearMinimapAttributeDirty = function()
{
    // 何もしない
};

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

var _KMS_Game_Event_setupPage = Game_Event.prototype.setupPage;
Game_Event.prototype.setupPage = function()
{
    _KMS_Game_Event_setupPage.call(this);

    this.setupMinimapAttribute();
};

/**
 * ミニマップ用属性の設定
 */
Game_Event.prototype.setupMinimapAttribute = function()
{
    this._minimapAttribute = { dirty: true, wall: false, move: false, person: -1, object: -1 };

    var isComment = function(command)
    {
        return command && (command.code === 108 || command.code === 408);
    };

    // 注釈以外に達するまで解析
    var page = this.page();
    if (!page)
    {
        return;
    }

    var commands = page.list;
    var index    = 0;
    var command  = commands[index++];
    while (isComment(command))
    {
        var comment = command.parameters[0];

        this._minimapAttribute.wall |= Minimap.regex.wallEvent.test(comment);
        this._minimapAttribute.move |= Minimap.regex.moveEvent.test(comment);
        Minimap.keysRequireNumber.forEach(function(key)
        {
            var match = Minimap.regex[key].exec(comment);
            if (match)
            {
                this._minimapAttribute[key] = Number(match[1]);
            }
        }, this);

        command = commands[index++];
    }
};

Game_Event.prototype.isMinimapAttributeDirty = function()
{
    return this._minimapAttribute.dirty;
};

Game_Event.prototype.setMinimapAttributeDirty = function()
{
    this._minimapAttribute.dirty = true;
};

Game_Event.prototype.clearMinimapAttributeDirty = function()
{
    this._minimapAttribute.dirty = false;
};

Game_Event.prototype.isMinimapWall = function()
{
    return this._minimapAttribute.wall;
};

Game_Event.prototype.isMinimapMove = function()
{
    return this._minimapAttribute.move;
};

Game_Event.prototype.minimapPersonType = function()
{
    return this._minimapAttribute.person;
};

Game_Event.prototype.minimapObjectType = function()
{
    return this._minimapAttribute.object;
};

//-----------------------------------------------------------------------------
// Game_Vehicle

/**
 * 現在のマップに存在するか
 */
Game_Vehicle.prototype.isInCurrentMap = function()
{
    return this._mapId === $gameMap.mapId();
};

//-----------------------------------------------------------------------------
// Game_MinimapPassageCache

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

Game_MinimapPassageCache.prototype.initialize = function(map, grid)
{
    this._mapId = map.mapId();
    this._width = map.width();
    this._height = map.height();
    this._grid = grid;
    this._blockCount = {
        x: Math.floor((this._width  + grid.x - 1) / grid.x),
        y: Math.floor((this._height + grid.y - 1) / grid.y)
    };

    // 各タイルの通行可否フラグ
    this._flags = new Array(this._width * this._height);

    // チェック済みブロックフラグ
    this._blockChecked = new Array(this._blockCount.x * this._blockCount.y);
};

/**
 * ブロック数の取得
 */
Game_MinimapPassageCache.prototype.getBlockCount = function()
{
    return this._blockCount;
};

/**
 * ブロックチェック済み判定
 */
Game_MinimapPassageCache.prototype.isBlockChecked = function(bx, by)
{
    return this._blockChecked[bx + by * this._blockCount.y];
};

/**
 * ブロックチェック済みフラグの設定
 */
Game_MinimapPassageCache.prototype.setBlockChecked = function(bx, by, checked)
{
    this._blockChecked[bx + by * this._blockCount.y] = checked;
};

/**
 * 通行フラグの取得
 */
Game_MinimapPassageCache.prototype.getFlag = function(x, y)
{
    if ($gameMap.isLoopHorizontal())
    {
        x = (x + this._width) % this._width;
    }
    else if (x < 0 || x >= this._width)
    {
        return 0;
    }

    if ($gameMap.isLoopVertical())
    {
        y = (y + this._height) % this._height;
    }
    else if (y < 0 || y >= this._height)
    {
        return 0;
    }

    return this._flags[x + y * this._width];
};

/**
 * 通行フラグの設定
 */
Game_MinimapPassageCache.prototype.setFlag = function(x, y, flag)
{
    this._flags[x + y * this._width] = flag;
};

/**
 * 指定位置が通行可能か
 */
Game_MinimapPassageCache.prototype.isPassable = function(x, y)
{
    return this.getFlag(x, y) !== 0;
};

/**
 * 指定方向への通行が可能か
 */
Game_MinimapPassageCache.prototype.isPassableDir = function(x, y, dir)
{
    var flag = this.getFlag(x, y);
    switch (dir)
    {
        case 2: return (flag & Minimap.dirFlags.down)  !== 0;
        case 4: return (flag & Minimap.dirFlags.left)  !== 0;
        case 6: return (flag & Minimap.dirFlags.right) !== 0;
        case 8: return (flag & Minimap.dirFlags.up)    !== 0;
        default: return false;
    }
};

//-----------------------------------------------------------------------------
// Sprite_Minimap
//
// ミニマップ用のスプライトです。

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

Sprite_Minimap.prototype = Object.create(Sprite_Base.prototype);
Sprite_Minimap.prototype.constructor = Sprite_Minimap;

Sprite_Minimap.prototype.initialize = function()
{
    Sprite_Base.prototype.initialize.call(this);

    var rect = Params.mapRect;
    this._gridNumber = {
        x: Math.floor((rect.width + Params.gridSize - 1) / Params.gridSize),
        y: Math.floor((rect.height + Params.gridSize - 1) / Params.gridSize),
    };
    this._drawGridNumber = { x: this._gridNumber.x + 2, y: this._gridNumber.y + 2 };
    this._drawRange = { begin: new PIXI.Point(0, 0), end: new PIXI.Point(0, 0) };

    this._lastPosition = new Point($gamePlayer.x, $gamePlayer.y);
    this._scrollDiff = new Point();

    this.createSubSprites();

    this._baseOpacity = 255;
    this.setColorTone([-64, -64, 128, 64]);

    this.move(rect.x, rect.y);
};

/**
 * 内部のスプライトを作成
 */
Sprite_Minimap.prototype.createSubSprites = function()
{
    this._bitmapSize = {
        width: (this._gridNumber.x + 2) * Params.gridSize,
        height: (this._gridNumber.y + 2) * Params.gridSize
    };

    this.createBaseSprite();
    this.createPassageSprite();
    this.createObjectSprites();
    this.createPlayerSprite();
};

/**
 * ベース部分のスプライトを作成
 */
Sprite_Minimap.prototype.createBaseSprite = function()
{
    var rect = Params.mapRect;

    this._baseSprite = new Sprite();
    this._baseSprite.bitmap = new Bitmap(rect.width, rect.height);
    this._baseSprite.bitmap.fillAll(Params.backgroundColor);

    this.addChild(this._baseSprite);

    if (Params.displayTileImage)
    {
        this._tilemap = Graphics.isWebGL() ?
            new ShaderTilemap() :
            new Tilemap();

        // 軽量化のためにタイルのアニメーションを切る
        this._tilemap.update = null;

        this.addChild(this._tilemap);
    }

    this.applyMask(rect);
};

/**
 * マスクの適用
 */
Sprite_Minimap.prototype.applyMask = function(rect)
{
    this._maskGraphic = new PIXI.Graphics();
    this._maskGraphic.beginFill(0x000000);

    switch (Params.maskStyle)
    {
        case Minimap.maskStyles.ellipse:
            this._maskGraphic.drawEllipse(rect.width / 2, rect.height / 2, rect.width / 2, rect.height / 2);
            break;

        case Minimap.maskStyles.roundedRect:
            this._maskGraphic.drawRoundedRect(0, 0, rect.width, rect.height, 64);
            break;

        case Minimap.maskStyles.hex1:
        case Minimap.maskStyles.hex2:
            fillRegularPolygon(
                this._maskGraphic,
                rect.width / 2,
                rect.height / 2,
                rect.width / 2,
                rect.height / 2,
                (Params.maskStyle === Minimap.maskStyles.hex1) ? 0 : (Math.PI / 2),
                6);
            break;

        default:
            this._maskGraphic.drawRect(0, 0, rect.width, rect.height);
            break;
    }

    this._maskGraphic.endFill();

    this.addChild(this._maskGraphic);
    this.mask = this._maskGraphic;
};

/**
 * 通行可能領域スプライトの作成
 */
Sprite_Minimap.prototype.createPassageSprite = function()
{
    this._passageSprite = new Sprite_MinimapPassage(this._bitmapSize.width, this._bitmapSize.height);

    this.updateScroll();

    this.addChild(this._passageSprite);
};

/**
 * オブジェクトスプライトの作成
 */
Sprite_Minimap.prototype.createObjectSprites = function()
{
    this._objectSprites = [];

    var objects = $gameMap.events().concat($gameMap.vehicles());
    objects.forEach(function(obj)
    {
        var sprite = new Sprite_MinimapIcon();
        sprite.setObject(obj);

        this._objectSprites.push(sprite);
        this.addChild(sprite);
    }, this);
};

/**
 * 現在位置スプライトの作成
 */
Sprite_Minimap.prototype.createPlayerSprite = function()
{
    var rect = Params.mapRect;

    this._playerSprite = new Sprite_MinimapIcon();
    this._playerSprite.bitmap = ImageManager.loadSystem(Params.playerIconImage);
    this._playerSprite.x = rect.width / 2;
    this._playerSprite.y = rect.height / 2;

    this.addChild(this._playerSprite);
};

/**
 * 全体の不透明度を設定
 */
Sprite_Minimap.prototype.setWholeOpacity = function(baseOpacity)
{
    this.opacity = this._baseOpacity * baseOpacity / 255;
};

/**
 * ミニマップ位置の移動
 */
Sprite_Minimap.prototype.move = function(x, y)
{
    this.x = x;
    this.y = y;
};

Sprite_Minimap.prototype.isNeedUpdate = function()
{
    return this.visible && this.opacity > 0;
};

Sprite_Minimap.prototype.update = function()
{
    Sprite_Base.prototype.update.call(this);

    this.updateVisibility();

    if ($gameTemp.minimapCacheRefreshFlag)
    {
        $gameTemp.minimapCacheRefreshFlag = false;
        this.refreshPassageTable();
    }

    if (!this.isNeedUpdate())
    {
        return;
    }

    this.updatePosition();
    this.updateTilemap();
    this.updatePassageSprite();
    this.updateObjectSprites();
    this.updatePlayerSprite();
};

/**
 * 可視状態の更新
 */
Sprite_Minimap.prototype.updateVisibility = function()
{
    this.visible =
        $gameSystem.isMinimapEnabled() &&
        $gameMap.isMinimapEnabled();
};

/**
 * 描画範囲の更新
 */
Sprite_Minimap.prototype.updateDrawRange = function()
{
    var range = {
        x: Math.floor(this._drawGridNumber.x / 2),
        y: Math.floor(this._drawGridNumber.y / 2)
    };
    this._drawRange.begin.x = $gamePlayer.x - range.x;
    this._drawRange.begin.y = $gamePlayer.y - range.y;
    this._drawRange.end.x   = $gamePlayer.x + range.x;
    this._drawRange.end.y   = $gamePlayer.y + range.y;
};

/**
 * タイルマップの表示領域を更新
 */
Sprite_Minimap.prototype.updateTilemap = function()
{
    if (!this._tilemap)
    {
        return;
    }

    this._tilemap.origin.x =
        ($gamePlayer._realX - this._tileCount.x / 2.0 + 1.5) * $gameMap.tileWidth();
    this._tilemap.origin.y =
        ($gamePlayer._realY - this._tileCount.y / 2.0 + 1.5) * $gameMap.tileHeight();
};

/**
 * 通行可能領域スプライトの更新
 */
Sprite_Minimap.prototype.updatePassageSprite = function()
{
    // TODO: 実装
};

/**
 * オブジェクトスプライトの更新
 */
Sprite_Minimap.prototype.updateObjectSprites = function()
{
    this._objectSprites.forEach(function(sprite)
    {
        var obj = sprite.getObject();
        if (!obj || !this.isInDrawRange(obj.x - 1, obj.y - 1))
        {
            sprite.visible = false;
            return;
        }

        sprite.updatePosition(this._drawRange.begin, this._scrollDiff);
    }, this);
};

/**
 * 現在位置スプライトの更新
 */
Sprite_Minimap.prototype.updatePlayerSprite = function()
{
    // スプライトの向きを設定
    var angle;
    if (KMS.imported['3DVehicle'] && $gameMap.is3DMode())
    {
        angle = -$gameMap.get3DPlayerAngle();
    }
    else
    {
        switch ($gamePlayer.direction())
        {
            case 2:  angle = Math.PI; break;
            case 4:  angle = Math.PI * 3 / 2; break;
            case 6:  angle = Math.PI / 2; break;
            case 8:  angle = 0; break;
            default: angle = 0; break;
        }
    }
    this._playerSprite.rotation = angle;
};

/**
 * ミニマップの再構築
 */
Sprite_Minimap.prototype.refresh = function()
{
    this.updatePosition();
    this.refreshTilemap();
    this.refreshParameters();
    this.refreshMapImage();
};

/**
 * タイルマップの再構築
 */
Sprite_Minimap.prototype.refreshTilemap = function()
{
    if (!this._tilemap)
    {
        return;
    }

    var rect = Params.mapRect;
    var baseSize = {
        width:  Math.floor(rect.width  * $gameMap.tileWidth()  / Params.gridSize),
        height: Math.floor(rect.height * $gameMap.tileHeight() / Params.gridSize)
    };

    // タイルマップのパラメータを設定
    this._tilemap.tileWidth  = $gameMap.tileWidth();
    this._tilemap.tileHeight = $gameMap.tileHeight();
    this._tilemap.width      = baseSize.width;
    this._tilemap.height     = baseSize.height;
    this._tilemap.setData($gameMap.width(), $gameMap.height(), $gameMap.data());
    this._tilemap.horizontalWrap = $gameMap.isLoopHorizontal();
    this._tilemap.verticalWrap   = $gameMap.isLoopVertical();

    var scaleX = Params.mapRect.width / this._tilemap.width;
    var scaleY = Params.mapRect.height / this._tilemap.height;
    this._tilemap.scale.x = scaleX;
    this._tilemap.scale.y = scaleY;
    this._tilemap.x += this._tilemap._margin * scaleX;
    this._tilemap.y += this._tilemap._margin * scaleY;
    //this._tilemap.width += this._tilemap._margin * 2;
    //this._tilemap.height += this._tilemap._margin * 2;

    Spriteset_Map.prototype.loadTileset.call(this);

    // タイルマップを再描画するために update を呼ぶ
    (Graphics.isWebGL() ? ShaderTilemap : Tilemap)
        .prototype.update.call(this._tilemap);

    this._tileCount = this._tilemap.getTileCount();
};

/**
 * ミニマップ用パラメータの再構築
 */
Sprite_Minimap.prototype.refreshParameters = function()
{
    this.updateDrawRange();
    this.refreshPassageTable();
};

/**
 * 通行フラグテーブルの更新
 */
Sprite_Minimap.prototype.refreshPassageTable = function()
{
    this._passageCache = this.getPassageTableCache();
};

/**
 * 現在のマップに対応する通行フラグキャッシュを取得
 */
Sprite_Minimap.prototype.getPassageTableCache = function()
{
    return new Game_MinimapPassageCache($gameMap, this._drawGridNumber);
};

/**
 * マップ画像の再構築
 */
Sprite_Minimap.prototype.refreshMapImage = function()
{
    this.drawMap();
};

/**
 * 指定した座標が含まれるブロックの通行フラグをスキャン
 */
Sprite_Minimap.prototype.scanPassage = function(x, y)
{
    var mapWidth  = $gameMap.width();
    var mapHeight = $gameMap.height();
    if ($gameMap.isLoopHorizontal())
    {
        x = (x + mapWidth) % mapWidth;
    }
    if ($gameMap.isLoopVertical())
    {
        y = (y + mapHeight) % mapHeight;
    }

    var blocks = this._passageCache.getBlockCount();
    var bx = Math.floor(x / this._drawGridNumber.x);
    var by = Math.floor(y / this._drawGridNumber.y);

    if (bx < 0 || bx >= blocks.x || by < 0 || by >= blocks.y)
    {
        // マップ範囲外
        return;
    }

    if (this._passageCache.isBlockChecked(bx, by))
    {
        // 探索済み
        return;
    }

    var range = {
        x: {
            begin: bx * this._drawGridNumber.x,
            end:   (bx + 1) * this._drawGridNumber.x
        },
        y: {
            begin: by * this._drawGridNumber.y,
            end:   (by + 1) * this._drawGridNumber.y
        }
    };

    // 探索範囲内の通行テーブルを生成
    for (var ty = range.y.begin; ty < range.y.end; ty++)
    {
        if (ty < 0 || ty >= mapHeight)
        {
            continue;
        }

        for (var tx = range.x.begin; tx < range.x.end; tx++)
        {
            if (tx < 0 || tx >= mapWidth)
            {
                continue;
            }

            // 通行方向フラグの作成
            // (方向は 2, 4, 6, 8)
            var flag = 0;
            for (var i = 0; i < 4; i++)
            {
                var dir = (i + 1) * 2;
                if ($gameMap.isPassable(tx, ty, dir))
                {
                    flag |= 1 << (dir / 2 - 1);
                }
            }
            this._passageCache.setFlag(tx, ty, flag);
        }
    }

    this._passageCache.setBlockChecked(bx, by, true);
};

/**
 * プレイヤー周囲の通行フラグテーブルを更新
 */
Sprite_Minimap.prototype.updateAroundPassageTable = function()
{
    var gx = this._drawGridNumber.x;
    var gy = this._drawGridNumber.y;
    var dx = $gamePlayer.x - Math.floor(gx / 2);
    var dy = $gamePlayer.y - Math.floor(gy / 2);
    this.scanPassage(dx, dy);
    this.scanPassage(dx + gx, dy);
    this.scanPassage(dx, dy + gy);
    this.scanPassage(dx + gx, dy + gy);
};

/**
 * プレイヤー位置の更新
 */
Sprite_Minimap.prototype.updatePosition = function()
{
    this._scrollDiff.x = ($gamePlayer._realX - $gamePlayer.x) * Params.gridSize;
    this._scrollDiff.y = ($gamePlayer._realY - $gamePlayer.y) * Params.gridSize;
    this.updateScroll();

    if (this._lastPosition.x !== $gamePlayer.x ||
        this._lastPosition.y !== $gamePlayer.y)
    {
        this.updateDrawRange();
        this.drawMap();
        this._lastPosition.x = $gamePlayer.x;
        this._lastPosition.y = $gamePlayer.y;
    }
};

/**
 * スクロール処理
 */
Sprite_Minimap.prototype.updateScroll = function()
{
    var offset = {
        x: Math.floor((Params.gridSize) * 1.5) + this._scrollDiff.x,
        y: Math.floor((Params.gridSize) * 1.5) + this._scrollDiff.y
    };
    var rect = Params.mapRect;
    this._passageSprite.setFrame(offset.x, offset.y, rect.width, rect.height);
};

/**
 * 描画範囲か判定
 */
Sprite_Minimap.prototype.isInDrawRange = function(x, y)
{
    var begin = this._drawRange.begin;
    var end   = this._drawRange.end;

    var dx = x;
    if ($gameMap.isLoopHorizontal())
    {
        dx = (dx + $gameMap.width()) % $gameMap.width();
    }

    var dy = y;
    if ($gameMap.isLoopVertical())
    {
        dy = (dy + $gameMap.height()) % $gameMap.height();
    }

    return x >= begin.x && x <= end.x &&
        y >= begin.y && y <= end.y;
};

/**
 * マップの範囲内か判定
 */
Sprite_Minimap.prototype.isInMapRange = function(x, y)
{
    return x >= 0 && x < $gameMap.width() &&
        y >= 0 && y < $gameMap.height();
};

/**
 * マップ画像の描画
 */
Sprite_Minimap.prototype.drawMap = function()
{
    this.updateAroundPassageTable();

    var bitmap = this._passageSprite.bitmap;
    bitmap.clear();
    this.drawMapForeground(bitmap);
};

/**
 * 移動可能領域の描画
 */
Sprite_Minimap.prototype.drawMapForeground = function(bitmap)
{
    for (var y = this._drawRange.begin.y; y < this._drawRange.end.y; y++)
    {
        for (var x = this._drawRange.begin.x; x < this._drawRange.end.x; x++)
        {
            this.drawMapForegroundGrid(bitmap, x, y);
        }
    }
};

/**
 * 移動可能グリッドの描画
 */
Sprite_Minimap.prototype.drawMapForegroundGrid = function(bitmap, x, y)
{
    var passage = this._passageCache;
    if (!passage.isPassable(x, y))
    {
        return;
    }

    var dx = (x - this._drawRange.begin.x) * Params.gridSize;
    var dy = (y - this._drawRange.begin.y) * Params.gridSize;
    var dw = Params.gridSize;
    var dh = Params.gridSize;

    if (!passage.isPassableDir(x, y, 2))  // 下方向移動不可
    {
        dh -= 1;
    }
    if (!passage.isPassableDir(x, y, 4))  // 左方向移動不可
    {
        dx += 1;
        dw -= 1;
    }
    if (!passage.isPassableDir(x, y, 6))  // 右方向移動不可
    {
        dw -= 1;
    }
    if (!passage.isPassableDir(x, y, 8))  // 上方向移動不可
    {
        dy += 1;
        dh -= 1;
    }
    bitmap.fillRect(dx, dy, dw, dh, Params.foregroundColor);
};

//-----------------------------------------------------------------------------
// Sprite_MinimapPassage
//
// ミニマップ上の通行可能領域表示用スプライトです。

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

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

Sprite_MinimapPassage.prototype.initialize = function(width, height)
{
    Sprite.prototype.initialize.call(this);

    this.bitmap = new Bitmap(width, height);
};

//-----------------------------------------------------------------------------
// Sprite_MinimapIcon
//
// ミニマップ上のアイコン用スプライトです。

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

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

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

    this.bitmap   = ImageManager.loadSystem(Params.objectIconImage);
    this.anchor.x = 0.5;
    this.anchor.y = 0.5;

    this._object        = null;
    this._lastIconIndex = -1;
    this._blinkDuration = 0;
};

/**
 * 表示準備ができているか
 */
Sprite_MinimapIcon.prototype.isReady = function()
{
    return this.bitmap && this.bitmap.isReady();
};

/**
 * 追従するオブジェクトの取得
 */
Sprite_MinimapIcon.prototype.getObject = function()
{
    return this._object;
};

/**
 * 追従するオブジェクトの設定
 */
Sprite_MinimapIcon.prototype.setObject = function(object)
{
    this._object = object;
    if (object)
    {
        this.bitmap = ImageManager.loadSystem(Params.objectIconImage);
        this.updateIconInfo();
    }

    this.refresh();
};

/**
 * 表示位置の更新
 *
 * @param {Point} begin      - ミニマップの表示開始座標
 * @param {Point} scrollDiff - 位置補正のためのマップスクロール量
 */
Sprite_MinimapIcon.prototype.updatePosition = function(begin, scrollDiff)
{
    var x = (this._object.x - begin.x - 1) * Params.gridSize;
    var y = (this._object.y - begin.y - 1) * Params.gridSize;
    this.x = x - scrollDiff.x;
    this.y = y - scrollDiff.y;

    if (KMS.imported['AreaEvent'])
    {
        // 表示サイズに応じた位置補正
        this.x += this._iconSize * (this.scale.x - 1.0) / 2;
        this.y += this._iconSize * (this.scale.y - 1.0) / 2;
    }
};

/**
 * アイコン情報の更新
 */
Sprite_MinimapIcon.prototype.updateIconInfo = function()
{
    if (!this.isReady())
    {
        this._iconSize    = null;
        this._iconColumns = null;
        return;
    }

    this._iconSize    = Math.floor(this.bitmap.height / 3);
    this._iconColumns = Math.floor(this.bitmap.width / this._iconSize);
};

/**
 * リフレッシュ
 */
Sprite_MinimapIcon.prototype.refresh = function()
{
    this._lastIconIndex = -1;
};

/**
 * オブジェクト更新
 */
Sprite_MinimapIcon.prototype.update = function()
{
    Sprite.prototype.update.call(this);

    this.updateImage();
    this.updateBlink();
};

/**
 * 表示する画像の更新
 */
Sprite_MinimapIcon.prototype.updateImage = function()
{
    if (!this._object)
    {
        return;
    }

    if (!this._iconColumns)
    {
        this.updateIconInfo();
    }

    var iconIndex = this.getCurrentIconIndex();
    if (iconIndex >= 0)
    {
        if (iconIndex !== this._lastIconIndex || this._object.isMinimapAttributeDirty())
        {
            this.setIconIndex(iconIndex);
        }
    }
    else
    {
        this._lastIconIndex = iconIndex;
        this.visible = false;
    }
};

/**
 * 現在のオブジェクトに対応するオブジェクトアイコン番号の取得
 */
Sprite_MinimapIcon.prototype.getCurrentIconIndex = function()
{
    if (!(this._object && this.isReady()))
    {
        return -1;
    }

    if (this._object instanceof Game_Vehicle)
    {
        return this.getCurrentIconIndexForVehicle();
    }
    else
    {
        return this.getCurrentIconIndexForEvent();
    }
};

/**
 * 現在のイベントに対応するアイコン番号の取得
 */
Sprite_MinimapIcon.prototype.getCurrentIconIndexForEvent = function()
{
    var obj = this._object;

    if (obj.isMinimapMove())
    {
        return 0;
    }
    else if (obj.minimapPersonType() >= 0)
    {
        // person は 2 行目
        return this._iconColumns + obj.minimapPersonType();
    }
    else if (obj.minimapObjectType() >= 0)
    {
        // object は 3 行目
        return this._iconColumns * 2 + obj.minimapObjectType();
    }
    else
    {
        return -1;
    }
};

/**
 * 現在の乗り物に対応するアイコン番号の取得
 */
Sprite_MinimapIcon.prototype.getCurrentIconIndexForVehicle = function()
{
    var obj = this._object;

    if (!obj.isInCurrentMap())
    {
        return -1;
    }
    else if (obj.isBoat())
    {
        return $gamePlayer.isInBoat() ? -1 : 1;
    }
    else if (obj.isShip())
    {
        return $gamePlayer.isInShip() ? -1 : 2;
    }
    else if (obj.isAirship())
    {
        return $gamePlayer.isInAirship() ? -1 : 3;
    }
    else
    {
        // 不明な乗り物
        return -1;
    }
};

/**
 * オブジェクトアイコン番号の設定
 */
Sprite_MinimapIcon.prototype.setIconIndex = function(iconIndex)
{
    this.setFrame(
        (iconIndex % this._iconColumns) * this._iconSize,
        Math.floor(iconIndex / this._iconColumns) * this._iconSize,
        this._iconSize,
        this._iconSize);
    this.updateDisplaySize();

    this._object.clearMinimapAttributeDirty();
    this._lastIconIndex = iconIndex;
    this.visible = true;
};

/**
 * オブジェクトアイコン表示サイズの更新
 */
Sprite_MinimapIcon.prototype.updateDisplaySize = function()
{
    if (!KMS.imported['AreaEvent'] ||
        !(this._object instanceof Game_Event))
    {
        return;
    }

    var area = this._object.getEventTriggerArea();
    this.scale.x = area.width;
    this.scale.y = area.height;
};

/**
 * 明滅エフェクトの更新
 */
Sprite_MinimapIcon.prototype.updateBlink = function()
{
    this._blinkDuration = (this._blinkDuration + 1) % Params.blinkTime;

    var alpha = 128 * (Math.sin(this._blinkDuration * Math.PI * 2 / Params.blinkTime) + 1);
    var color = [255, 255, 255, alpha];
    this.setBlendColor(color);
};

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

var _KMS_Spriteset_Map_createUpperLayer = Spriteset_Map.prototype.createUpperLayer;
Spriteset_Map.prototype.createUpperLayer = function()
{
    _KMS_Spriteset_Map_createUpperLayer.call(this);

    this.createMinimap();
};

/**
 * ミニマップの作成
 */
Spriteset_Map.prototype.createMinimap = function()
{
    this._minimap = new Sprite_Minimap();
    this._minimap.refresh();
    this.addChild(this._minimap);
};

var _KMS_Spriteset_Map = Spriteset_Map.prototype.update;
Spriteset_Map.prototype.update = function()
{
    _KMS_Spriteset_Map.call(this);

    this.updateMinimap();
};

/**
 * ミニマップの更新
 */
Spriteset_Map.prototype.updateMinimap = function()
{
    this._minimap.setWholeOpacity(255 - this._fadeSprite.opacity);
    this._minimap.update();
};

})();


code:
//=============================================================================
// KNH_CharacterShadow.js
//=============================================================================

/*:
 * @plugindesc キャラクターに影をつけるプラグイン
 * @author こんにちは
 *
 * @version 1.0.0 2017/10/28 公開
 * 1.0.1 2017/10/29 パーティが0人の時などにエラーが発生する不具合を修正
 * 1.0.2 2018/10/23 隊列非表示時またはパーティからメンバーを外した際にも隊列の影が表示される不具合を修正
 *
 * @param 影画像
 * @desc 影画像を指定。img/systemに保存する。
 * @default
 * @type file
 * @require 1
 * @dir img/system
 *
 * @help キャラクターの下に影をつけます。
 * 影画像が必要です。img/system に保存し、プラグインパラメータで指定してください。
 *
 * ●プレイヤーや隊列メンバーに影を設定する方法
 *
 * データベース → アクター の「メモ」に下のいずれかを記入します。
 * 【】内を記入してください。「\v[1]」等使用できます。
 *
 * 【<KNHShadow>】            アクターに影を表示する
 * 【<KNHShadow:5,-10,150>】  影のX座標を 5 、Y座標を -10 ずらし
 *                            大きさを 1.5 倍にして表示する
 *
 * ●イベントに影を設定する方法
 *
 * イベントの「メモ」、またはイベントコマンド「注釈」内に上記と同じ方法で
 * 記入します。メモ欄の場合は全てのページで、注釈の場合は
 * そのイベントページでのみ適用されます。
 *
 * ※注意
 * キャラクターが透明化 ON の場合表示されません。
 * キャラクターの不透明度を変更した場合、影も同じ不透明度となります。
 * キャラクター画像をなしに設定しても、影だけ表示することができます。
 *
 * ●影の表示切り替えや位置・大きさの変更
 *
 * 変更したいイベント(またはプレイヤー)の「移動ルートの設定」内の「スクリプト」に
 * 記入します。【】内を記入してください。
 *
 * 【this.setShadow(true)】           影を表示する
 * 【this.setShadow(false)】          影を表示しない
 * 【this.setShadowPosition(-5, 8)】  影の表示位置のX座標を -5、Y座標を 8 ずらす
 * 【this.setShadowPosition(0, 0)】   影の表示位置のずれを無くす
 * 【this.setShadowScale(80)】        影の大きさを 0.8 倍にする
 * 【this.setShadowScale(100)】       影の大きさを通常に戻す
 *
 * ●プラグインコマンド    なし
 *
 * ●利用規約
 *   特に無いです。
 */

(function() {
    'use strict';
    var pluginName = 'KNH_CharacterShadow';

    var getNumber = function(text, max, min) {
        text = applyCharacters(text);
        if (isNaN(text)) return NaN;
        return Math.max(Math.min(Number(text), max || Infinity), min || -Infinity);
    };

    var getArrayString = function(text) {
        var values = applyCharacters(text).split(',');
        for (var i = 0; i < values.length; i++) {
            values[i] = values[i].trim();
            if (!isNaN(values[i])) values[i] = Number(values[i]);
        }
        return values;
    };

    var applyCharacters = function(text) {
        if (text === null) text = '';
        text = '' + text;
        text = text.replace(/\\/g, '\x1b');
        text = text.replace(/\x1b\x1b/g, '\\');
        text = text.replace(/\x1bV\[(\d+)\]/gi, function() {
            return $gameVariables.value(parseInt(arguments[1], 10));
        }.bind(this));
        text = text.replace(/\x1bV\[(\d+)\]/gi, function() {
            return $gameVariables.value(parseInt(arguments[1], 10));
        }.bind(this));
        text = text.replace(/\x1bN\[(\d+)\]/gi, function() {
            var actor = parseInt(arguments[1], 10) >= 1 ? $gameActors.actor(parseInt(arguments[1], 10)) : null;
            return actor ? actor.name() : '';
        }.bind(this));
        text = text.replace(/\x1bP\[(\d+)\]/gi, function() {
            var actor = parseInt(arguments[1], 10) >= 1 ? $gameParty.members()[parseInt(arguments[1], 10) - 1] : null;
            return actor ? actor.name() : '';
        }.bind(this));
        if ($dataSystem) text = text.replace(/\x1bG/gi, TextManager.currencyUnit);
        return text;
    };

    var getMeta = function(text, str) {
        var re = /<([^<>:]+)(:?)([^>]*)>/g;
        var meta = {};
        for (;;) {
            var match = re.exec(text);
            if (match) {
                if (match[2] === ':') {
                    meta[match[1]] = match[3];
                } else {
                    meta[match[1]] = true;
                }
            } else {
                break;
            }
        }
        return meta['' + str];
    }

     var getShadowInfo = function(text) {
        if (text.contains('<KNHShadow>')) {
            return [true];
        } else if (getMeta(text, 'KNHShadow')) {
            return [true].concat(getArrayString(getMeta(text, 'KNHShadow')));
        } else {
            return false;
        }
    };

    //-----------------------------------------------------------------------------
    // プラグインパラメータの取得
    //-----------------------------------------------------------------------------

    var KNH_shadowImage = PluginManager.parameters(pluginName)['影画像'];

    //-----------------------------------------------------------------------------
    //  Game_CharacterBase
    //-----------------------------------------------------------------------------

    var _Game_CharacterBase_initMembers = Game_CharacterBase.prototype.initMembers;
    Game_CharacterBase.prototype.initMembers = function() {
        _Game_CharacterBase_initMembers.apply(this, arguments);
        this._shadow = false;
        this._shadowAddX = 0;
        this._shadowAddY = 0;
        this._shadowScale = 100;
    };

    Game_CharacterBase.prototype.setShadow = function(shadow) {
        this._shadow = !!shadow;
    };

    Game_CharacterBase.prototype.setShadowPosition = function(addX, addY) {
        this._shadowAddX = addX || 0;
        this._shadowAddY = addY || 0;
    };

    Game_CharacterBase.prototype.setShadowScale = function(scale) {
        this._shadowScale = scale || 100;
    };

    Game_CharacterBase.prototype.setShadowInfo = function(info) {
        if (!info) info = [false];
        this.setShadow(!!info[0] || false);
        this.setShadowPosition(info[1] || 0, info[2] || 0);
        this.setShadowScale(info[3] || 100);
    };

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

    var _Game_Event_setupPageSettings = Game_Event.prototype.setupPageSettings;
    Game_Event.prototype.setupPageSettings = function() {
        _Game_Event_setupPageSettings.call(this);
        this.setupShadow();
    };

    Game_Event.prototype.setupShadow = function() {
        var info = [false], page = this.page(), shadow = false;
        if (page) {
            for (var i = 0; i < page.list.length; i++) {
                if (page.list[i].code == 108 && getShadowInfo(page.list[i].parameters[0])) {
                    info = getShadowInfo(page.list[i].parameters[0]);
                    shadow = true;
                }
            }
        }
        if (!shadow) info = getShadowInfo(this.event().note);
        this.setShadowInfo(info);
    };

    //-----------------------------------------------------------------------------
    // Game_Player
    //-----------------------------------------------------------------------------

    var _Game_Player_refresh = Game_Player.prototype.refresh;
    Game_Player.prototype.refresh = function() {
        _Game_Player_refresh.apply(this, arguments);
        if ($gameParty.leader()) this.setShadowInfo(getShadowInfo($gameParty.leader().actor().note));
    };

    //-----------------------------------------------------------------------------
    // Game_Follower
    //-----------------------------------------------------------------------------

    var _Game_Follower_refresh = Game_Follower.prototype.refresh;
    Game_Follower.prototype.refresh = function() {
        _Game_Follower_refresh.apply(this, arguments);
        if (this.actor()) this.setShadowInfo(getShadowInfo(this.actor().actor().note));
        if (!this.isVisible()) this.setShadow(false);
    };

    //-----------------------------------------------------------------------------
    // Sprite_Character
    //-----------------------------------------------------------------------------

    var _Sprite_Character_update = Sprite_Character.prototype.update;
    Sprite_Character.prototype.update = function() {
        _Sprite_Character_update.call(this);
        this.updateShadow();
    };

    Sprite_Character.prototype.updateShadow = function() {
        if (this._character._shadow) {
            if (!this._shadowSprite) {
                this._shadowSprite = new Sprite_CharacterShadow(this._character);
                this.parent.addChild(this._shadowSprite);
            }
        } else if (this._shadowSprite) {
            this.parent.removeChild(this._shadowSprite);
            this._shadowSprite = null;
        }
    };

    //-----------------------------------------------------------------------------
    // Sprite_CharacterShadow
    //-----------------------------------------------------------------------------

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

    Sprite_CharacterShadow.prototype = Object.create(Sprite_Base.prototype);
    Sprite_CharacterShadow.prototype.constructor = Sprite_CharacterShadow;

    Sprite_CharacterShadow.prototype.initialize = function(character) {
        Sprite_Base.prototype.initialize.call(this);
        this._character = character;
        this.bitmap = ImageManager.loadSystem(KNH_shadowImage);
        this.anchor.x = this.anchor.y = 0.5;
    };

    Sprite_CharacterShadow.prototype.update = function() {
        var ch = this._character;
        this.x = ch.screenX() + ch._shadowAddX;
        this.y = ch.screenY() + ch.jumpHeight() - 2 + ch._shadowAddY;
        this.z = ch.screenZ() - 1;
        this.scale.x = this.scale.y = ch._shadowScale / 100;
        this.opacity = (ch._transparent || ch._opacity === 0) ? 0 : ch._opacity;
    };

})();


code:
//=============================================================================
// K_VariableWindow.js
//=============================================================================

/*:
 * @plugindesc ツクールフェスのイベントコマンド「変数を画面に表示」を実装します。
 * @author Kota (https://nine-yusha.com/)
 *
 * @help

 プラグインコマンド
   VariableWindow show 1  # 変数１の値を画面に表示します。
   VariableWindow close   # 表示した変数を画面から消去します。

 利用規約:
   ・著作権表記は必要ございません。
   ・利用するにあたり報告の必要は特にございません。
   ・商用・非商用問いません。
   ・R18作品にも使用制限はありません。
   ・ゲームに合わせて自由に改変していただいて問題ございません。
   ・プラグイン素材としての再配布（改変後含む）は禁止させていただきます。

 ライセンスについての詳細は下記をご確認ください。
 https://nine-yusha.com/plugin/

 作者: ルルの教会
 作成日: 2020/10/13
*/

(function() {

    var parameters = PluginManager.parameters('K_VariableWindow');

	var Scene_map_start = Scene_Map.prototype.start;
	Scene_Map.prototype.start = function() {
		Scene_map_start.call(this);
	    this._variableInfoWindow = new Window_VariableInfo();
        this.addWindow(this._variableInfoWindow);
    };

    var _Scene_Map_update = Scene_Map.prototype.update;
    Scene_Map.prototype.update = function() {
        _Scene_Map_update.call(this);
        this._variableInfoWindow.setText();
    };

    // Game_Systemに変数を追加 (セーブ時に保存させるため)
    Game_System.prototype.clearVariableWindowFlag = function() {
        this._VariableWindowFlag = false;
        this._VariableWindowId = 1;
    };

    //-----------------------------------------------------------------------------
	// PluginCommand
    //

    var _Game_Interpreter_pluginCommand =
            Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === 'VariableWindow') {
            switch (args[0]) {
            case 'show':
                if (!$gameSystem._VariableWindowFlag) {
                    $gameSystem.clearVariableWindowFlag();
                }
                $gameSystem._VariableWindowId = args[1];
                $gameSystem._VariableWindowFlag = true;
                break;
            case 'close':
                if (!$gameSystem._VariableWindowFlag) {
                    $gameSystem.clearVariableWindowFlag();
                }
                $gameSystem._VariableWindowFlag = false;
                break;
            }
        }
    };

    //-----------------------------------------------------------------------------
	// Window_VariableInfo
	//

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

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

    Window_VariableInfo.prototype.initialize = function() {
	    var width = 400;
        var height = this.fittingHeight(1);
	    Window_Base.prototype.initialize.call(this, Graphics.boxWidth - width, 0, width, height);
    };

    Window_VariableInfo.prototype.setText = function(text) {
	    this._text = text;
	    this.refresh();
    };

    Window_VariableInfo.prototype.clear = function() {
	    this.setText('');
    };

    Window_VariableInfo.prototype.refresh = function() {
        var variableId = $gameSystem._VariableWindowId;
        this.contents.clear();
        this.changeTextColor(this.systemColor());
        this.drawText($dataSystem.variables[variableId], this.textPadding(), 0, 250);
        this.resetTextColor();
        this.drawText($gameVariables.value(variableId), 258, 0, 100, 'right');
        // 表示・非表示状態判定
        if ($gameSystem._VariableWindowFlag) {
            this.show();
        } else {
            this.hide();
        }
	};

})();