code:
//=============================================================================
// HalfMove.js
// ----------------------------------------------------------------------------
// (C)2016 Triacontane
// This software is released under the MIT License.
// http://opensource.org/licenses/mit-license.php
// ----------------------------------------------------------------------------
// Version
// 1.16.1 2020/07/02 スクリプトからキャラクターの座標を0.5以外の端数にするとエラーになる問題を修正
// 1.16.0 2020/04/18 右上、右下、左上、左下のみ移動可能な地形、リージョンの設定を追加
// 1.15.4 2020/04/15 英語版の一部のパラメータの型指定と初期値が日本語版と合っていなかった問題を修正
// 1.15.3 2019/11/14 通行設定(4方向)の北の方を通行不可にしたタイルに南の中央から侵入すると半歩分は通行可能にもかかわらず通行不可判定されてしまう問題を修正
// 1.15.2 2019/11/10 PD_8DirDash.jsと組み合わせたとき、斜め方向を向いている状態で一歩前進するとキャラクターが移動先に瞬間移動してしまう競合を解消
// 1.15.1 2019/11/10 1.15.0の機能で半歩加算と半歩減算のどちらもできるよう修正
// 1.15.0 2019/11/10 イベントの初期位置を半歩位置にできる機能を追加
// 1.14.0 2019/11/02 トリガー領域拡大で負の値を設定できるよう修正
// 1.13.1 2019/09/29 半歩用通行可能判定の地形タグおよびリージョンで複数のリージョンを並べたときに、一部設定が無効になる問題を修正
// 1.13.0 2019/07/07 移動ルート強制中は半歩移動無効の設定をしているときでも半歩で強制移動できるスクリプトを追加
// 1.12.5 2019/06/09 半歩移動無効時、下半分移動不可に設定した地形とリージョンが、元の通行設定にかかわらず移動不可となる問題を修正
// 1.12.4 2019/03/31 MOG_ChronoEngine.jsとの起動時の競合を解消
// 1.12.3 2018/12/19 プレイヤーに近づく、遠ざかる処理で特定条件下で正しく移動しない場合がある問題を修正
// 1.12.2 2018/11/04 1.11.8の修正後、一部環境でゲーム画面のFPS低下が起きていた現象を修正
// 1.12.1 2018/10/13 すり抜けが設定が無効なイベントのページが切り替わったとき、すり抜け設定が有効になってしまう場合がある不具合を修正
// 1.12.0 2018/08/24 移動不可の地形およびリージョンを複数指定できる機能を追加
// 1.11.11 2018/08/23 1.11.10の修正で横一列の通路上で上に半歩上に移動できない不具合を修正
// 1.11.10 2018/06/22 移動不可タイルに乗っているとき半歩上に移動できてしまう現象を修正
// 1.11.9 2018/04/29 イベントすり抜けのパラメータがOFFかつイベントとプレイヤーが重なったときに移動不可となる問題を修正
//                   パラメータ「強制中無効」が有効なとき、対象キャラが半歩位置にいると強制中でも半歩移動になってしまう問題を修正（一部制約あり）
// 1.11.8 2018/03/21 プレイヤーが向きが固定されているとき、プレイヤー接触のイベントをプレイヤーの進行方向を基準に判定するよう修正
// 1.11.7 2018/02/01 プラグインが未適用の状態でセーブされたデータをロードした際、一部の処理に差異が出る問題を修正
// 1.11.6 2018/01/28 プライオリティが通常キャラと同じイベントに対して拡張トリガーが適用されない問題を修正
// 1.11.5 2018/01/24 KhasAdvancedLightingとの競合を解消
// 1.11.4 2017/12/31 PD_8DirDash.jsとの併用時、タッチ移動で斜め移動できるよう修正
// 1.11.3 2017/12/30 半歩移動無効時のタッチ移動の挙動が一部おかしくなっていた問題を修正
//                   タッチ移動を少し軽量化
//                   タッチ移動でイベントの一歩前に停止したときにイベントが起動する場合がある問題を修正
// 1.11.2 2017/12/23 半歩移動有効時にタッチ移動時の探索深度が本来の半分になっていた問題を修正
// 1.11.1 2017/10/29 MPP_MiniMap_OP1.jsとの競合を解消
// 1.11.0 2017/10/07 探索系プラグインとの併用時の負荷対策に、イベントによる探索深度を変更できる機能を追加
//                   YEP_MoveRouteCore.jsとの競合を解消
// 1.10.0 2017/10/02 パラメータの型指定機能に対応
//                   斜め移動をしながらイベントを起動すると起動地点から余分に移動する場合がある不具合を修正
// 1.9.0 2017/06/21 イベントの自律移動で8方向移動を使用できる機能を追加
// 1.8.2 2017/05/28 進入不可タイルに存在するイベントに対する半歩用衝突判定が行われない現象を修正
// 1.8.1 2017/05/14 プライオリティが「通常キャラと同じ」でないイベントはプレイヤーに対する衝突判定を行わないよう修正
// 1.8.0 2017/04/23 8方向移動の可否をスイッチによって切り替える機能を追加
// 1.7.0 2017/03/01 全方向移動不可な地形タグやリージョンのパラメータを追加
// 1.6.4 2017/02/14 下半分移動不可なタイルに対して下方向から移動できてしまっていた不具合を修正
// 1.6.3 2016/09/21 半歩移動中、上方向にある小型船、大型船に乗船できない不具合を修正
// 1.6.2 2016/09/03 斜め移動の移動先にイベントがある場合、縦横移動に切り替わらない問題を修正
// 1.6.1 2016/09/01 すり抜けOFF時のイベントからの接触による起動が正しく行われるよう修正
// 1.6.0 2016/08/20 左半分のみ、右半分のみを通行不可にする機能を追加
// 1.5.0 2016/08/16 イベント同士の位置の重複を許可する設定を追加
// 1.4.9 2016/08/14 半歩位置にいる場合にタイル依存の戦闘背景の設定が正しく機能しない現象を修正
// 1.4.8 2016/08/12 イベントすり抜けがOFF、トリガー拡張がONの場合に、縦に半歩ずれた状態でイベントが起動できない現象を修正
// 1.4.7 2016/08/08 タッチ操作時にたまに同じ場所を延々とループしてしまう現象の修正
// 1.4.6 2016/07/30 場所移動やイベント位置の設定で半歩位置に移動できるよう修正
// 1.4.5 2016/07/22 イベントの複数同時起動を抑制する設定を追加
// 1.4.4 2016/07/02 半歩位置にいる場合に地形タグとリージョンIDの取得値が0になってしまう不具合を修正
// 1.4.3 2016/06/30 タッチ操作によるマップ移動でイベント起動できない場合がある問題を修正
// 1.4.2 2016/06/08 PD_8DirDash.jsと組み合わせて斜め移動グラフィックを反映するよう修正
// 1.4.1 2016/05/20 ダメージ床や茂みで上半分のみ接している場合は無効にするよう変更
// 1.4.0 2016/05/20 トリガー領域を上下左右で細かく指定できる機能を追加
//                  英名のプラグインコマンドが正しく機能していなかった問題を修正
// 1.3.0 2016/05/16 タイルの下半分のみ通行不可にできるような地形タグとリージョンIDの指定を追加
//                  イベントごとにトリガー拡大を設定できる機能を追加
// 1.2.0 2016/05/11 タイルの上半分のみ通行不可にできるような地形タグとリージョンIDの指定を追加
//                  歩数の増加およびエンカウント歩数とダメージ床を通常の歩数に合わせて調整できる機能を追加
// 1.1.0 2016/05/08 イベントごとに「すり抜け禁止」の可否を設定できる機能を追加
//                  トリガー関係の機能を拡張
//                  斜め移動時に減速する設定を追加
//                  カウンター属性のタイルに対して上から起動したときの判定が一部機能していなかったのを修正
// 1.0.1 2016/05/08 ループするマップの境界値にいる場合に一部の通行可能判定が誤っていたのを修正
//                  メモ欄にてイベントごとに半歩移動の可否を設定できる機能を追加
// 1.0.0 2016/05/06 初版
// ----------------------------------------------------------------------------
// [Blog]   : https://triacontane.blogspot.jp/
// [Twitter]: https://twitter.com/triacontane/
// [GitHub] : https://github.com/triacontane/
//=============================================================================

/*:
 * @plugindesc Half Move Plugin
 * @author triacontane
 *
 * @param Direction8Move
 * @desc 斜め移動を含めた8方向移動を許可します。
 * @default true
 * @type boolean
 *
 * @param 8MoveSwitch
 * @desc 指定したIDのスイッチがONのときのみ8方向移動を許可します。0の場合は常に許可します。
 * @default 0
 * @type switch
 *
 * @param EventThrough
 * @desc イベントに横から接触したときに半歩ぶんならすり抜けます。
 * @default true
 * @type boolean
 *
 * @param DisableForcing
 * @desc 移動ルートの強制中は半歩移動を無効にします。
 * @default false
 * @type boolean
 *
 * @param AvoidCorner
 * @desc 直進中にマップの角に引っ掛かった場合、斜め移動に切り替えて再試行します。
 * @default true
 * @type boolean
 *
 * @param DiagonalSlow
 * @desc 斜め移動中の歩行速度が0.8倍になります。
 * @default false
 * @type boolean
 *
 * @param TriggerExpansion
 * @desc プライオリティが「通常キャラと同じ」イベントの起動領域を左右に半マス分だけ拡張します。
 * @default false
 * @type boolean
 *
 * @param AdjustmentRealStep
 * @desc 歩数が増加するタイミングが2歩につき1歩分となります。エンカウント歩数とダメージ床のタイミングも調整されます。
 * @default false
 * @type boolean
 *
 * @param UpperNpTerrainTag
 * @desc 上半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param UpperNpRegionId
 * @desc 上半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LowerNpTerrainTag
 * @desc 下半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LowerNpRegionId
 * @desc 下半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param RightNpTerrainTag
 * @desc 右半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param RightNpRegionId
 * @desc 右半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LeftNpTerrainTag
 * @desc 左半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LeftNpRegionId
 * @desc 左半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param RightUpNpTerrainTag
 * @desc タイルの右上のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param RightUpNpRegionId
 * @desc タイルの右上のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param RightDownNpTerrainTag
 * @desc タイルの右下のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param RightDownNpRegionId
 * @desc タイルの右下のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LeftUpNpTerrainTag
 * @desc タイルの左上のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LeftUpNpRegionId
 * @desc タイルの左上のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LeftDownNpTerrainTag
 * @desc タイルの左下のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param LeftDownNpRegionId
 * @desc タイルの左下のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param AllNpTerrainTag
 * @desc 全方向通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param AllNpRegionId
 * @desc 全方向通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param MultiStartDisable
 * @desc トリガー条件を満たすイベントが同時に複数存在する場合にIDがもっとも小さいイベントのみを起動します。
 * @default false
 * @type boolean
 *
 * @param EventOverlap
 * @desc プライオリティが「通常キャラと同じ」以外のイベント同士であれば位置の重複を許可します。
 * @default false
 * @type boolean
 *
 * @help Moving distance in half.
 *
 * Plugin command
 * ・HALF_MOVE_DISABLE
 * Disable half move.
 *
 * ・HALF_MOVE_ENABLE
 * Enable half move.
 *
 * Note(Event Editor)
 * <HMHalfDisable> -> Disable half move.
 * <HMThroughDisable> -> Disable half through.
 * <HMTriggerExpansion:ON> -> Expansion trigger area ON
 * <HMTriggerExpansion:OFF> -> Expansion trigger area OFF
 * <HMExpansionArea:1,1,1,1> -> Expansion trigger area(down,left,right,up)
 * <HMInitialHalfX:+> -> Initial Half Position X(+0.5)
 * <HMInitialHalfY:+> -> Initial Half Position Y(+0.5)
 * <HMInitialHalfX:-> -> Initial Half Position X(-0.5)
 * <HMInitialHalfY:-> -> Initial Half Position Y(-0.5)
 *
 * ・スクリプト（移動ルートの設定の「スクリプト」から実行）
 *
 * 「移動ルート強制中は半歩移動無効」の設定が有効なときでも半歩で強制移動します。
 * this.setHalfMoveDuringRouteForce();
 *
 * 上記の設定をもとに戻します。
 * this.resetHalfMoveDuringRouteForce();
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc 半歩移動プラグイン
 * @author トリアコンタン
 *
 * @param 8方向移動
 * @desc 斜め移動を含めた8方向移動を許可します。
 * @default true
 * @type boolean
 *
 * @param 8方向移動スイッチ
 * @desc 指定したIDのスイッチがONのときのみ8方向移動を許可します。0の場合は常に許可します。
 * @default 0
 * @type switch
 *
 * @param イベントすり抜け
 * @desc イベントに横から接触したときに半歩ぶんならすり抜けます。
 * @default true
 * @type boolean
 *
 * @param 強制中無効
 * @desc 移動ルートの強制中は半歩移動を無効にします。
 * @default false
 * @type boolean
 *
 * @param 角回避
 * @desc 直進中にマップの角に引っ掛かった場合、斜め移動に切り替えて再試行します。進行方向に起動可能なイベントがある場合は無効。
 * @default true
 * @type boolean
 *
 * @param 斜め移動中減速
 * @desc 斜め移動中の歩行速度が0.8倍になります。
 * @default false
 * @type boolean
 *
 * @param トリガー拡大
 * @desc イベントの起動領域を拡張します。プライオリティによって拡張領域が異なります。
 * @default false
 * @type boolean
 *
 * @param 実歩数調整
 * @desc 歩数が増加するタイミングが2歩につき1歩分となります。エンカウント歩数とダメージ床のタイミングも調整されます。
 * @default false
 * @type boolean
 *
 * @param 上半分移動不可地形
 * @desc 上半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 上半分移動不可Region
 * @desc 上半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 下半分移動不可地形
 * @desc 下半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 下半分移動不可Region
 * @desc 下半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 右半分移動不可地形
 * @desc 右半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 右半分移動不可Region
 * @desc 右半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 左半分移動不可地形
 * @desc 左半分のタイルのみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 左半分移動不可Region
 * @desc 左半分のタイルのみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 右上移動不可地形
 * @desc タイルの右上のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 右上移動不可Region
 * @desc タイルの右上のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 右下移動不可地形
 * @desc タイルの右下のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 右下移動不可Region
 * @desc タイルの右下のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 左上移動不可地形
 * @desc タイルの左上のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 左上移動不可Region
 * @desc タイルの左上のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 左下移動不可地形
 * @desc タイルの左下のみ通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 左下移動不可Region
 * @desc タイルの左下のみ通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 全方向移動不可地形
 * @desc 全方向通行不可となる地形タグです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param 全方向移動不可Region
 * @desc 全方向通行不可となるリージョンIDです。0を指定すると無効になります。
 * @default ["0"]
 * @type number[]
 *
 * @param イベント複数起動防止
 * @desc トリガー条件を満たすイベントが同時に複数存在する場合にIDがもっとも小さいイベントのみを起動します。
 * @default false
 * @type boolean
 *
 * @param イベント位置重複OK
 * @desc プライオリティが「通常キャラと同じ」以外のイベント同士であれば位置の重複を許可します。
 * @default false
 * @type boolean
 *
 * @help キャラクターの移動単位が1タイルの半分になります。
 * 半歩移動が有効なら、乗り物以外は全て半歩移動になります。
 *
 * プラグインコマンド詳細
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * ・半歩移動禁止
 * ・HALF_MOVE_DISABLE
 * 半歩移動を一時的に禁止します。この情報はセーブデータに含まれます。
 * 特定のイベント等で禁止したい場合等に使用します。
 *
 * ・半歩移動許可
 * ・HALF_MOVE_ENABLE
 * 禁止していた半歩移動をもとに戻します。
 *
 * イベントごとの拡張機能を利用するには、
 * イベントのメモ欄に以下の通り記述してください。
 *
 * 対象イベントが半歩移動しなくなります。
 * <HM半歩禁止>
 * <HMHalfDisable>
 *
 * 対象イベントがすり抜けしなくなります。
 * <HMすり抜け禁止>
 * <HMThroughDisable>
 *
 * 対象イベントのトリガー拡大の有無を個別に設定します。
 * 設定がない場合は、パラメータ「トリガー拡大」の値が適用されます。
 * <HMトリガー拡大:ON>
 * <HMトリガー拡大:OFF>
 *
 * ・トリガー拡大をONにした場合の仕様
 * イベントのメモ欄の記述により個別にトリガー領域を設定することができます。
 * // 下、左、右、上方向にそれぞれ1マス、2マス、3マス、4マス拡大したい場合
 * <HM拡大領域:1,2,3,4>
 *
 * // 下、左、右、上方向にそれぞれ0.5マス、1マス、1マス、0.5マス拡大したい場合
 * <HM拡大領域:0.5,1,1,0.5>
 *
 * プライオリティが「通常キャラと同じ」かつイベントすり抜けが無効な場合
 * 　左右に半マスずつ起動可能領域が拡張されます。
 *
 * それ以外は上下左右に半マスずつトリガー領域が拡張されます。
 *
 * イベントの初期位置を半歩分だけ加算します。
 * 最初から半歩位置にイベントを配置したいときに使用してください。
 * <HM初期半歩X:+>
 * <HMInitialHalfX:+>
 * <HM初期半歩Y:+>
 * <HMInitialHalfY:+>
 *
 * 半歩減算したい場合はこちらのメモ欄です。
 * <HM初期半歩X:->
 * <HMInitialHalfX:->
 * <HM初期半歩Y:->
 * <HMInitialHalfY:->
 *
 *
 * 注意！
 * 対象イベントの領域が拡大する以下のタグは廃止になりました。
 * <HM横幅:2>
 * <HMWidth:2>
 * <HM高さ:3>
 * <HMHeight:3>
 *
 * ・イベントの8方向自律移動
 * プレイヤーが8方向移動可能な状態のときは、イベントもランダム移動や
 * プレイヤー接近移動で8方向移動を使うようになります。
 * 以下のタグを指定するとことでイベントの8方向移動を禁止できます。
 * <HM8MoveDisable>
 * <HM8方向移動禁止>
 *
 * ・スクリプト（移動ルートの設定の「スクリプト」から実行）
 *
 * 「移動ルート強制中は半歩移動無効」の設定が有効なときでも半歩で強制移動します。
 * this.setHalfMoveDuringRouteForce();
 *
 * 上記の設定をもとに戻します。
 * this.resetHalfMoveDuringRouteForce();
 *
 * ・他プラグインとの連携に関して
 *
 * 1. PD_8DirDash.jsと組み合わせると半歩移動に
 * グラフィック変更を伴う8方向移動機能が反映されます。
 *
 * 配布元：http://pixeldog.x.fc2.com/material_script.html
 *
 * 2. OverpassTile.jsと組み合わせると半歩移動に
 * 立体交差を適用できます。
 *
 * 配布元：公式サンプルゲーム「ニナと鍵守の勇者」に収録
 *
 * OverpassTile.jsを当プラグインより上に定義してください。
 *
 * 3. FloatVariables.jsと組み合わせると半歩位置に場所移動したり
 * イベント位置を設定したりできます。
 *
 * 配布元：半歩移動プラグインと同じ配布元です。
 *
 * 4. YEP_MoveRouteCore.jsと組み合わせる場合、
 * このプラグインを下に配置してください。
 *
 * 5. MPP_MiniMap_OP1.jsと組み合わせる場合、
 * このプラグインを下に配置してください。
 *
 * 他のプラグインと併用する場合は、それぞれの配布元の規約や注意事項を
 * あらかじめご確認ください。
 *
 * 注意事項
 * 「強制中無効」のパラメータをONにして移動ルート強制した場合、フォロワーの動きや通行判定が
 * 一部おかしくなる問題があり、現在は未解決です。同パラメータを有効にする場合は
 * ご注意ください。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

(function() {
    'use strict';
    var pluginName    = 'HalfMove';
    var metaTagPrefix = 'HM';

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

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

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

    var getParamArrayNumber = function(paramNames) {
        var paramReplacer = function(key, value) {
            try {
                return JSON.parse(value);
            } catch (e) {
                return value;
            }
        };
        return JSON.parse(JSON.stringify(getParamOther(paramNames), paramReplacer));
    };

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

    var getMetaValue = function(object, name) {
        var metaTagName = metaTagPrefix + (name ? name : '');
        return object.meta.hasOwnProperty(metaTagName) ? object.meta[metaTagName] : undefined;
    };

    var getMetaValues = function(object, names) {
        if (!Array.isArray(names)) return getMetaValue(object, names);
        for (var i = 0, n = names.length; i < n; i++) {
            var value = getMetaValue(object, names[i]);
            if (value !== undefined) return value;
        }
        return undefined;
    };

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

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

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

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

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

    var convertEscapeCharacters = function(text) {
        if (text === null || text === undefined) {
            text = '';
        }
        var windowLayer = SceneManager._scene._windowLayer;
        return windowLayer ? windowLayer.children[0].convertEscapeCharacters(text) : text;
    };

    //=============================================================================
    // パラメータの取得と整形
    //=============================================================================
    var paramDirection8Move        = getParamBoolean(['Direction8Move', '8方向移動']);
    var paramEventThrough          = getParamBoolean(['EventThrough', 'イベントすり抜け']);
    var paramDisableForcing        = getParamBoolean(['DisableForcing', '強制中無効']);
    var paramAvoidCorner           = getParamBoolean(['AvoidCorner', '角回避']);
    var paramDiagonalSlow          = getParamBoolean(['DiagonalSlow', '斜め移動中減速']);
    var paramTriggerExpansion      = getParamBoolean(['TriggerExpansion', 'トリガー拡大']);
    var paramAdjustmentRealStep    = getParamBoolean(['AdjustmentRealStep', '実歩数調整']);
    var paramUpperNpTerrainTag     = getParamArrayNumber(['UpperNpTerrainTag', '上半分移動不可地形']);
    var paramUpperNpRegionId       = getParamArrayNumber(['UpperNpRegionId', '上半分移動不可Region']);
    var paramLowerNpTerrainTag     = getParamArrayNumber(['LowerNpTerrainTag', '下半分移動不可地形']);
    var paramLowerNpRegionId       = getParamArrayNumber(['LowerNpRegionId', '下半分移動不可Region']);
    var paramRightNpTerrainTag     = getParamArrayNumber(['RightNpTerrainTag', '右半分移動不可地形']);
    var paramRightNpRegionId       = getParamArrayNumber(['RightNpRegionId', '右半分移動不可Region']);
    var paramLeftNpTerrainTag      = getParamArrayNumber(['LeftNpTerrainTag', '左半分移動不可地形']);
    var paramLeftNpRegionId        = getParamArrayNumber(['LeftNpRegionId', '左半分移動不可Region']);
    var paramAllNpTerrainTag       = getParamArrayNumber(['AllNpTerrainTag', '全方向移動不可地形']);
    var paramAllNpRegionId         = getParamArrayNumber(['AllNpRegionId', '全方向移動不可Region']);
    var paramMultiStartDisable     = getParamBoolean(['MultiStartDisable', 'イベント複数起動防止']);
    var paramEventOverlap          = getParamBoolean(['EventOverlap', 'イベント位置重複OK']);
    var param8MoveSwitch           = getParamNumber(['8MoveSwitch', '8方向移動スイッチ'], 0);
    var paramRightUpNpTerrainTag   = getParamArrayNumber(['RightUpNpTerrainTag', '右上移動不可地形']);
    var paramRightUpNpRegionId     = getParamArrayNumber(['RightUpNpRegionId', '右上移動不可Region']);
    var paramRightDownNpTerrainTag = getParamArrayNumber(['RightDownNpTerrainTag', '右下移動不可地形']);
    var paramRightDownNpRegionId   = getParamArrayNumber(['RightDownNpRegionId', '右下移動不可Region']);
    var paramLeftUpNpTerrainTag    = getParamArrayNumber(['LeftUpNpTerrainTag', '左上移動不可地形']);
    var paramLeftUpNpRegionId      = getParamArrayNumber(['LeftUpNpRegionId', '左上移動不可Region']);
    var paramLeftDownNpTerrainTag  = getParamArrayNumber(['LeftDownNpTerrainTag', '左下移動不可地形']);
    var paramLeftDownNpRegionId    = getParamArrayNumber(['LeftDownNpRegionId', '左下移動不可Region']);

    //=============================================================================
    // ローカル変数
    //=============================================================================
    var localHalfPositionCount = 0;

    //=============================================================================
    // Game_Interpreter
    //  プラグインコマンドを追加定義します。
    //=============================================================================
    var _Game_Interpreter_pluginCommand      = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.apply(this, arguments);
        this.pluginCommandHalfMove(command, args);
    };

    Game_Interpreter.prototype.pluginCommandHalfMove = function(command) {
        switch (getCommandName(command)) {
            case '半歩移動禁止' :
            case 'HALF_MOVE_DISABLE':
                $gameSystem.setEnableHalfMove(false);
                break;
            case '半歩移動許可' :
            case 'HALF_MOVE_ENABLE':
                $gameSystem.setEnableHalfMove(true);
                break;
        }
    };

    //=============================================================================
    // Game_System
    //  半歩移動全体の禁止フラグを追加定義します。
    //=============================================================================
    var _Game_System_initialize      = Game_System.prototype.initialize;
    Game_System.prototype.initialize = function() {
        _Game_System_initialize.apply(this, arguments);
        this._disableHalfMove = false;
    };

    Game_System.prototype.canHalfMove = function() {
        return !this._disableHalfMove;
    };

    Game_System.prototype.setEnableHalfMove = function(value) {
        this._disableHalfMove = !value;
        $gamePlayer.locate($gamePlayer.x, $gamePlayer.y);
        $gameMap.events().forEach(function(event) {
            event.locate(event.x, event.y);
        }.bind(this));
    };

    var _Game_System_onAfterLoad      = Game_System.prototype.onAfterLoad;
    Game_System.prototype.onAfterLoad = function() {
        _Game_System_onAfterLoad.apply(this, arguments);
        $gamePlayer.initMembersForHalfMoveIfNeed();
    };

    //=============================================================================
    // Game_Map
    //  座標計算を半分にします。
    //=============================================================================
    Game_Map.tileUnit = 0.5;

    var _Game_Map_xWithDirection      = Game_Map.prototype.xWithDirection;
    Game_Map.prototype.xWithDirection = function(x, d) {
        var newX = _Game_Map_xWithDirection.apply(this, arguments);
        if (localHalfPositionCount > 0) {
            var dx = newX - x;
            return x + (dx * Game_Map.tileUnit);
        } else {
            return newX;
        }
    };

    var _Game_Map_yWithDirection      = Game_Map.prototype.yWithDirection;
    Game_Map.prototype.yWithDirection = function(y, d) {
        var newY = _Game_Map_yWithDirection.apply(this, arguments);
        if (localHalfPositionCount > 0) {
            var dy = newY - y;
            return y + (dy * Game_Map.tileUnit);
        } else {
            return newY;
        }
    };

    var _Game_Map_roundXWithDirection      = Game_Map.prototype.roundXWithDirection;
    Game_Map.prototype.roundXWithDirection = function(x, d) {
        if (localHalfPositionCount > 0) {
            return this.roundHalfXWithDirection(x, d);
        } else {
            return _Game_Map_roundXWithDirection.apply(this, arguments);
        }
    };

    var _Game_Map_roundYWithDirection      = Game_Map.prototype.roundYWithDirection;
    Game_Map.prototype.roundYWithDirection = function(y, d) {
        if (localHalfPositionCount > 0) {
            return this.roundHalfYWithDirection(y, d);
        } else {
            return _Game_Map_roundYWithDirection.apply(this, arguments);
        }
    };

    // for PD_8DirDash.js
    Game_Map.prototype.roundHalfXWithDirection = function(x, d) {
        return this.roundX(x + ((d % 3) === 0 ? Game_Map.tileUnit : (d % 3) === 1 ? -Game_Map.tileUnit : 0));
    };

    Game_Map.prototype.roundHalfYWithDirection = function(y, d) {
        return this.roundY(y + (d <= 3 ? Game_Map.tileUnit : d >= 7 ? -Game_Map.tileUnit : 0));
    };

    Game_Map.prototype.roundNoHalfXWithDirection = function(x, d) {
        return _Game_Map_roundXWithDirection.apply(this, arguments);
    };

    Game_Map.prototype.roundNoHalfYWithDirection = function(x, d) {
        return _Game_Map_roundYWithDirection.apply(this, arguments);
    };

    Game_Map.prototype.isHalfPos = function(value) {
        return value - Game_Map.tileUnit === Math.floor(value)
    };

    Game_Map.prototype.eventsXyUnitNt = function(x, y) {
        return this.events().filter(function(event) {
            return event.posExpansionNt(x, y);
        });
    };

    Game_Map.prototype.isPassableByHalfRegionAndTag = function(floatX, floatY) {
        var halfX = this.isHalfPos(floatX);
        var halfY = this.isHalfPos(floatY);
        var x = Math.floor(floatX);
        var y = Math.ceil(floatY);
        if (this.isAllNp(x, y)) {
            return false;
        }
        if (halfX) {
            if (this.isRightNp(x, y)) {
                return false;
            } else if (!halfY && this.isRightLowerNp(x, y)) {
                return false;
            } else if (halfY && this.isRightUpperNp(x, y)) {
                return false;
            }
        } else {
            if (this.isLeftNp(x, y)) {
                return false;
            } else if (!halfY && this.isLeftLowerNp(x, y)) {
                return false;
            } else if (halfY && this.isLeftUpperNp(x, y)) {
                return false;
            }
        }
        if (halfY) {
            if (this.isUpperNp(x, y)) {
                return false;
            } else if (halfX && this.isRightUpperNp(x, y)) {
                return false;
            } else if (!halfX && this.isLeftUpperNp(x, y)) {
                return false;
            }
        } else {
            if (this.isLowerNp(x, y)) {
                return false;
            } else if (halfX && this.isRightLowerNp(x, y)) {
                return false;
            } else if (!halfX && this.isLeftLowerNp(x, y)) {
                return false;
            }
        }
        return true;
    };

    Game_Map.prototype.isUpperNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramUpperNpTerrainTag, paramUpperNpRegionId);
    };

    Game_Map.prototype.isLowerNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramLowerNpTerrainTag, paramLowerNpRegionId);
    };

    Game_Map.prototype.isRightNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramRightNpTerrainTag, paramRightNpRegionId);
    };

    Game_Map.prototype.isLeftNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramLeftNpTerrainTag, paramLeftNpRegionId);
    };

    Game_Map.prototype.isRightUpperNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramRightUpNpTerrainTag, paramRightUpNpRegionId);
    };

    Game_Map.prototype.isLeftUpperNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramLeftUpNpTerrainTag, paramLeftUpNpRegionId);
    };

    Game_Map.prototype.isRightLowerNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramRightDownNpTerrainTag, paramRightDownNpRegionId);
    };

    Game_Map.prototype.isLeftLowerNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramLeftDownNpTerrainTag, paramLeftDownNpRegionId);
    };

    Game_Map.prototype.isNoPathByRegionAndTag = function(x, y, terrainParam, regionParam) {
        return this.isIncludeTerrainTag(x, y, terrainParam) ||
            this.isIncludeRegionId(x, y, regionParam);
    };

    Game_Map.prototype.isAllNp = function(x, y) {
        return this.isNoPathByRegionAndTag(x, y, paramAllNpTerrainTag, paramAllNpRegionId);
    };

    Game_Map.prototype.isIncludeTerrainTag = function(x, y, tags) {
        if (!Array.isArray(tags)) {
            tags = [tags];
        }
        if (tags[0] <= 0) {
            return false;
        }
        return tags.some(function(tag) {
            return this.allTerrainTag(x, y).contains(tag);
        }, this);
    };

    Game_Map.prototype.isIncludeRegionId = function(x, y, ids) {
        if (!Array.isArray(ids)) {
            ids = [ids];
        }
        if (ids[0] <= 0) {
            return false;
        }
        return ids.some(function(id) {
            return this.allRegionId(x, y).contains(id);
        }, this);
    };

    Game_Map.prototype.allTerrainTag = function(x, y) {
        var tu = Game_Map.tileUnit;
        if (this.isHalfPos(x)) {
            return [this.terrainTag(x - tu, y), this.terrainTag(x + tu, y)];
        }
        if (this.isHalfPos(y)) {
            return [this.terrainTag(x, y + tu), this.terrainTag(x, y - tu)];
        }
        return [_Game_Map_terrainTag.apply(this, arguments)];
    };

    Game_Map.prototype.allRegionId = function(x, y) {
        var tu = Game_Map.tileUnit;
        if (this.isHalfPos(x)) {
            return [this.regionId(x - tu, y), this.regionId(x + tu, y)];
        }
        if (this.isHalfPos(y)) {
            return [this.regionId(x, y + tu), this.regionId(x, y - tu)];
        }
        return [_Game_Map_regionId.apply(this, arguments)];
    };

    var _Game_Map_checkLayeredTilesFlags      = Game_Map.prototype.checkLayeredTilesFlags;
    Game_Map.prototype.checkLayeredTilesFlags = function(x, y, bit) {
        var result = false;
        if (this.isHalfPos(x)) {
            result = this.checkLayeredTilesFlags(x + Game_Map.tileUnit, y, bit);
            result = result || this.checkLayeredTilesFlags(x - Game_Map.tileUnit, y, bit);
        } else if (this.isHalfPos(y)) {
            result = this.checkLayeredTilesFlags(x, y + Game_Map.tileUnit, bit);
        } else {
            result = _Game_Map_checkLayeredTilesFlags.apply(this, arguments);
        }
        return result;
    };

    var _Game_Map_terrainTag      = Game_Map.prototype.terrainTag;
    Game_Map.prototype.terrainTag = function(x, y) {
        var tu = Game_Map.tileUnit;
        if (this.isHalfPos(x)) {
            return this.terrainTag(x - tu, y) || this.terrainTag(x + tu, y);
        }
        if (this.isHalfPos(y)) {
            return this.terrainTag(x, y + tu) || this.terrainTag(x, y - tu);
        }
        return _Game_Map_terrainTag.apply(this, arguments);
    };

    var _Game_Map_regionId      = Game_Map.prototype.regionId;
    Game_Map.prototype.regionId = function(x, y) {
        var tu = Game_Map.tileUnit;
        if (this.isHalfPos(x)) {
            return this.regionId(x - tu, y) || this.regionId(x + tu, y);
        }
        if (this.isHalfPos(y)) {
            return this.regionId(x, y + tu) || this.regionId(x, y - tu);
        }
        return _Game_Map_regionId.apply(this, arguments);
    };

    var _Game_Map_autotileType      = Game_Map.prototype.autotileType;
    Game_Map.prototype.autotileType = function(x, y, z) {
        var tu = Game_Map.tileUnit;
        if (this.isHalfPos(x)) {
            return this.autotileType(x - tu, y, z) || this.autotileType(x + tu, y, z);
        }
        if (this.isHalfPos(y)) {
            return this.autotileType(x, y + tu, z) || this.autotileType(x, y - tu, z);
        }
        return _Game_Map_autotileType.apply(this, arguments);
    };

    //=============================================================================
    // Game_CharacterBase
    //  半歩移動の判定処理を追加定義します。
    //=============================================================================
    var _Game_CharacterBase_initMembers      = Game_CharacterBase.prototype.initMembers;
    Game_CharacterBase.prototype.initMembers = function() {
        _Game_CharacterBase_initMembers.apply(this, arguments);
        this.initMembersForHalfMove();
    };

    Game_CharacterBase.prototype.initMembersForHalfMove = function() {
        this._halfDisable     = false;
        this._throughDisable  = false;
        this._eventWidth      = null;
        this._eventHeight     = null;
        this._customExpansion = false;
        this._frontDirection  = 0;
    };

    Game_Player.prototype.initMembersForHalfMoveIfNeed = function() {
        if (!this.hasOwnProperty('_halfDisable')) {
            this.initMembersForHalfMove();
        }
    };

    var _Game_CharacterBase_pos      = Game_CharacterBase.prototype.pos;
    Game_CharacterBase.prototype.pos = function(x, y) {
        if (this._eventWidth || this._eventHeight) {
            return this._x <= x && this._x + (this._eventWidth || 1) - 1 >= x &&
                this._y <= y && this._y + (this._eventHeight || 1) - 1 >= y;
        } else {
            return _Game_CharacterBase_pos.apply(this, arguments);
        }
    };

    var _Game_CharacterBase_isMapPassable      = Game_CharacterBase.prototype.isMapPassable;
    Game_CharacterBase.prototype.isMapPassable = function(x, y, d) {
        var alias              = _Game_CharacterBase_isMapPassable.bind(this);
        var result             = true;
        var halfPositionCount  = localHalfPositionCount;
        localHalfPositionCount = 0;
        if (!this.isHalfMove()) {
            if (this.isHalfPosX()) {
                x = $gameMap.roundHalfXWithDirection(x, d);
            }
            if (this.isHalfPosY()) {
                y = $gameMap.roundHalfYWithDirection(y, d);
            }
            result = alias(x, y, d);
        } else if (this.isHalfPosX(x) && this.isHalfPosY(y)) {
            if (d === 8) {
                var y1      = $gameMap.roundHalfYWithDirection(y, d);
                var xLeft1  = $gameMap.roundHalfXWithDirection(x, 4);
                var xRight1 = $gameMap.roundHalfXWithDirection(x, 6);
                var y3      = $gameMap.roundHalfYWithDirection(y, 2);
                if (alias(xLeft1, y1, 10 - d) && alias(xRight1, y1, 10 - d)) {
                    result = alias(xLeft1, y1, 6) || alias(xRight1, y1, 4);
                }
                result = result && alias(xLeft1, y3, d) && alias(xRight1, y3, d);
            }
        } else if (this.isHalfPosX(x)) {
            if (d === 2) {
                var y2      = $gameMap.roundNoHalfYWithDirection(y, d);
                var xLeft2  = $gameMap.roundHalfXWithDirection(x, 4);
                var xRight2 = $gameMap.roundHalfXWithDirection(x, 6);
                if (alias(xLeft2, y2, 10 - d) && alias(xRight2, y2, 10 - d)) {
                    result = alias(xLeft2, y2, 6) || alias(xRight2, y2, 4);
                }
                result = result && alias(xLeft2, y, d) && alias(xRight2, y, d);
            }
        } else if (this.isHalfPosY(y)) {
            if (d !== 2) {
                var y4 = $gameMap.roundHalfYWithDirection(y, 2);
                result = alias(x, y4, d);
            }
        } else {
            if (d !== 8) {
                result = alias(x, y, d);
            } else {
                result = $gameMap.isPassable(x, y, 2) || $gameMap.isPassable(x, y, 4) ||
                    $gameMap.isPassable(x, y, 6) || $gameMap.isPassable(x, y, 8);
            }
        }
        if (this.isHalfMove()) {
            result = result && this.isMapPassableByHalfRegionAndTag(x, y, d);
        }
        localHalfPositionCount = halfPositionCount;
        return result;
    };

    Game_CharacterBase.prototype.isMapPassableByHalfRegionAndTag = function(x, y, d) {
        var targetX = $gameMap.roundHalfXWithDirection(x, d);
        var targetY = $gameMap.roundHalfYWithDirection(y, d);
        if (!$gameMap.isPassableByHalfRegionAndTag(targetX, targetY)) {
            return false;
        } else if (!$gameMap.isPassableByHalfRegionAndTag(targetX + Game_Map.tileUnit, targetY)) {
            return false;
        }
        return true;
    };

    Game_CharacterBase.prototype.isHalfPosX = function(x) {
        if (x === undefined) x = this._x;
        return $gameMap.isHalfPos(x);
    };

    Game_CharacterBase.prototype.isHalfPosY = function(y) {
        if (y === undefined) y = this._y;
        return $gameMap.isHalfPos(y);
    };

    Game_CharacterBase.prototype.isMovingDiagonal = function() {
        return this._realX !== this._x && this._realY !== this._y;
    };

    var _Game_CharacterBase_distancePerFrame      = Game_CharacterBase.prototype.distancePerFrame;
    Game_CharacterBase.prototype.distancePerFrame = function() {
        return _Game_CharacterBase_distancePerFrame.apply(this, arguments) *
            (paramDiagonalSlow && this.isMovingDiagonal() ? 0.8 : 1);
    };

    var _Game_CharacterBase_moveStraight      = Game_CharacterBase.prototype.moveStraight;
    Game_CharacterBase.prototype.moveStraight = function(d) {
        if (this.isHalfMove()) {
            var prevX = this._x;
            var prevY = this._y;
            localHalfPositionCount++;
            _Game_CharacterBase_moveStraight.apply(this, arguments);
            localHalfPositionCount--;
            if (this.isMovementSucceeded()) {
                this._prevX = prevX;
                this._prevY = prevY;
            }
        } else {
            _Game_CharacterBase_moveStraight.apply(this, arguments);
        }
    };

    Game_CharacterBase.prototype.moveDiagonallyForRetry = function(horizon, vertical) {
        if (this.isMovementSucceeded()) return;
        var prevDirection = this.direction();
        this.moveDiagonally(horizon, vertical);
        if (!this.isMovementSucceeded()) this.setDirection(prevDirection);
    };

    var _Game_CharacterBase_moveDiagonally      = Game_CharacterBase.prototype.moveDiagonally;
    Game_CharacterBase.prototype.moveDiagonally = function(horizon, vertical) {
        if (this.isHalfMove()) {
            var prevX = this._x;
            var prevY = this._y;
            localHalfPositionCount++;
            _Game_CharacterBase_moveDiagonally.apply(this, arguments);
            localHalfPositionCount--;
            if (this.isMovementSucceeded()) {
                this._prevX = prevX;
                this._prevY = prevY;
            }
        } else {
            _Game_CharacterBase_moveDiagonally.apply(this, arguments);
        }
    };

    Game_CharacterBase.prototype.divideDirection = function(d) {
        var horizon  = d / 3 <= 1 ? d + 3 : d - 3;
        var vertical = d % 3 === 0 ? d - 1 : d + 1;
        return {horizon: horizon, vertical: vertical};
    };

    var _Game_CharacterBase_canPass2     = Game_CharacterBase.prototype.canPass;
    Game_CharacterBase.prototype.canPass = function(x, y, d) {
        if (d % 2 !== 0) {
            var divide = this.divideDirection(d);
            return this.canPassDiagonally(x, y, divide.horizon, divide.vertical);
        }
        var x2 = $gameMap.roundXWithDirection(x, d);
        var y2 = $gameMap.roundYWithDirection(y, d);
        this.isCollidedWithCharacters(x2, y2);
        return _Game_CharacterBase_canPass2.call(this, x, y, d);
    };

    var _Game_CharacterBase_canPass      = Game_CharacterBase.prototype.canPass;
    Game_CharacterBase.prototype.canPass = function(x, y, d) {
        if (this.isHalfMove()) {
            localHalfPositionCount++;
            var result = _Game_CharacterBase_canPass.apply(this, arguments);
            localHalfPositionCount--;
            return result;
        } else {
            return _Game_CharacterBase_canPass.apply(this, arguments);
        }
    };

    var _Game_CharacterBase_canPassDiagonally      = Game_CharacterBase.prototype.canPassDiagonally;
    Game_CharacterBase.prototype.canPassDiagonally = function(x, y, horizon, vertical) {
        if (this.isHalfMove()) {
            localHalfPositionCount++;
            var result = _Game_CharacterBase_canPassDiagonally.apply(this, arguments);
            localHalfPositionCount--;
            return result;
        } else {
            return _Game_CharacterBase_canPassDiagonally.apply(this, arguments);
        }
    };

    Game_CharacterBase.prototype.posUnit = function(x, y) {
        var unit = Game_Map.tileUnit;
        return this._x >= x - unit && this._x <= x + unit && this._y >= y - unit && this._y <= y + unit;
    };

    Game_CharacterBase.prototype.posUnitNt = function(x, y) {
        return this.posUnit(x, y) && !this.isThrough();
    };

    Game_CharacterBase.prototype.posUnitHt = function(x, y) {
        return this.posUnit(x, y) && !this.isHalfThrough(y);
    };

    var _Game_CharacterBase_isCollidedWithEvents      = Game_CharacterBase.prototype.isCollidedWithEvents;
    Game_CharacterBase.prototype.isCollidedWithEvents = function(x, y) {
        return _Game_CharacterBase_isCollidedWithEvents.apply(this, arguments) ||
            this.isCollidedWithEventsForHalfMove(x, y);
    };

    Game_CharacterBase.prototype.isCollidedWithEventsForHalfMove = function(x, y) {
        var events = $gameMap.eventsXyUnitNt(x, y);
        var result = false;
        events.forEach(function(event) {
            if (event.isNormalPriority() && !event.isHalfThrough(y) && !event.pos(this.x, this.y)) {
                this.collidedToEvent(event);
                result = true;
            }
        }.bind(this));
        return result;
    };

    Game_CharacterBase.prototype.collidedToEvent = function(target) {};

    Game_CharacterBase.prototype.getPrevX = function() {
        return this._prevX !== undefined ? this._prevX : this._x;
    };

    Game_CharacterBase.prototype.getPrevY = function() {
        return this._prevY !== undefined ? this._prevY : this._y;
    };

    Game_CharacterBase.prototype.resetPrevPos = function() {
        this._prevX = undefined;
        this._prevY = undefined;
    };

    Game_CharacterBase.prototype.isHalfThrough = function(y) {
        return !this._customExpansion && this.isThroughEnable() && this.y !== y;
    };

    Game_CharacterBase.prototype.isThroughEnable = function() {
        return (this._throughDisable !== undefined ? !this._throughDisable : paramEventThrough);
    };

    var _Game_CharacterBase_checkEventTriggerTouchFront      = Game_CharacterBase.prototype.checkEventTriggerTouchFront;
    Game_CharacterBase.prototype.checkEventTriggerTouchFront = function(d) {
        var halfPositionCount  = localHalfPositionCount;
        localHalfPositionCount = 0;
        this._frontDirection   = d;
        _Game_CharacterBase_checkEventTriggerTouchFront.apply(this, arguments);
        localHalfPositionCount = halfPositionCount;
        this._frontDirection   = 0;
    };

    Game_CharacterBase.prototype.getDistanceForHalfMove = function(character) {
        return $gameMap.distance(this.x, this.y, character.x, character.y);
    };

    var _Game_CharacterBase_setPosition      = Game_CharacterBase.prototype.setPosition;
    Game_CharacterBase.prototype.setPosition = function(x, y) {
        _Game_CharacterBase_setPosition.apply(this, arguments);
        if (this.isHalfMove()) {
            this._x = x;
            this._y = y;
        }
    };

    /**
     * for YEP_MoveRouteCore.js
     * @param x
     * @param y
     * @param collision
     */
    Game_CharacterBase.prototype.moveToPoint = function(x, y, collision) {
        collision = collision || false;
        if (collision) $gameTemp._moveAllowPlayerCollision = true;
        var direction = this.findDirectionTo(x, y);
        if (collision) $gameTemp._moveAllowPlayerCollision = false;
        if (direction > 0) this.moveStraight(direction);
        if (this.x !== x || this.y !== y) this._moveRouteIndex -= 1;
        this.setMovementSuccess(true);
    };

    //=============================================================================
    // Game_Character
    //  タッチ移動の動作を調整します。
    //=============================================================================
    var _Game_Character_findDirectionTo      = Game_Character.prototype.findDirectionTo;
    Game_Character.prototype.findDirectionTo = function(goalX, goalY) {
        var result;
        if (this.isHalfMove()) {
            localHalfPositionCount++;
            result = _Game_Character_findDirectionTo.apply(this, arguments);
            localHalfPositionCount--;
        } else {
            result = _Game_Character_findDirectionTo.apply(this, arguments);
        }
        if (!this._searchHighPrecision && !this.canPass(this.x, this.y, result)) {
            this._searchHighPrecision = true;
            result                    = this.findDirectionTo(goalX, goalY);
        }
        return result;
    };

    var _Game_Character_searchLimit      = Game_Character.prototype.searchLimit;
    Game_Character.prototype.searchLimit = function() {
        return _Game_Character_searchLimit.apply(this, arguments) * (this.isSearchHighPrecision() ? 2 : 1);
    };

    Game_Character.prototype.isSearchHighPrecision = function() {
        return this._searchHighPrecision;
    };

    Game_Character.prototype.canDiagonalMove = function() {
        return paramDirection8Move && (param8MoveSwitch > 0 ? !$gameSwitches.value(param8MoveSwitch) : true);
    };

    Game_Character.prototype.getDiagonalRandomDirection = function() {
        var direction;
        do {
            direction = 1 + Math.randomInt(9);
        } while (!this.isDiagonalDirection(direction));
        return direction;
    };

    Game_Character.prototype.getDiagonalTowardDirection = function(x, y) {
        var sx        = this.deltaXFrom(x);
        var sy        = this.deltaYFrom(y);
        var direction = 5;
        if (sx !== 0) {
            direction += (sx < 0 ? 1 : -1);
        }
        if (sy !== 0) {
            direction += (sy < 0 ? -3 : 3);
        }
        return direction;
    };

    Game_Character.prototype.isDiagonalDirection = function(direction) {
        return direction !== 5 && direction % 2 === 1;
    };

    var _Game_Character_moveRandom      = Game_Character.prototype.moveRandom;
    Game_Character.prototype.moveRandom = function() {
        if (!this.canDiagonalMove() || Math.randomInt(2) === 0) {
            _Game_Character_moveRandom.apply(this, arguments);
        } else {
            this.executeDiagonalMove(this.getDiagonalRandomDirection());
        }
    };

    var _Game_Character_moveTowardCharacter      = Game_Character.prototype.moveTowardCharacter;
    Game_Character.prototype.moveTowardCharacter = function(character) {
        if (!this.canDiagonalMove() || Math.randomInt(4) === 0) {
            _Game_Character_moveTowardCharacter.apply(this, arguments);
            return;
        }
        var direction = this.getDiagonalTowardDirection(character.x, character.y);
        if (this.isDiagonalDirection(direction)) {
            this.executeDiagonalMove(direction);
            if (!this.isMovementSucceeded()) {
                _Game_Character_moveTowardCharacter.apply(this, arguments);
            }
        } else {
            _Game_Character_moveTowardCharacter.apply(this, arguments);
        }
    };

    var _Game_Character_moveAwayFromCharacter      = Game_Character.prototype.moveAwayFromCharacter;
    Game_Character.prototype.moveAwayFromCharacter = function(character) {
        if (!this.canDiagonalMove() || Math.randomInt(4) === 0) {
            _Game_Character_moveAwayFromCharacter.apply(this, arguments);
            return;
        }
        var direction = 10 - this.getDiagonalTowardDirection(character.x, character.y);
        if (this.isDiagonalDirection(direction)) {
            this.executeDiagonalMove(direction);
            if (!this.isMovementSucceeded()) {
                _Game_Character_moveAwayFromCharacter.apply(this, arguments);
            }
        } else {
            _Game_Character_moveAwayFromCharacter.apply(this, arguments);
        }
    };

    Game_Character.prototype.executeDiagonalMove = function(d) {
        var divide   = this.divideDirection(d);
        var horizon  = divide.horizon;
        var vertical = divide.vertical;
        this.moveDiagonally(horizon, vertical);
        if (this._firstInputDir === horizon) {
            this.moveStraightForRetry(vertical);
            this.moveStraightForRetry(horizon);
        } else {
            this.moveStraightForRetry(horizon);
            this.moveStraightForRetry(vertical);
        }
    };

    Game_Character.prototype.moveStraightForRetry = function(d) {
        if (!this.isMovementSucceeded()) {
            this.moveStraight(d);
        }
    };

    //=============================================================================
    // Game_Player
    //  8方向移動に対応させます。
    //=============================================================================
    var _Game_Player_initMembers      = Game_Player.prototype.initMembers;
    Game_Player.prototype.initMembers = function() {
        _Game_Player_initMembers.apply(this, arguments);
        this._testEventStart = false;
    };

    var _Game_Player_locate      = Game_Player.prototype.locate;
    Game_Player.prototype.locate = function(x, y) {
        _Game_Player_locate.apply(this, arguments);
        this.resetPrevPos();
    };

    var _Game_Player_increaseSteps      = Game_Player.prototype.increaseSteps;
    Game_Player.prototype.increaseSteps = function() {
        if (this._realStep === undefined) this._realStep = 0;
        this._realStep += (this.isHalfMove() ? Game_Map.tileUnit : 1);
        if (this.isHalfStep()) {
            Game_Character.prototype.increaseSteps.call(this);
        } else {
            _Game_Player_increaseSteps.apply(this, arguments);
        }
    };

    var _Game_Player_updateEncounterCount      = Game_Player.prototype.updateEncounterCount;
    Game_Player.prototype.updateEncounterCount = function() {
        if (!this.isHalfStep()) {
            _Game_Player_updateEncounterCount.apply(this, arguments);
        }
    };

    Game_Player.prototype.isHalfStep = function() {
        return paramAdjustmentRealStep && this._realStep && Math.floor(this._realStep) !== this._realStep;
    };

    var _Game_Player_isOnDamageFloor      = Game_Player.prototype.isOnDamageFloor;
    Game_Player.prototype.isOnDamageFloor = function() {
        return !this.isHalfStep() && _Game_Player_isOnDamageFloor.apply(this, arguments);
    };

    var _Game_Player_isCollided      = Game_Player.prototype.isCollided;
    Game_Player.prototype.isCollided = function(x, y) {
        if (_Game_Player_isCollided.apply(this, arguments)) {
            return true;
        }
        if (this.isThrough()) {
            return false;
        }
        return this.posUnitHt(x, y) || this._followers.isSomeoneUnitCollidedCollided(x, y);
    };

    var _Game_Player_getInputDirection      = Game_Player.prototype.getInputDirection;
    Game_Player.prototype.getInputDirection = function() {
        var result = this.canDiagonalMove() ? Input.dir8 : _Game_Player_getInputDirection.apply(this, arguments);
        if (result === 0) {
            this._firstInputDir = 0;
        } else if (result % 2 === 0 && this._firstInputDir === 0) {
            this._firstInputDir = result;
        }
        return result;
    };

    var _Game_Player_executeMove      = Game_Player.prototype.executeMove;
    Game_Player.prototype.executeMove = function(d) {
        if (d % 2 !== 0 && d !== 5) {
            this.executeDiagonalMove(d);
        } else {
            _Game_Player_executeMove.apply(this, arguments);
            if (!this.isMovementSucceeded() && this.isHalfMove() &&
                paramAvoidCorner && !$gameTemp.isDestinationValid() && !$gameMap.isEventRunning()) {
                this.executeMoveRetry(d);
            }
        }
    };

    var _Game_Player_startMapEvent      = Game_Player.prototype.startMapEvent;
    Game_Player.prototype.startMapEvent = function(x, y, triggers, normal) {
        _Game_Player_startMapEvent.apply(this, arguments);
        if ($gameMap.isEventRunning()) return;
        $gameMap.events().some(function(event) {
            if (event.isTriggerExpansion(x, y) && event.isTriggerIn(triggers) &&
                event.isNormalPriority() === normal && (event.isCollidedFromPlayer() || !event.isNormalPriority())) {
                event.start();
                if (event.isStarting() && paramMultiStartDisable) return true;
            }
            return false;
        });
    };

    var _Game_Player_startMapEvent2     = Game_Player.prototype.startMapEvent;
    Game_Player.prototype.startMapEvent = function(x, y, triggers, normal) {
        if (normal && this.isHalfMove()) {
            var d = this._frontDirection || this.direction();
            if (!this.canPass(this.x, this.y, d)) {
                _Game_Player_startMapEvent2.apply(this, arguments);
                arguments[0] = $gameMap.roundHalfXWithDirection(x, 10 - d);
                arguments[1] = $gameMap.roundHalfYWithDirection(y, 10 - d);
                _Game_Player_startMapEvent2.apply(this, arguments);
            }
        } else {
            _Game_Player_startMapEvent2.apply(this, arguments);
        }
    };

    var _Game_Player_triggerTouchAction      = Game_Player.prototype.triggerTouchAction;
    Game_Player.prototype.triggerTouchAction = function() {
        var result = _Game_Player_triggerTouchAction.apply(this, arguments);
        if (!result && $gameTemp.isDestinationValid()) {
            var direction    = this._frontDirection || this.direction();
            var x1           = this.x;
            var y1           = this.y;
            var x2           = $gameMap.roundHalfXWithDirection(x1, direction);
            var y2           = $gameMap.roundHalfYWithDirection(y1, direction);
            var x3           = $gameMap.roundXWithDirection(x2, direction);
            var y3           = $gameMap.roundYWithDirection(y2, direction);
            var destinationX = $gameTemp.destinationX();
            var destinationY = $gameTemp.destinationY();
            var tu           = Game_Map.tileUnit;
            if (x1 === destinationX && y1 === destinationY) {
                return false;
            }
            if (Math.abs(destinationX - x2) <= tu && Math.abs(destinationY - y2) <= tu) {
                return this.triggerTouchActionD2(x2, y2);
            } else if (Math.abs(destinationX - x3) <= tu && Math.abs(destinationY - y3) <= tu) {
                return this.triggerTouchActionD3(x2, y2);
            }
        }
        return result;
    };

    Game_Player.prototype.isStartingPreparedMapEvent = function(x, y) {
        $gameMap.events().forEach(function(event) {
            event.resetStartingPrepared();
        });
        this._testEventStart = true;
        this.startMapEvent(x, y, [0, 1, 2], true);
        if ($gameMap.isCounter(x, y)) {
            var x1 = $gameMap.roundXWithDirection(x, this.direction());
            var y1 = $gameMap.roundYWithDirection(y, this.direction());
            this.startMapEvent(x1, y1, [0], true);
        }
        this._testEventStart = false;
        return $gameMap.events().some(function(event) {
            return event.isStartingPrepared();
        });
    };

    Game_Player.prototype.isTestEventStart = function() {
        return this._testEventStart;
    };

    Game_Player.prototype.executeMoveRetry = function(d) {
        var x2 = $gameMap.roundXWithDirection(this.x, d);
        var y2 = $gameMap.roundYWithDirection(this.y, d);
        if (!this.isStartingPreparedMapEvent(x2, y2)) {
            if (d === 2 || d === 8) {
                this.moveDiagonallyForRetry(4, d);
                this.moveDiagonallyForRetry(6, d);
            }
            if (d === 4 || d === 6) {
                this.moveDiagonallyForRetry(d, 2);
                this.moveDiagonallyForRetry(d, 8);
            }
        }
    };

    Game_Player.prototype.resetPrevPos = function() {
        Game_CharacterBase.prototype.resetPrevPos.call(this);
        this.followers().forEach(function(follower) {
            follower.resetPrevPos();
        }.bind(this));
    };

    Game_Player.prototype.isCollidedWithEventsForHalfMove = function(x, y) {
        $gameMap.events().forEach(function(event) {
            event.setCollidedFromPlayer(false);
        });
        return Game_CharacterBase.prototype.isCollidedWithEventsForHalfMove.call(this, x, y);
    };

    Game_Player.prototype.collidedToEvent = function(target) {
        target.setCollidedFromPlayer(true);
    };

    var _Game_Player_getOnVehicle      = Game_Player.prototype.getOnVehicle;
    Game_Player.prototype.getOnVehicle = function() {
        var result = _Game_Player_getOnVehicle.apply(this, arguments);
        if (!result && this.isHalfMove()) {
            localHalfPositionCount++;
            result = _Game_Player_getOnVehicle.apply(this, arguments);
            localHalfPositionCount--;
        }
        return result;
    };

    var _Game_Player_moveStraightForRetry      = Game_Player.prototype.moveStraightForRetry;
    Game_Player.prototype.moveStraightForRetry = function(d) {
        if (this.canMove()) {
            _Game_Player_moveStraightForRetry.apply(this, arguments);
        }
    };

    var _Game_Player_updateNonmoving      = Game_Player.prototype.updateNonmoving;
    Game_Player.prototype.updateNonmoving = function(wasMoving) {
        _Game_Player_updateNonmoving.apply(this, arguments);
        if (!wasMoving) {
            this._searchHighPrecision = false;
        }
    };

    //=============================================================================
    // Game_Event
    //  半歩移動用の接触処理を定義します。
    //=============================================================================
    var _Game_Event_initialize      = Game_Event.prototype.initialize;
    Game_Event.prototype.initialize = function(mapId, eventId) {
        _Game_Event_initialize.apply(this, arguments);
        this._halfDisable      = getMetaValues(this.event(), ['HalfDisable', '半歩禁止']);
        this._throughDisable   = getMetaValues(this.event(), ['ThroughDisable', 'すり抜け禁止']);
        this._eventWidth       = getArgNumber(getMetaValues(this.event(), ['Width', '横幅']), 0);
        this._eventHeight      = getArgNumber(getMetaValues(this.event(), ['Height', '高さ']), 0);
        this._can8moveDisable  = getMetaValues(this.event(), ['8MoveDisable', '8方向移動禁止']);
        var metaValue          = getMetaValues(this.event(), ['TriggerExpansion', 'トリガー拡大']);
        this._triggerExpansion = metaValue ? getArgBoolean(metaValue) : paramTriggerExpansion;
        this._expansionArea    = this.getExpansionArea();
        var halfX              = getMetaValues(this.event(), ['初期半歩X', 'InitialHalfX']);
        var halfY              = getMetaValues(this.event(), ['初期半歩Y', 'InitialHalfY']);
        if (halfX || halfY) {
            this.initHalfPos(halfX, halfY);
        }
    };

    Game_Event.prototype.initHalfPos = function(halfX, halfY) {
        var newX = this.x;
        var newY = this.y;
        if (halfX === '-') {
            newX -= Game_Map.tileUnit;
        } else if (halfX) {
            newX += Game_Map.tileUnit;
        }
        if (halfY === '-') {
            newY -= Game_Map.tileUnit;
        } else if (halfY) {
            newY += Game_Map.tileUnit;
        }
        this.locate(newX, newY);
    };

    var _Game_Event_setupPage      = Game_Event.prototype.setupPage;
    Game_Event.prototype.setupPage = function() {
        _Game_Event_setupPage.apply(this, arguments);
        this._expansionArea = this.getExpansionArea();
    };

    Game_Event.prototype.getExpansionArea = function() {
        // Resolve conflict for MOG_ChronoEngine.js
        if (!this.event().meta) {
            this.event().meta = {};
        }
        var metaValue = getMetaValues(this.event(), ['ExpansionArea', '拡大領域']);
        if (metaValue) {
            this._customExpansion = true;
            return getArgArrayFloat(metaValue);
        } else if (this.isNormalPriority() && this.isThroughEnable()) {
            return [0, 0.5, 0.5, 0];
        } else {
            return [0.5, 0.5, 0.5, 0.5];
        }
    };

    var _Game_Event_isCollidedWithEvents      = Game_Event.prototype.isCollidedWithEvents;
    Game_Event.prototype.isCollidedWithEvents = function(x, y) {
        var result = _Game_Event_isCollidedWithEvents.apply(this, arguments);
        if (result) return true;
        var events         = $gameMap.eventsXyUnitNt(x, y);
        var collidedEvents = events.filter(function(event) {
            return event !== this && !event.isHalfThrough(y) && (!paramEventOverlap || event.isNormalPriority());
        }.bind(this));
        if (collidedEvents.length === 0) return false;
        return !paramEventOverlap || this.isNormalPriority();
    };

    var _Game_Event_isCollidedWithPlayerCharacters      = Game_Event.prototype.isCollidedWithPlayerCharacters;
    Game_Event.prototype.isCollidedWithPlayerCharacters = function(x, y) {
        var result = _Game_Event_isCollidedWithPlayerCharacters.apply(this, arguments);
        if (!result && !this.isHalfThrough($gamePlayer.y) && this.isNormalPriority()) {
            var tileUnit = Game_Map.tileUnit;
            result       = $gamePlayer.isCollided(x, y - tileUnit) || $gamePlayer.isCollided(x, y + tileUnit);
        }
        this.setCollidedFromPlayer(result);
        return result;
    };

    var _Game_Event_checkEventTriggerTouch      = Game_Event.prototype.checkEventTriggerTouch;
    Game_Event.prototype.checkEventTriggerTouch = function(x, y) {
        _Game_Event_checkEventTriggerTouch.apply(this, arguments);
        if ($gameMap.isEventRunning()) return;
        if (this._trigger === 2 && $gamePlayer.posUnit(x, y) && this.isTriggerExpansion(x, y)) {
            if (!this.isJumping() && this.isNormalPriority() && this.isCollidedFromPlayer()) {
                this.start();
            }
        }
    };

    var _Game_Event_checkEventTriggerTouch2     = Game_Event.prototype.checkEventTriggerTouch;
    Game_Event.prototype.checkEventTriggerTouch = function(x, y) {
        var d = this._frontDirection || this.direction();
        _Game_Event_checkEventTriggerTouch2.apply(this, arguments);
        arguments[0] = $gameMap.roundHalfXWithDirection(x, 10 - d);
        arguments[1] = $gameMap.roundHalfYWithDirection(y, 10 - d);
        _Game_Event_checkEventTriggerTouch2.apply(this, arguments);
    };

    var _Game_Event_start      = Game_Event.prototype.start;
    Game_Event.prototype.start = function() {
        if (!$gamePlayer.isTestEventStart()) {
            _Game_Event_start.apply(this, arguments);
        } else {
            var list = this.list();
            if (list && list.length > 1) {
                this._startingPrepared = true;
            }
        }
    };

    Game_Event.prototype.isStartingPrepared = function() {
        return this._startingPrepared;
    };

    Game_Event.prototype.resetStartingPrepared = function() {
        this._startingPrepared = false;
    };

    Game_Event.prototype.isTriggerExpansion = function(x, y) {
        return this._triggerExpansion && this.isInExpansionArea(x, y);
    };

    Game_Event.prototype.isInExpansionArea = function(x, y) {
        if (this.y + this._expansionArea[0] < y) {
            return false;
        } else if (this.x - this._expansionArea[1] > x) {
            return false;
        } else if (this.x + this._expansionArea[2] < x) {
            return false;
        } else if (this.y - this._expansionArea[3] > y) {
            return false;
        }
        return true;
    };

    Game_Event.prototype.isCollidedFromPlayer = function() {
        return this._collidedFromPlayer;
    };

    Game_Event.prototype.setCollidedFromPlayer = function(value) {
        this._collidedFromPlayer = value;
    };

    Game_Event.prototype.canDiagonalMove = function() {
        return !this._can8moveDisable && Game_Character.prototype.canDiagonalMove.call(this);
    };

    Game_Event.prototype.posExpansionNt = function(x, y) {
        if (this._triggerExpansion) {
            return this.isTriggerExpansion(x, y) && !this.isThrough();
        } else {
            return this.posUnitNt(x, y);
        }
    };

    //=============================================================================
    // Game_Follower
    //  追従処理を半歩移動に対応させます。
    //=============================================================================
    var _Game_Follower_chaseCharacter      = Game_Follower.prototype.chaseCharacter;
    Game_Follower.prototype.chaseCharacter = function(character) {
        if ($gamePlayer.followers().areGathering() || $gamePlayer.isInVehicle()) {
            character.resetPrevPos();
            _Game_Follower_chaseCharacter.apply(this, arguments);
        } else {
            var sx = this.deltaXFrom(character.getPrevX());
            var sy = this.deltaYFrom(character.getPrevY());
            if (sx !== 0 && sy !== 0) {
                this.moveDiagonally(sx > 0 ? 4 : 6, sy > 0 ? 8 : 2);
            } else if (sx !== 0) {
                this.moveStraight(sx > 0 ? 4 : 6);
            } else if (sy !== 0) {
                this.moveStraight(sy > 0 ? 8 : 2);
            }
            this.setMoveSpeed($gamePlayer.realMoveSpeed());
        }
    };

    //=============================================================================
    // Game_Followers
    //  追従処理を半歩移動に対応させます。
    //=============================================================================
    Game_Followers.prototype.isSomeoneUnitCollidedCollided = function(x, y) {
        return this.visibleFollowers().some(function(follower) {
            return follower.posUnitHt(x, y);
        }, this);
    };

    //=============================================================================
    // Game_CharacterBase
    //  禁止フラグを確認します。
    //=============================================================================
    Game_CharacterBase.prototype.isHalfMove = function() {
        return !this._halfDisable && $gameSystem.canHalfMove();
    };

    //=============================================================================
    // Game_Character
    //  移動ルート強制中は半歩移動を無効にします。
    //=============================================================================
    Game_Character.prototype.isHalfMove = function() {
        if (this._moveRouteForcing && !this.canHalfMoveDuringRouteForce()) {
            return false;
        }
        return Game_CharacterBase.prototype.isHalfMove.call(this) || this.isHalfPosX() || this.isHalfPosY();
    };

    Game_Character.prototype.canHalfMoveDuringRouteForce = function() {
        return this._halfMoveDuringRouteForce || !paramDisableForcing;
    };

    Game_Character.prototype.setHalfMoveDuringRouteForce = function() {
        this._halfMoveDuringRouteForce = true;
    };

    Game_Character.prototype.resetHalfMoveDuringRouteForce = function() {
        this._halfMoveDuringRouteForce = false;
    };

    //=============================================================================
    // Game_Player
    //  乗り物搭乗中は半歩移動を無効にします。
    //=============================================================================
    Game_Player.prototype.isHalfMove = function() {
        return Game_Character.prototype.isHalfMove.call(this) && !this.isInVehicle();
    };

    //=============================================================================
    // Game_Vehicle
    //  乗り物の半歩移動は無効
    //=============================================================================
    Game_Vehicle.prototype.isHalfMove = function() {
        return false;
    };

    //=============================================================================
    // Game_Follower
    //  フォロワーの半歩移動はプレイヤーに依存します。
    //=============================================================================
    Game_Follower.prototype.isHalfMove = function() {
        return $gamePlayer.isHalfMove() || this.isHalfPosX() || this.isHalfPosY();
    };

    // Resolve conflict for MPP_MiniMap_OP1.js
    //=============================================================================
    // Game_MiniMap
    //  描画判定において半歩座標を考慮します。
    //=============================================================================
    if (typeof Game_MiniMap === 'function') {
        var _Game_MiniMap_isFilled      = Game_MiniMap.prototype.isFilled;
        Game_MiniMap.prototype.isFilled = function(x, y) {
            arguments[0] = Math.floor(arguments[0]);
            arguments[1] = Math.floor(arguments[1]);
            return _Game_MiniMap_isFilled.apply(this, arguments);
        };
    }

    // Resolve conflict for KhasAdvancedLighting
    var _Game_Map_getHeight      = Game_Map.prototype.getHeight;
    Game_Map.prototype.getHeight = function(x, y) {
        if (this.isHalfPos(x)) {
            x -= Game_Map.tileUnit;
        }
        if (this.isHalfPos(y)) {
            y -= Game_Map.tileUnit;
        }
        _Game_Map_getHeight.call(this, x, y);
    };
})();


code:
//=============================================================================
// HighSpeedBossCollapseEffect.js
//
//=============================================================================
// Copyright (c) 2018-2019 uta_asakayu
// Released under the MIT license.
// http://opensource.org/licenses/mit-license.php
/*:
 * @plugindesc ボスの消滅エフェクトを高速化します
 * @author uta_asakayu
 * @help
 * ボスの消滅エフェクトを高速化します
 *
 * 再配布以外はご自由にお使いください
 *
 * ver 1.00 :リリース。単純に2倍速にしてみる
 *
*/

(function(){

const _Sprite_Enemy_updateBossCollapse = Sprite_Enemy.prototype.updateBossCollapse
  Sprite_Enemy.prototype.updateBossCollapse = function() {
    this._effectDuration -= this._effectDuration > 1 ? 1 : 0
    _Sprite_Enemy_updateBossCollapse.call(this)
};

})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// IRPP_MV_DisableAutoplayBGM.js
//=============================================================================

/*:
 * @plugindesc (※下部)指定のスイッチがONの時、BGMやMEの自動再生を禁止します。
 * @author イロスマRPG制作委員会
 *
 * @param MapBgm Switch
 * @desc マップのBGMの自動再生を禁止するスイッチのIDです。
 * @default 7
 * @type switch
 *
 * @param VehicleBgm Switch
 * @desc 乗り物のBGMの自動再生を禁止するスイッチのIDです。
 * @default 8
 * @type switch
 *
 * @param BattleBgm Switch
 * @desc 戦闘BGMの自動再生を禁止するスイッチのIDです。
 * @default 9
 * @type switch
 *
 * @param VictoryMe Switch
 * @desc 勝利MEの自動再生を禁止するスイッチのIDです。
 * @default 10
 * @type switch
 *
 * @help 指定のスイッチがONの時、BGMやMEの自動再生を禁止します。
 * また、スイッチがOFFの時は通常通りBGMやMEを再生します。
 */

var Imported = Imported || {};
Imported.IRPP_MV_DisableAutoplayBGM = true;
(function() {
var Parameters = PluginManager.parameters('IRPP_MV_DisableAutoplayBGM');
var mapBgmSwitch = Number(Parameters['MapBgm Switch'] || 7);
var vehicleBgmSwitch = Number(Parameters['VehicleBgm Switch'] || 8);
var battleBgmSwitch = Number(Parameters['BattleBgm Switch'] || 9);
var victoryMeSwitch = Number(Parameters['VictoryMe Switch'] || 10);

var _Game_System_saveWalkingBgm = Game_System.prototype.saveWalkingBgm;
Game_System.prototype.saveWalkingBgm = function() {
    if (!$gameSwitches.value(vehicleBgmSwitch)) {
      _Game_System_saveWalkingBgm.call(this);
    }
};

var _Game_System_replayWalkingBgm = Game_System.prototype.replayWalkingBgm;
Game_System.prototype.replayWalkingBgm = function() {
    if (!$gameSwitches.value(vehicleBgmSwitch)) {
      _Game_System_replayWalkingBgm.call(this);
    }
};

var _Game_Map_autoplay = Game_Map.prototype.autoplay;
Game_Map.prototype.autoplay = function() {
    if (!$gameSwitches.value(mapBgmSwitch)) {
        _Game_Map_autoplay.call(this);
    }
};

var _Scene_Map_stopAudioOnBattleStart = Scene_Map.prototype.stopAudioOnBattleStart;
Scene_Map.prototype.stopAudioOnBattleStart = function() {
    if ($gameSwitches.value(battleBgmSwitch)) {
        AudioManager.stopBgs();
        AudioManager.stopMe();
        AudioManager.stopSe();
    } else {
        _Scene_Map_stopAudioOnBattleStart.call(this);
        AudioManager.playBgm($gameSystem.battleBgm());
    }
};

var _Game_Vehicle_playBgm = Game_Vehicle.prototype.playBgm;
Game_Vehicle.prototype.playBgm = function() {
    if (!$gameSwitches.value(vehicleBgmSwitch)) {
      _Game_Vehicle_playBgm.call(this);
    }
};

var _BattleManager_playBattleBgm = BattleManager.playBattleBgm;
BattleManager.playBattleBgm = function() {
    if (!$gameSwitches.value(battleBgmSwitch)) {
      _BattleManager_playBattleBgm.call(this);
    }
};

var _BattleManager_playVictoryMe = BattleManager.playVictoryMe;
BattleManager.playVictoryMe = function() {
    if (!$gameSwitches.value(victoryMeSwitch)) {
      _BattleManager_playVictoryMe.call(this);
    }
};
})();


code:
//=============================================================================
// IRPP_MV_PrizeShop.js
//=============================================================================

/*:
 * @plugindesc (※下部)特殊なショップの処理を実装します。
 * @author イロスマRPG制作委員会
 *
 * @param Page1
 * @text 基本設定
 *
 * @param SellShop SID
 * @desc 売却ショップの判定に使うスイッチIDです。
 * @default 12
 * @type switch
 * @parent Page1
 *
 * @param BuyingPrice VID
 * @desc 購入価格の割合を指定する変数のIDです。
 * @default 10
 * @type variable
 * @parent Page1
 *
 * @param SellingPrice VID
 * @desc 売却価格の割合を指定する変数のIDです。
 * @default 11
 * @type variable
 * @parent Page1
 *
 * @param Page2
 * @text 交換ショップ
 *
 * @param ItemShop SID
 * @desc 交換ショップの判定に使うスイッチIDです。
 * @default 13
 * @type switch
 * @parent Page2
 *
 * @param ItemMoney VID
 * @desc 交換対象のアイテムIDの指定に使う変数IDです。
 * @default 12
 * @type variable
 * @parent Page2
 *
 * @param Text Buy ItemShop
 * @desc 交換ショップの「購入する」の名称です。
 * @default 交換する
 * @parent Page2
 *
 * @param Text Sell ItemShop
 * @desc 交換ショップの「購入する」の名称です。
 * @default 引換する
 * @parent Page2
 *
 * @param Text ItemMoney
 * @desc 交換ショップの通貨単位名です。
 * @default 個
 * @parent Page2
 *
 * @param Show Sell Item
 * @desc 交換ショップで「売却する」を表示を表示しますか？
 * @default 0
 * @type select
 * @option false
 * @value 0
 * @option true
 * @value 1
 * @parent Page2
 *
 * @param Page3
 * @text 変数ショップ
 *
 * @param VariableShop SID
 * @desc 変数ショップの判定に使うスイッチIDです。
 * @default 14
 * @type switch
 * @parent Page3
 *
 * @param VariableMoney VID
 * @desc 変数ショップの通貨に使う変数IDです。
 * @default 13
 * @type variable
 * @parent Page3
 *
 * @param Text Buy VariableShop
 * @desc 変数ショップの「購入する」の名称です。
 * @default 交換する
 * @parent Page3
 *
 * @param Text Sell VariableShop
 * @desc 変数ショップの「購入する」の名称です。
 * @default 引換する
 * @parent Page3
 *
 * @param Text VariableMoney
 * @desc 変数ショップの通貨単位名です。
 * @default BP
 * @parent Page3
 *
 * @param Show Sell Variable
 * @desc 変数ショップで「売却する」を表示を表示しますか？
 * @default 0
 * @type select
 * @option false
 * @value 0
 * @option true
 * @value 1
 * @parent Page3
 *
 * @help アイテム、武器、防具のメモ欄に以下を書くと
 * そのアイテム類の値段に関わらず売却できなくなります。
 * <DisableSelling>
 *
 * 使い方:
 * 「ItemShop SID」で指定したスイッチをONにすると
 * 交換ショップになります。
 *
 * 「VariableShop SID」で指定したスイッチをONにすると
 * 変数ショップになります。
 *
 * 「SellShop SID」で指定したスイッチをONにすると
 * 売却ショップになります。
 * また、「購入のみ」の設定が無視されます。
 *
 * 交換ショップの場合:
 * 「ItemMoney VID」で指定した変数IDが1で、
 * その変数の値が1の時は1番目のアイテムが通貨になります。
 *
 * 変数ショップの場合:
 * 「VariableMoney VID」で指定した変数IDが2の場合、
 * その変数が通貨になります。
 */

var Imported = Imported || {};
Imported.IRPP_MV_PrizeShop = true;
(function() {
var Parameters = PluginManager.parameters('IRPP_MV_PrizeShop');
var sellShop_SID = Number(Parameters['SellShop SID'] || 12);
var buyingPrice_VID = Number(Parameters['BuyingPrice VID'] || 10);
var sellingPrice_VID = Number(Parameters['SellingPrice VID'] || 11);
var itemShop_SID = Number(Parameters['ItemShop SID'] || 13);
var itemMoney_VID = Number(Parameters['ItemMoney VID'] || 12);
var showSell_Item = Number(Parameters['Show Sell Item'] || 0);
var variableShop_SID = Number(Parameters['VariableShop SID'] || 14);
var variableMoney_VID = Number(Parameters['VariableMoney VID'] || 13);
var showSell_Variable = Number(Parameters['Show Sell Variable'] || 0);
var textBuy_ItemShop = String(Parameters['Text Buy ItemShop'] || '交換する');
var textSell_ItemShop = String(Parameters['Text Sell ItemShop'] || '引換する');
var text_ItemMoney = String(Parameters['Text ItemMoney'] || '個');
var textBuy_VidShop = String(Parameters['Text Buy VariableShop'] || '交換する');
var textSell_VidShop = String(Parameters['Text Sell VariableShop'] || '引換する');
var text_VariableMoney = String(Parameters['Text VariableMoney'] || 'BP');
var reDisableSelling = /<DisableSelling>/i;

var _DataManager_setupNewGame = DataManager.setupNewGame;
DataManager.setupNewGame = function() {
    _DataManager_setupNewGame.call(this);
    $gameVariables.setValue(buyingPrice_VID, 100);
    $gameVariables.setValue(sellingPrice_VID, 100);
};

var _Scene_Shop_terminate = Scene_Shop.prototype.terminate;
Scene_Shop.prototype.terminate = function() {
    _Scene_Shop_terminate.call(this);
    $gameVariables.setValue(buyingPrice_VID, 100);
    $gameVariables.setValue(sellingPrice_VID, 100);
    $gameSwitches.setValue(sellShop_SID, false);
    $gameSwitches.setValue(itemShop_SID, false);
    $gameSwitches.setValue(variableShop_SID, false);
};

var _Scene_Shop_doBuy = Scene_Shop.prototype.doBuy;
Scene_Shop.prototype.doBuy = function(number) {
    if ($gameSwitches.value(itemShop_SID)) {
      $gameParty.loseItem($dataItems[$gameVariables.value(itemMoney_VID)], number * this.buyingPrice());
      $gameParty.gainItem(this._item, number);
    } else if ($gameSwitches.value(variableShop_SID)) {
      var oldCount = $gameVariables.value(variableMoney_VID);
      $gameVariables.setValue(variableMoney_VID, oldCount - (number * this.buyingPrice()));
      $gameParty.gainItem(this._item, number);
    } else {
      _Scene_Shop_doBuy.call(this, number);
    }
};

var _Scene_Shop_doSell = Scene_Shop.prototype.doSell;
Scene_Shop.prototype.doSell = function(number) {
    if ($gameSwitches.value(itemShop_SID)) {
      $gameParty.gainItem($dataItems[$gameVariables.value(itemMoney_VID)], number * this.sellingPrice());
      $gameParty.loseItem(this._item, number);
    } else if ($gameSwitches.value(variableShop_SID)) {
      var oldCount = $gameVariables.value(variableMoney_VID);
      $gameVariables.setValue(variableMoney_VID, oldCount + (number * this.sellingPrice()));
      $gameParty.loseItem(this._item, number);
    } else {
      _Scene_Shop_doSell.call(this, number);
    }
};

var _Scene_Shop_sellingPrice = Scene_Shop.prototype.sellingPrice;
Scene_Shop.prototype.sellingPrice = function() {
    return Math.floor(Math.max(_Scene_Shop_sellingPrice.call(this) * $gameVariables.value(sellingPrice_VID) * 0.01, 0));
};

var _Window_Gold_value = Window_Gold.prototype.value;
Window_Gold.prototype.value = function() {
    if ($gameSwitches.value(itemShop_SID)) {
      return $gameParty.numItems($dataItems[$gameVariables.value(itemMoney_VID)]);
    } else if ($gameSwitches.value(variableShop_SID)) {
      return $gameVariables.value(variableMoney_VID);
    } else {
      return _Window_Gold_value.call(this);
    }
};

var _Window_Gold_currencyUnit = Window_Gold.prototype.currencyUnit;
Window_Gold.prototype.currencyUnit = function() {
    if ($gameSwitches.value(itemShop_SID)) {
      return text_ItemMoney;
    } else if ($gameSwitches.value(variableShop_SID)) {
      return text_VariableMoney;
    } else {
      return _Window_Gold_currencyUnit.call(this);
    }
};

var _Window_ShopCommand_makeCommandList = Window_ShopCommand.prototype.makeCommandList;
Window_ShopCommand.prototype.makeCommandList = function() {
    if ($gameSwitches.value(itemShop_SID)) {
      if ($gameSwitches.value(sellShop_SID)) {
        this.addCommand(textSell_ItemShop,   'sell');
      } else {
        this.addCommand(textBuy_ItemShop,    'buy');
        if (showSell_Item == 1) {
          this.addCommand(textSell_ItemShop,   'sell',   !this._purchaseOnly);
        }
      }
      this.addCommand(TextManager.cancel, 'cancel');
    } else if ($gameSwitches.value(variableShop_SID)) {
      if ($gameSwitches.value(sellShop_SID)) {
        this.addCommand(textSell_VidShop,   'sell');
      } else {
        this.addCommand(textBuy_VidShop,    'buy');
        if (showSell_Variable == 1) {
          this.addCommand(textSell_VidShop,   'sell',   !this._purchaseOnly);
        }
      }
      this.addCommand(TextManager.cancel, 'cancel');
    } else if ($gameSwitches.value(sellShop_SID)) {
      this.addCommand(TextManager.sell,   'sell');
      this.addCommand(TextManager.cancel, 'cancel');
    } else {
      _Window_ShopCommand_makeCommandList.call(this);
    }
};

var _Window_ShopBuy_price = Window_ShopBuy.prototype.price;
Window_ShopBuy.prototype.price = function(item) {
    return Math.floor(Math.max(_Window_ShopBuy_price.call(this, item) * ($gameVariables.value(buyingPrice_VID) * 0.01), 0));
};

var _Window_ShopSell_isEnabled = Window_ShopSell.prototype.isEnabled;
Window_ShopSell.prototype.isEnabled = function(item) {
    return _Window_ShopSell_isEnabled.call(this, item) && !(reDisableSelling.exec(item.note) != null) &&
           (($gameSwitches.value(itemShop_SID)) ? !(item == $dataItems[$gameVariables.value(itemMoney_VID)]):true);
};
})();


code:
//=============================================================================
// IZ_ChoiceWindow
//=============================================================================

//=============================================================================
/*:
* @plugindesc v1.0 選択肢ウィンドウをスマホ操作に最適化します。
*
* @author いず
* @help
*・選択肢ウィンドウを横長に表示して、スマホの縦持ち操作に最適化します。
*・エディタの選択肢ウィンドウ表示位置の設定で、
*　ウィンドウの位置の設定の代わりに選択肢の列数を選択するようにします。
*
* 位置    行数
* 左      4
* 中      1
* 右      1
*
* 左指定時のみ動作するように変更 by suzu (MPP_CoiceEXより上に配置)
*/

(function () {

    //-----------------------------------------------------------------------------
    // Window_ChoiceList
    //
    // The window used for the event command [Show Choices].

    //
    // MPP_ChoiceEX.js との競合バグ回避 by suzu
    //
    var _Window_ChoiceList_start = Window_ChoiceList.prototype.start;
    Window_ChoiceList.prototype.start = function(){
        this.resetScroll();
        _Window_ChoiceList_start.call(this);
    }

    //
    //■選択肢ウィンドウの場所を変更する機能を列数変更機能に書き換え
    //
    // MPP_ChoiceEX.js との競合バグ回避 by suzu
    // 関数実行順変更
    var _Window_ChoiceList_updatePlacement = Window_ChoiceList.prototype.updatePlacement;
    Window_ChoiceList.prototype.updatePlacement = function () {
        var positionType = $gameMessage.choicePositionType();
        var messageY = this._messageWindow.y;
        this.width = this.windowWidth();
        switch (positionType) {
            case 0:
                this.x = 0;
                Window_ChoiceList.prototype.maxCols = function () {
                	if($gameSwitches.value(628)){ //にんじん探しミニゲーム中
	                    return 8;
	                }else{
	                    return 4;
	                }
                };
                break;
            case 1:
                this.x = (Graphics.boxWidth - this.width) / 2;
                Window_ChoiceList.prototype.maxCols = function () {
                    return 1;
                };
                break;
            case 2:
                this.x = Graphics.boxWidth - this.width;
                Window_ChoiceList.prototype.maxCols = function () {
                //本の整理ミニゲーム中
                	if($gameSwitches.value(282)){
                		return 3;
                	}else{
	                    return 1;
	                }
                };
                break;
        }
        this.height = this.windowHeight();
        if (messageY >= Graphics.boxHeight / 2) {
            this.y = messageY - this.height;
        } else {
            this.y = messageY + this._messageWindow.height;
        }

    };

    //
    //■ウィンドウ幅を画面幅に合わせる
    //
    // 左指定時のみ動作に変更 by suzu
    Window_ChoiceList.prototype.windowWidth = function () {
        var positionType = $gameMessage.choicePositionType();
        switch(positionType){
            case 0:
                return Graphics.boxWidth;
            case 1:
            case 2:
                var width = this.maxChoiceWidth() + this.padding * 2;
                return Math.min(width, Graphics.boxWidth);
            default:
                var width = this.maxChoiceWidth() + this.padding * 2;
                return Math.min(width, Graphics.boxWidth);
        }
    };

    //
    //■行数の調整
    //
    Window_ChoiceList.prototype.numVisibleRows = function () {
        var messageY = this._messageWindow.y;
        var messageHeight = this._messageWindow.height;
        var centerY = Graphics.boxHeight / 2;
        var choices = $gameMessage.choices();

        var positionType = $gameMessage.choicePositionType();
        switch (positionType) {
            case 0:
                var numLines = Math.ceil(choices.length / 2);
                break;
            case 1:
                var numLines = choices.length;
                break;
            case 2:
                var numLines = Math.ceil(choices.length / 3);
                break;
        }
        var maxLines = 8;
        if (messageY < centerY && messageY + messageHeight > centerY) {
            maxLines = 4;
        }
        if (numLines > maxLines) {
            numLines = maxLines;
        }
        return numLines;
    };

    //
    //■１つの選択肢に表示できる文字数の調整
    //　（上手いやり方がわからないので暫定的に最大240pxにしておく）
    //
    Window_ChoiceList.prototype.maxChoiceWidth = function () {
        var maxWidth = 240;//表示できる文章の最大長さ（px）
        var choices = $gameMessage.choices();
        for (var i = 0; i < choices.length; i++) {
            var choiceWidth = this.textWidthEx(choices[i]) + this.textPadding() * 2;
            if (maxWidth < choiceWidth) {
                maxWidth = choiceWidth;
            }
        }
        return maxWidth;
    };

})();


code:
//=============================================================================
// InfoWindow.js
//=============================================================================

/*:
 * @plugindesc 情報表示ウィンドウをメニュー画面に追加するプラグイン
 * @author Me
 *
 * @help 情報表示ウィンドウをメニュー画面上に追加します。
 *
 * 2020.12.27 suzu 表示ウィンドウの表示/非表示切り替え機能の追加
 *
 * @param display switch
 * @desc 情報表示ウィンドウの表示/非表示を切り替えるスイッチNo
 * @default 0
 * @type number
 *
 */

(function() {

    var parameters = PluginManager.parameters('InfoWindow');
	var displaySwitchNo = Number(parameters['display switch'] || 0);

	var gaugeBitmap = ImageManager.loadSystem('Gauge');
	var gaugeWidth = gaugeBitmap.width;
	var gaugeHeight = gaugeBitmap.height;

	// マップ上にウィンドウ表示するよ宣言
	var Scene_map_start = Scene_Map.prototype.start;
	Scene_Map.prototype.start = function() {
		Scene_map_start.call(this);
	    this._InfoWindow = new Window_Info();
	    this.addWindow(this._InfoWindow);
	};
    var _Scene_Map_update = Scene_Map.prototype.update;
    Scene_Map.prototype.update = function() {
        _Scene_Map_update.call(this);
        this._InfoWindow.setText();
    };

	Window_Base.prototype.drawHypnoGauge = function(x, y, width, rate, color1, color2) {
		x -=256;
    	this.contents.blt(gaugeBitmap, 0, 0, gaugeWidth, gaugeHeight, x, y);
    	var fillW = Math.floor((width - 2) * rate);
    	var fillH = gaugeHeight - 4;
    	var gaugeFillRect = new Rectangle(2, 2, fillW, fillH);
    	this.contents.fillRect(gaugeFillRect.x + x, gaugeFillRect.y + y, Math.floor(width - 2), gaugeFillRect.height);
    	this.contents.clearRect(gaugeFillRect.x + x+1, gaugeFillRect.y + y-1, Math.floor(width - 4), gaugeFillRect.height+1);
    	this.contents.fillRect(gaugeFillRect.x + x + 1, gaugeFillRect.y + y - 1, Math.floor(width - 4), gaugeFillRect.height, 'rgba(0, 0, 0, 0.5)');
		// ゲージの色
    	this.contents.gradientFillRect(gaugeFillRect.x + x + 1, gaugeFillRect.y + y - 1, Math.floor((width - 4) * rate), gaugeFillRect.height, color1, color2);
    	// ゲージのふち
	}
	;

	// ここからメニューウィンドウ作り始まります。
	function Window_Info() {
	    this.initialize.apply(this, arguments);
	}

	Window_Info.prototype = Object.create(Window_Base.prototype);
	Window_Info.prototype.constructor = Window_Info;
	Window_Info.prototype.initialize = function() {
		var x = -40;
		var y = -18;
	    var width = 1064;
	    var height = 95;
	    if($gameVariables.value(8)>=1){
		    Window_Base.prototype.initialize.call(this, x, y, width, height);
		}else{
		    Window_Base.prototype.initialize.call(this, x+1024, y, width, height);
		}
		/**
		 * 2020.12.27 suzu 非表示切り替え機能の追加
		 */
		if(!!$gameSwitches.value(displaySwitchNo)){
			this.opacity = 0;
			this.contentsOpacity = 0;
		}
	};

	Window_Info.prototype.setText = function(str) {
		this._text = str;
		this.refresh();
	};

	// ウィンドウに載せる内容
	Window_Info.prototype.refresh = function() {
	    this.contents.clear();
		//日付情報計算部
	    switch($gameVariables.value(2)){
	    	case 0:
	    		var time1 = "\\I[1017]";
	    		var time2 = "\\fs[11] Morning ";
	    		break;
	    	case 1:
	    		var time1 = "\\I[1018]";
	    		var time2 = "\\fs[11]Afternoon";
	    		break;
	    	case 2:
	    		var time1 = "\\I[1019]";
	    		var time2 = "\\fs[11] Evening ";
	    		break;
	    	case 3:
	    		var time1 = "\\I[1020]";
	    		var time2 = "\\fs[11]  Night  ";
	    		break;
	    	case 4:
	    		var time1 = "\\I[1020]";
	    		var time2 = "\\fs[11]Mid Night";
	    		break;
	    	case 5:
	    		var time1 = "\\I[1020]";
	    		var time2 = "\\fs[11]  Dream  ";
	    		break;
	    	default:
	    		var time1 = "\\I[1020]";
	    		var time2 = "\\fs[11]  ?????  ";
	    		break;
	    }

		if(!$gameSwitches.value(15)){
			var color = 16;
		}else{
			var color = 21;
		}

		var day = "  " +  $gameVariables.value(4);
	    var day_info = "\\fs[28]" + day.slice(-3) +`\\fs[22]\\C[${color}]（\\C[0]` + $gameVariables.value(3)[$gameVariables.value(4)%7]  + `\\C[${color}]）`

		//学内風紀計算部
		var school_value = "  " +$gameVariables.value(149);
		var school_info = school_value.slice(-3) + `\\C[${color}]/\\C[0]100`;

		//所有SP計算部
		var sp_value = "00000000" +$gameVariables.value(142);
		var sp_info = sp_value.slice(-8)+ ` \\C[${color}]pt\\C[0]`;

		//リリィのHP計算部
		var lily_hp = "   " + $gameVariables.value(122)
		var lily_maxhp = $gameVariables.value(123) + "   ";
		var lilyinfo = lily_hp.slice(-4) + `\\C[${color}]/\\C[0]` + lily_maxhp.slice(0,4);

		//彩羽のHP計算部
		var Iroha_hp = "   " + $gameActors.actor(1).hp;
		var Iroha_maxhp = $gameActors.actor(1).param(0) + "   ";
		var Irohainfo   = Iroha_hp.slice(-4) + `\\C[${color}]/\\C[0]` + Iroha_maxhp.slice(0,4);

		//催眠抵抗値計算部
		var hypno_value = "   " + $gameVariables.value(262)
		if(hypno_value==100){
			var hypno_info = hypno_value.slice(-3) + `\\C[${color}]/\\C[0]100`;
		}else if(hypno_value<10){
			var hypno_info = "  " + hypno_value.slice(-3) + "\\C[0]" + `\\C[${color}]/\\C[0]100`;
		}else{
			var hypno_info = " " + hypno_value.slice(-3) + "\\C[0]" + `\\C[${color}]/\\C[0]100`;
		}

		//佐井の魔力計算部
		var sai_value = "   " + $gameVariables.value(346)
		if(sai_value==100){
			var sai_info = sai_value.slice(-3) + `\\C[${color}] %\\C[0]`;
		}else if(hypno_value<10){
			var sai_info = "  " + sai_value.slice(-3) + "\\C[0]" + `\\C[${color}] %\\C[0]`;
		}else{
			var sai_info = " " + sai_value.slice(-3) + "\\C[0]" + `\\C[${color}] %\\C[0]`;
		}

		//行動力計算部
		var stamina_now = "  " + $gameVariables.value(160);
		var stamina_max = $gameVariables.value(161) +  "  ";
		var stamina = stamina_now.slice(-3) + `\\C[${color}]/\\C[0]` + stamina_max.slice(0,3);

		this.drawTextEx(time1,32,1);
		this.drawTextEx(time2,26,15);
		this.drawTextEx(day_info,140,2);
		if(!$gameSwitches.value(15)){
			if($gameSwitches.value(257)){
			    this.drawHypnoGauge(570, 29, 210, $gameVariables.value(346)/100, "#4A35E4","#FF57FF" );
			    if($gameVariables.value(346) < 10){
					this.drawTextEx(sai_info,470, 0);
				}else{
					this.drawTextEx(sai_info,462, 0);
				}
			}else if(!$gameSwitches.value(253)){
				this.drawTextEx(school_info,410, 0);
			}else{
				if($gameVariables.value(24)>=30){
			    	this.drawHypnoGauge(570, 29, 210, $gameVariables.value(262)/100, "#4A35E4","#FF57FF" );
					this.drawTextEx(hypno_info,434, 0);
				}
			}
		}else{
			this.drawTextEx(sp_info,396, 0);
		}
		if(!$gameSwitches.value(15)){
			if(!$gameSwitches.value(4)){
				this.drawTextEx(Irohainfo,700 + (7 - Iroha_hp.length)*6, 0);
			}else{
				this.drawTextEx(lilyinfo,700, 0);
			}
		}else{
			this.drawTextEx(Irohainfo,700 + (7 - Iroha_hp.length)*6, 0);
		}
		this.drawTextEx(stamina,930, 0);
		this.resetTextColor();
	};

	// フォントサイズ
	Window_Info.prototype.standardFontSize = function() {
    	return 20;
    };
	// ウィンドウの透明度
	Window_Info.prototype.standardBackOpacity = function() {
    	return 200;
	};
    // ウィンドウの余白
	Window_Info.prototype.standardPadding = function() {
    	return 18;
	};

	/**
	 * 2020.12.27 suzu 非表示切り替え機能の追加
	 */
	var _Window_Info_update = Window_Info.prototype.update;
	Window_Info.prototype.update = function(){
		_Window_Info_update.call(this);

		if(displaySwitchNo <= 0){
			return;
		}

		if(!!$gameSwitches.value(displaySwitchNo) && this.isOpen() && !this.isOpening()){
			this.close();
		}
		else if(!$gameSwitches.value(displaySwitchNo) && this.isClosed() && !this.isClosing()){
			this.open();
			this.opacity = 255;
			this.contentsOpacity = 255;
		}
	}

})();