2260 lines
65 KiB
JavaScript
2260 lines
65 KiB
JavaScript
//=============================================================================
|
||
// MPP_MiniMap.js
|
||
//=============================================================================
|
||
// Copyright (c) 2017 - 2022 Mokusei Penguin
|
||
// Released under the MIT license
|
||
// http://opensource.org/licenses/mit-license.php
|
||
//=============================================================================
|
||
|
||
/*:
|
||
* @target MV MZ
|
||
* @plugindesc Display the minimap on the screen.
|
||
* @author Mokusei Penguin
|
||
* @url
|
||
*
|
||
* @help [version 4.3.1]
|
||
* This plugin is for RPG Maker MV and MZ.
|
||
*
|
||
* ▼ Plugin command
|
||
* - In MV, the variable N is referred to by writing 'v[N]' in the item for
|
||
* inputting a numerical value.
|
||
* - In MZ, in the item to enter a numerical value, select the text and
|
||
* write 'v[N]' to refer to the variable N.
|
||
*
|
||
* 〇 MV / MZ
|
||
*
|
||
* 〇 ShowMinimap index / show
|
||
* index : number(0:Hide)
|
||
* - Display the minimap.
|
||
* - The display position and size set in the plug-in parameter
|
||
* [Display Positions] are applied.
|
||
*
|
||
* 〇 SetMinimapZoom zoom / setZoom
|
||
* zoom : magnification(-1:Whole, 0:Default / 1x at 100)
|
||
* - Only change the magnification of the minimap display.
|
||
*
|
||
* 〇 AddMarker x y m tag / addMarker
|
||
* x : X coordinate
|
||
* y : Y coordinate
|
||
* m : Marker string
|
||
* tag : tag(Arbitrary value / Not set:0)
|
||
* - Place a marker at the coordinates (x, y) of the current map.
|
||
* - Tags are used when deleting.
|
||
*
|
||
* 〇 RemoveMarker tag / removeMarker
|
||
* tag : tag
|
||
* - Deletes all markers for the specified tag.
|
||
*
|
||
* 〇 RemoveMarkerXy x y / removeMarkerXy
|
||
* x : X coordinate
|
||
* y : Y coordinate
|
||
* - Delete the marker at the coordinates (x, y) of the current map.
|
||
*
|
||
* ▼ Map notes
|
||
* 〇 <Minimap:name>
|
||
* - Specifies the file name of the minimap image for this map.
|
||
* - Put the image files in img/pictures.
|
||
*
|
||
* 〇 <MinimapZoom:n>
|
||
* - Sets the initial value for the minimap magnification for this map.
|
||
* - The variable N is referenced by writing 'v[N]'.
|
||
*
|
||
* ▼ Event notes
|
||
* 〇 <Marker:m>
|
||
* - Set markers for this event.
|
||
*
|
||
* ▼ [Comment] of the execution content of the event
|
||
* 〇 MinimapMarker m
|
||
* - Set a marker for the event when the EV page is displayed.
|
||
* - If <Marker:m> is set, this will be prioritized.
|
||
*
|
||
* ▼ Marker designation
|
||
* - Markers are specified as a combination of strings and numbers.
|
||
* TCO
|
||
* T = <Type>
|
||
* C = <Color number>
|
||
* O = <Option>
|
||
* - There are the following 8 types of <Type>.
|
||
* P : Point type (●)
|
||
* A : Arrow type / Synchronize with the orientation of the character
|
||
* I : Icon type / Icon image set by plugin parameters
|
||
* T : Triangle type (▲)
|
||
* S : Square type (■)
|
||
* R : Rhombus type (◆)
|
||
* X : Cross mark type (×)
|
||
* C0- : Circle type / Specify the radius after C and insert a hyphen(-)
|
||
* - <Color number> is the same as the text color of [Display text].
|
||
* - See img/system/Window.png for specific colors.
|
||
* - Add <Option> when you want the following functions.
|
||
* B : Blink flag
|
||
* T : Synchronize with the orientation of the character / Icon type only
|
||
* H : Displayed in front of other markers / Always displayed even outside the minimap
|
||
* M : For MPP_MiniMap_Op1.js / Display only in the mapped range
|
||
* - Multiple <Option> can be set.
|
||
* - All strings work in either case.
|
||
*
|
||
* ▼ Plugin parameters
|
||
* 〇 Map Ids / Wall Region IDs / Floor Region IDs
|
||
* - Range specification is available for these plug-in parameters.
|
||
* - You can specify a number from n to m by writing n-m.
|
||
* Example: 1-4,8,10 => 1 to 4 and 8 and 10
|
||
*
|
||
* 〇 Icon Image
|
||
* - The icon image is made up of eight horizontally arranged blocks as
|
||
* one block, and the blocks are lengthened as long as necessary.
|
||
* - The width and height of the icon is the width of the image divided by 8.
|
||
*
|
||
* ================================
|
||
* Mail : wood_penguin＠yahoo.co.jp (＠ is half-width)
|
||
* Blog : http://woodpenguin.blog.fc2.com/
|
||
* License : MIT license
|
||
*
|
||
* @command show
|
||
* @desc
|
||
* @arg index
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
*
|
||
* @command setZoom
|
||
* @desc
|
||
* @arg zoom
|
||
* @desc 100:1x
|
||
* @type number
|
||
* @min -1
|
||
* @max 10000
|
||
* @default 100
|
||
*
|
||
* @command addMarker
|
||
* @desc
|
||
* @arg x
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
* @arg y
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
* @arg marker
|
||
* @desc Type: P,A,I,C0- / Color number / Option: B,T,H,M
|
||
* Can be used in both uppercase and lowercase
|
||
* @type string
|
||
* @default P0
|
||
*
|
||
* @command removeMarker
|
||
* @desc
|
||
* @arg x
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
* @arg y
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
*
|
||
*
|
||
* @param Map Ids
|
||
* @desc An array of map IDs to display the minimap
|
||
* (Range can be specified)
|
||
* @default 1-5
|
||
*
|
||
* @param Display Positions
|
||
* @desc
|
||
* @type struct<DisplayPositions>[]
|
||
* @default ["{\"X\":\"32\",\"Y\":\"32\",\"Width\":\"160\",\"Height\":\"120\",\"Opacity\":\"192\",\"Zoom\":\"150\",\"Frame Image\":\"\"}"]
|
||
*
|
||
* @param Blink Duration
|
||
* @desc
|
||
* @type number
|
||
* @min 1
|
||
* @max 999
|
||
* @default 80
|
||
*
|
||
* @param Blur Level
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 10
|
||
* @default 4
|
||
*
|
||
* @param Wall Region IDs
|
||
* @desc An array of region IDs to display as impassable
|
||
* (Range can be specified)
|
||
* @default 63
|
||
*
|
||
* @param Floor Region IDs
|
||
* @desc An array of region IDs to display as passable
|
||
* (Range can be specified)
|
||
* @default
|
||
*
|
||
* @param Icon Image
|
||
* @desc
|
||
* @type file
|
||
* @require 1
|
||
* @dir img/pictures
|
||
* @default
|
||
*
|
||
* @param Marker Size
|
||
* @desc Point type and arrow type sizes
|
||
* @type number
|
||
* @min 1
|
||
* @max 999
|
||
* @default 4
|
||
*
|
||
* @param Player Marker
|
||
* @desc Type: P,A,I,C0- / Color number / Option: B,T,H,M
|
||
* Can be used in both uppercase and lowercase
|
||
* @default A3h
|
||
*
|
||
* @param Vehicle Markers
|
||
* @desc Vehicle markers when not boarding
|
||
* @type struct<Vehicle>
|
||
* @default {"boat":"P3","ship":"P3","airship":"P3"}
|
||
*
|
||
*
|
||
* @noteParam Minimap
|
||
* @noteRequire 1
|
||
* @noteDir img/system/
|
||
* @noteType file
|
||
* @noteData maps
|
||
*
|
||
*/
|
||
|
||
/*~struct~DisplayPositions:
|
||
* @param X
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999999
|
||
* @default 32
|
||
*
|
||
* @param Y
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999999
|
||
* @default 32
|
||
*
|
||
* @param Width
|
||
* @desc
|
||
* @type number
|
||
* @min 1
|
||
* @max 999999
|
||
* @default 160
|
||
*
|
||
* @param Height
|
||
* @desc
|
||
* @type number
|
||
* @min 1
|
||
* @max 999999
|
||
* @default 120
|
||
*
|
||
* @param Opacity
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 255
|
||
* @default 192
|
||
*
|
||
* @param Zoom
|
||
* @desc -1:The entire display,
|
||
* 0:Do not change the value of <MinimapZoom: n> in the map memo
|
||
* @type number
|
||
* @min -1
|
||
* @max 10000
|
||
* @default 150
|
||
*
|
||
* @param Frame Image
|
||
* @desc
|
||
* @type file
|
||
* @require 1
|
||
* @dir img/pictures
|
||
* @default
|
||
*
|
||
*/
|
||
|
||
/*~struct~Vehicle:
|
||
* @param boat
|
||
* @desc Type: P,A,I,C0- / Color number / Option: B,T,H,M
|
||
* Can be used in both uppercase and lowercase
|
||
* @default P3
|
||
*
|
||
* @param ship
|
||
* @desc Type: P,A,I,C0- / Color number / Option: B,T,H,M
|
||
* Can be used in both uppercase and lowercase
|
||
* @default P3
|
||
*
|
||
* @param airship
|
||
* @desc Type: P,A,I,C0- / Color number / Option: B,T,H,M
|
||
* Can be used in both uppercase and lowercase
|
||
* @default P3
|
||
*
|
||
*/
|
||
|
||
/*:ja
|
||
* @target MV MZ
|
||
* @plugindesc ミニマップを画面に表示させます。
|
||
* @author 木星ペンギン
|
||
* @url
|
||
*
|
||
* @help [version 4.3.1]
|
||
* このプラグインはRPGツクールMVおよびMZ用です。
|
||
*
|
||
* ▼ プラグインコマンド
|
||
* - MVでは数値を入力する項目で v[N] と記述することで変数N番を参照します。
|
||
* - MZでは数値を入力する項目で、テキストを選択して v[N] と記述することで
|
||
* 変数N番を参照します。
|
||
*
|
||
* 〇 MV / MZ
|
||
*
|
||
* 〇 ShowMinimap index / ミニマップ表示
|
||
* index : 番号(0:非表示)
|
||
* - ミニマップを表示します。
|
||
* - 表示位置やサイズはプラグインパラメータ[Display Positions]で設定したものが
|
||
* 適用されます。
|
||
*
|
||
* 〇 SetMinimapZoom zoom / ミニマップ拡大率設定
|
||
* zoom : 拡大率(-1:全体, 0:デフォルト / 100で等倍)
|
||
* - ミニマップ表示の拡大率のみを変更します。
|
||
*
|
||
* 〇 AddMarker x y m tag / マーカー追加
|
||
* x : X座標
|
||
* y : Y座標
|
||
* m : マーカー文字列
|
||
* tag : タグ(任意の値 / 未設定:0)
|
||
* - 現在のマップの座標(x,y)にマーカーを設置します。
|
||
* - タグは削除する際に使用します。
|
||
*
|
||
* 〇 RemoveMarker tag / マーカー削除
|
||
* tag : タグ
|
||
* - 指定したタグのマーカーをすべて削除します。
|
||
*
|
||
* 〇 RemoveMarkerPos x y / 座標マーカー削除
|
||
* x : X座標
|
||
* y : Y座標
|
||
* - 現在のマップの座標(x,y)にあるマーカーを削除します。
|
||
*
|
||
* ▼ マップのメモ
|
||
* 〇 <Minimap:name>
|
||
* - このマップのミニマップ画像のファイル名を指定します。
|
||
* - 画像ファイルは img/pictures に入れてください。
|
||
*
|
||
* 〇 <MinimapZoom:n>
|
||
* - このマップのミニマップ拡大率の初期値を設定します。
|
||
* - v[N] と記述することで変数N番を参照します。
|
||
*
|
||
* ▼ イベントのメモ
|
||
* 〇 <Marker:m>
|
||
* - このイベントのマーカーを設定します。
|
||
*
|
||
* ▼ イベントの実行内容の注釈
|
||
* 〇 マーカー m
|
||
* - そのEVページが表示されている際のイベントのマーカーを設定します。
|
||
* - <Marker:m>を設定している場合、こちらが優先されます。
|
||
*
|
||
* ▼ マーカーの指定
|
||
* - マーカーは文字列と数字の組み合わせで指定します。
|
||
* TCO
|
||
* T = <タイプ>
|
||
* C = <色番号>
|
||
* O = <オプション>
|
||
* - <タイプ>は以下の8種類があります。
|
||
* P : 点タイプ (●)
|
||
* A : 矢印タイプ / キャラの向きに合わせて方向が変わる
|
||
* I : アイコンタイプ / アイコン画像はプラグインパラメータで設定
|
||
* T : 三角タイプ(▲)
|
||
* S : 四角タイプ(■)
|
||
* R : ひし形タイプ(◆)
|
||
* X : バツ印タイプ(×)
|
||
* C0- : 円形タイプ / Cの後に半径を指定しハイフン(-)を入れる
|
||
* - <色番号>は[文章の表示]の文字色と同じです。
|
||
* - 具体的な色は img/system/Window.png を参照してください。
|
||
* - <オプション>は以下の機能が欲しい時に付けてください。
|
||
* B : 点滅フラグ
|
||
* T : キャラの向きに合わせて方向が変わる / アイコンタイプのみ
|
||
* H : 他のマーカーより手前に表示 / ミニマップ外でも常時表示
|
||
* M : MPP_MiniMap_Op1.js用 / マッピングした範囲でのみ表示
|
||
* - <オプション>は複数設定可能です。
|
||
* - 文字列は全て、大文字小文字どちらでも機能します。
|
||
*
|
||
* ▼ プラグインパラメータ 詳細
|
||
* 〇 マップIDの配列 / 通行不可リージョン / 通行可能リージョン
|
||
* - これらのプラグインパラメータでは範囲指定が使用できます。
|
||
* - n-m と表記することで、nからmまでの数値を指定できます。
|
||
* 例: 1-4,8,10 => 1から4と8と10
|
||
*
|
||
* 〇 アイコン画像
|
||
* - アイコン画像は横方向に8個並べたものを1ブロックとし、そのブロックを
|
||
* 必要なだけ縦に長くしたものです。
|
||
* - 画像の幅を8で割ったものが、アイコンの幅と高さになります。
|
||
*
|
||
* ================================
|
||
* Mail : wood_penguin＠yahoo.co.jp (＠は半角)
|
||
* Blog : http://woodpenguin.blog.fc2.com/
|
||
* License : MIT license
|
||
*
|
||
* @command show
|
||
* @text ミニマップ表示
|
||
* @desc
|
||
* @arg index
|
||
* @text 番号
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
*
|
||
* @command setZoom
|
||
* @text ミニマップ拡大率設定
|
||
* @desc
|
||
* @arg zoom
|
||
* @text 拡大率
|
||
* @desc 100:等倍
|
||
* @type number
|
||
* @min -1
|
||
* @max 10000
|
||
* @default 100
|
||
*
|
||
* @command addMarker
|
||
* @text マーカー追加
|
||
* @desc
|
||
* @arg x
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
* @arg y
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
* @arg marker
|
||
* @text マーカー
|
||
* @desc Type: P,A,I,C0- / 色番号 / Option: B,T,H,M
|
||
* 大文字小文字どちらでも使用可能
|
||
* @type string
|
||
* @default P0
|
||
* @arg tag
|
||
* @text タグ
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 9999
|
||
* @default 0
|
||
*
|
||
* @command removeMarker
|
||
* @text マーカー削除
|
||
* @desc
|
||
* @arg tag
|
||
* @text タグ
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 9999
|
||
* @default 0
|
||
*
|
||
* @command removeMarkerXy
|
||
* @text 座標マーカー削除
|
||
* @desc
|
||
* @arg x
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
* @arg y
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999
|
||
* @default 0
|
||
*
|
||
*
|
||
* @param Map Ids
|
||
* @text マップIDの配列
|
||
* @desc ミニマップを表示するマップIDの配列
|
||
* (範囲指定可)
|
||
* @default 1-5
|
||
*
|
||
* @param Display Positions
|
||
* @text 表示位置の配列
|
||
* @desc
|
||
* @type struct<DisplayPositions>[]
|
||
* @default ["{\"X\":\"32\",\"Y\":\"32\",\"Width\":\"160\",\"Height\":\"120\",\"Opacity\":\"192\",\"Zoom\":\"150\",\"Frame Image\":\"\"}"]
|
||
*
|
||
* @param Blink Duration
|
||
* @text 点滅時間
|
||
* @desc
|
||
* @type number
|
||
* @min 1
|
||
* @max 999
|
||
* @default 80
|
||
*
|
||
* @param Blur Level
|
||
* @text ブラー強さ
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 10
|
||
* @default 4
|
||
*
|
||
* @param Wall Region IDs
|
||
* @text 通行不可リージョン
|
||
* @desc 通行不可として表示するリージョンIDの配列
|
||
* (範囲指定可)
|
||
* @default 63
|
||
*
|
||
* @param Floor Region IDs
|
||
* @text 通行可能リージョン
|
||
* @desc 通行可能として表示するリージョンIDの配列
|
||
* (範囲指定可)
|
||
* @default
|
||
*
|
||
* @param Icon Image
|
||
* @text アイコン画像
|
||
* @desc
|
||
* @type file
|
||
* @require 1
|
||
* @dir img/pictures
|
||
* @default
|
||
*
|
||
* @param Marker Size
|
||
* @text マーカーサイズ
|
||
* @desc 点タイプと矢印タイプのサイズ
|
||
* @type number
|
||
* @min 1
|
||
* @max 999
|
||
* @default 4
|
||
*
|
||
* @param Player Marker
|
||
* @text プレイヤーマーカー
|
||
* @desc Type: P,A,I,C0- / 色番号 / Option: B,T,H,M
|
||
* 大文字小文字どちらでも使用可能
|
||
* @default A3h
|
||
*
|
||
* @param Vehicle Markers
|
||
* @text 乗り物マーカー
|
||
* @desc 非搭乗時の乗り物のマーカー
|
||
* @type struct<Vehicle>
|
||
* @default {"boat":"P3","ship":"P3","airship":"P3"}
|
||
*
|
||
*
|
||
* @noteParam Minimap
|
||
* @noteRequire 1
|
||
* @noteDir img/system/
|
||
* @noteType file
|
||
* @noteData maps
|
||
*
|
||
*/
|
||
|
||
/*~struct~DisplayPositions:ja
|
||
* @param X
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999999
|
||
* @default 32
|
||
*
|
||
* @param Y
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 999999
|
||
* @default 32
|
||
*
|
||
* @param Width
|
||
* @text 幅
|
||
* @desc
|
||
* @type number
|
||
* @min 1
|
||
* @max 999999
|
||
* @default 160
|
||
*
|
||
* @param Height
|
||
* @text 高さ
|
||
* @desc
|
||
* @type number
|
||
* @min 1
|
||
* @max 999999
|
||
* @default 120
|
||
*
|
||
* @param Opacity
|
||
* @text 不透明度
|
||
* @desc
|
||
* @type number
|
||
* @min 0
|
||
* @max 255
|
||
* @default 192
|
||
*
|
||
* @param Zoom
|
||
* @text 拡大率
|
||
* @desc -1:全体表示,
|
||
* 0:マップメモの<MinimapZoom:n>の値、または変更しない
|
||
* @type number
|
||
* @min -1
|
||
* @max 10000
|
||
* @default 150
|
||
*
|
||
* @param Frame Image
|
||
* @text フレーム画像
|
||
* @desc
|
||
* @type file
|
||
* @require 1
|
||
* @dir img/pictures
|
||
* @default
|
||
*
|
||
*/
|
||
|
||
/*~struct~Vehicle:ja
|
||
* @param boat
|
||
* @text 小型船
|
||
* @desc Type: P,A,I,C0- / 色番号 / Option: B,T,H,M
|
||
* 大文字小文字どちらでも使用可能
|
||
* @default P3
|
||
*
|
||
* @param ship
|
||
* @text 大型船
|
||
* @desc Type: P,A,I,C0- / 色番号 / Option: B,T,H,M
|
||
* 大文字小文字どちらでも使用可能
|
||
* @default P3
|
||
*
|
||
* @param airship
|
||
* @text 飛行船
|
||
* @desc Type: P,A,I,C0- / 色番号 / Option: B,T,H,M
|
||
* 大文字小文字どちらでも使用可能
|
||
* @default P3
|
||
*
|
||
*/
|
||
|
||
(() => {
|
||
"use strict";
|
||
|
||
const pluginName = "MPP_MiniMap";
|
||
|
||
// Plugin Parameters
|
||
const parameters = PluginManager.parameters(pluginName);
|
||
const reviverParse = function (key, value) {
|
||
try {
|
||
return JSON.parse(value, reviverParse);
|
||
} catch (e) {
|
||
return value;
|
||
}
|
||
};
|
||
const range = function* (start, end) {
|
||
for (let i = start; i < end; i++) {
|
||
yield i;
|
||
}
|
||
};
|
||
const convertToArray = (param) => {
|
||
return param.split(",").reduce((r, item) => {
|
||
if (item) {
|
||
const match = /(\d+)-(\d+)/.exec(item);
|
||
if (match) {
|
||
r.push(...range(+match[1], +match[2] + 1));
|
||
} else {
|
||
r.push(+item);
|
||
}
|
||
}
|
||
return r;
|
||
}, []);
|
||
};
|
||
const param_MapIds = convertToArray(parameters["Map Ids"]);
|
||
const param_DisplayPositions = JSON.parse(
|
||
parameters["Display Positions"] || "[]",
|
||
reviverParse
|
||
);
|
||
const param_BlinkDuration = Number(parameters["Blink Duration"] || 80);
|
||
const param_BlurLevel = Number(parameters["Blur Level"]);
|
||
const param_WallRegionIDs = convertToArray(parameters["Wall Region IDs"]);
|
||
const param_FloorRegionIDs = convertToArray(parameters["Floor Region IDs"]);
|
||
const param_IconImage = parameters["Icon Image"];
|
||
const param_MarkerSize = Number(parameters["Marker Size"] || 4);
|
||
const param_PlayerMarker = parameters["Player Marker"];
|
||
const param_VehicleMarkers = JSON.parse(
|
||
parameters["Vehicle Markers"] || "{}"
|
||
);
|
||
|
||
// Dealing with other plugins
|
||
const _importedPlugin = (...names) => {
|
||
return names.some((name) => PluginManager._scripts.includes(name));
|
||
};
|
||
const _pluginOptions = [
|
||
"MPP_MiniMap_Op1",
|
||
"MPP_MiniMap_Op2",
|
||
"MPP_MiniMap_Op3",
|
||
];
|
||
|
||
// JsExtensions alternative
|
||
const MathExt = (() => {
|
||
// Number.prototype.clamp と違い、下限優先
|
||
const clamp = (x, min, max) => Math.max(Math.min(x, max), min);
|
||
const mod = (x, n) => ((x % n) + n) % n;
|
||
return { clamp, mod };
|
||
})();
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Bitmap
|
||
|
||
if (Utils.RPGMAKER_NAME === "MV") {
|
||
Bitmap.prototype.destroy = function () {
|
||
if (this._baseTexture) {
|
||
this._baseTexture.destroy();
|
||
this.__baseTexture = null;
|
||
}
|
||
this._destroyCanvas();
|
||
};
|
||
|
||
Bitmap.prototype._destroyCanvas = function () {
|
||
if (this._canvas) {
|
||
this._canvas.width = 0;
|
||
this._canvas.height = 0;
|
||
this.__canvas = null;
|
||
}
|
||
};
|
||
}
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Sprite
|
||
|
||
if (!Sprite.prototype._onBitmapChange) {
|
||
Sprite.prototype._onBitmapChange = function () {
|
||
if (this._bitmap) {
|
||
this._refreshFrame = true;
|
||
this._bitmap.addLoadListener(this._onBitmapLoad.bind(this));
|
||
} else {
|
||
this._refreshFrame = false;
|
||
this.texture.frame = Rectangle.emptyRectangle;
|
||
}
|
||
};
|
||
}
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_MinimapMarker
|
||
|
||
function Game_MinimapMarker() {
|
||
this.initialize.apply(this, arguments);
|
||
}
|
||
|
||
window.Game_MinimapMarker = Game_MinimapMarker;
|
||
|
||
Game_MinimapMarker._markerReg = /^(P|A|I|T|S|R|X|C(\d+)-|\!)(\d+)([BTHM]*)$/i;
|
||
|
||
Game_MinimapMarker.checkMarker = function (markerStr) {
|
||
if (markerStr) {
|
||
if (this._markerReg.test(markerStr)) {
|
||
return true;
|
||
} else {
|
||
const errorText = $gameSystem.isJapanese()
|
||
? "マーカーエラー"
|
||
: "Marker Error";
|
||
console.log(errorText + " : " + markerStr);
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
|
||
Object.defineProperties(Game_MinimapMarker.prototype, {
|
||
realX: {
|
||
get() {
|
||
const subject = this.subject();
|
||
return subject ? subject._realX : this._x;
|
||
},
|
||
configurable: true,
|
||
},
|
||
realY: {
|
||
get() {
|
||
const subject = this.subject();
|
||
return subject ? subject._realY : this._y;
|
||
},
|
||
configurable: true,
|
||
},
|
||
});
|
||
|
||
Game_MinimapMarker.prototype.initialize = function () {
|
||
this._tag = null;
|
||
this.clearPos();
|
||
this.clearMarker();
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.clearPos = function () {
|
||
this._mapId = 0;
|
||
this._x = NaN;
|
||
this._y = NaN;
|
||
this._eventId = 0;
|
||
this._vehicleType = null;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.clearMarker = function () {
|
||
this._type = null;
|
||
this._radius = 0;
|
||
this._index = 0;
|
||
this._blink = false;
|
||
this._turn = false;
|
||
this._highlighted = false;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setMarker = function (markerStr) {
|
||
const match = Game_MinimapMarker._markerReg.exec(markerStr);
|
||
if (match) {
|
||
this._type = match[1].charAt().toUpperCase();
|
||
this._radius = +match[2];
|
||
this._index = +match[3];
|
||
this.setMarkerFlag((match[4] || "").toUpperCase());
|
||
}
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setMarkerFlag = function (flag) {
|
||
this._blink = flag.includes("B");
|
||
this._turn = this._type === "A" || flag.includes("T");
|
||
this._highlighted = this._type !== "C" && flag.includes("H");
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setTag = function (tag) {
|
||
this._tag = tag;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.tag = function () {
|
||
return this._tag;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.type = function () {
|
||
return this._type;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.radius = function () {
|
||
return this._radius;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.iconIndex = function () {
|
||
return this._index;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.color = function () {
|
||
if (Utils.RPGMAKER_NAME === "MV") {
|
||
const windowskin = ImageManager.loadSystem("Window");
|
||
const n = this._index;
|
||
const px = 96 + (n % 8) * 12 + 6;
|
||
const py = 144 + Math.floor(n / 8) * 12 + 6;
|
||
return windowskin.getPixel(px, py);
|
||
} else {
|
||
return ColorManager.textColor(this._index);
|
||
}
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isBlink = function () {
|
||
return this._blink;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.angle = function () {
|
||
const subject = this.subject();
|
||
if (subject && this._turn) {
|
||
switch (subject.direction()) {
|
||
case 2:
|
||
return 0;
|
||
case 4:
|
||
return 90;
|
||
case 6:
|
||
return 270;
|
||
case 8:
|
||
return 180;
|
||
}
|
||
}
|
||
return 0;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isHighlighted = function () {
|
||
return this._highlighted;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setSubject = function (subject) {
|
||
this.clearPos();
|
||
if (subject) {
|
||
if (subject === $gamePlayer) {
|
||
this._eventId = -1;
|
||
} else if (subject === $gameMap.airship()) {
|
||
this._vehicleType = "airship";
|
||
} else if (subject === $gameMap.ship()) {
|
||
this._vehicleType = "ship";
|
||
} else if (subject === $gameMap.boat()) {
|
||
this._vehicleType = "boat";
|
||
} else {
|
||
this._mapId = $gameMap.mapId();
|
||
this._eventId = subject.eventId();
|
||
}
|
||
}
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setPlayer = function () {
|
||
this.clearPos();
|
||
this._eventId = -1;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setEventId = function (eventId) {
|
||
this.clearPos();
|
||
this._mapId = $gameMap.mapId();
|
||
this._eventId = eventId;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setVehicleType = function (vehicleType) {
|
||
this.clearPos();
|
||
this._vehicleType = vehicleType;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.subject = function () {
|
||
if (this._eventId < 0) {
|
||
return $gamePlayer;
|
||
}
|
||
if (this._vehicleType) {
|
||
return $gameMap.vehicle(this._vehicleType);
|
||
} else {
|
||
return this._mapId === $gameMap.mapId()
|
||
? $gameMap.event(this._eventId)
|
||
: null;
|
||
}
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isSubject = function () {
|
||
return this.isPlayer() || this.isVehicle() || this.isEvent();
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isPlayer = function () {
|
||
return this._eventId < 0;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isVehicle = function () {
|
||
return !!this._vehicleType;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isEvent = function () {
|
||
return this._eventId > 0 && this._mapId === $gameMap.mapId();
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isCoordinate = function () {
|
||
return !isNaN(this._x);
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.setPosition = function (x, y) {
|
||
this.clearPos();
|
||
this._mapId = $gameMap.mapId();
|
||
this._x = x;
|
||
this._y = y;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.pos = function (mapId, x, y) {
|
||
return this._mapId === mapId && this._x === x && this._y === y;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isValid = function () {
|
||
return !!this._type;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.isVisible = function () {
|
||
if (!this.isValid()) {
|
||
return false;
|
||
}
|
||
const subject = this.subject();
|
||
return subject
|
||
? subject.isMinimapMarkerVisible()
|
||
: this._mapId === $gameMap.mapId();
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.minimapX = function () {
|
||
return $gameMap.minimap.adjustX(this.realX) + 0.5;
|
||
};
|
||
|
||
Game_MinimapMarker.prototype.minimapY = function () {
|
||
return $gameMap.minimap.adjustY(this.realY) + 0.5;
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Minimap
|
||
|
||
function Game_Minimap() {
|
||
this.initialize.apply(this, arguments);
|
||
}
|
||
|
||
window.Game_Minimap = Game_Minimap;
|
||
|
||
Game_Minimap.prototype.initialize = function () {
|
||
this._paramsIndex = 0;
|
||
this._zoom = 100;
|
||
this._targetZoom = 100;
|
||
this._zoomDuration = 0;
|
||
this._markers = [];
|
||
this.clearDisplayRect();
|
||
};
|
||
|
||
Game_Minimap.prototype.clearDisplayRect = function () {
|
||
this._displayRect = new Rectangle();
|
||
};
|
||
|
||
Game_Minimap.prototype.setup = function () {
|
||
this.clearDisplayRect();
|
||
this.setupZoom();
|
||
};
|
||
|
||
Game_Minimap.prototype.setupZoom = function () {
|
||
this._zoom = this.metadataZoom() || this.paramsZoom() || this._targetZoom;
|
||
this._targetZoom = this._zoom;
|
||
this._zoomDuration = 0;
|
||
};
|
||
|
||
Game_Minimap.prototype.params = function () {
|
||
return this._paramsIndex > 0
|
||
? param_DisplayPositions[this._paramsIndex - 1]
|
||
: null;
|
||
};
|
||
|
||
Game_Minimap.prototype.metadataZoom = function () {
|
||
const zoom = $dataMap.meta ? $dataMap.meta.MinimapZoom : null;
|
||
return zoom ? Math.max(PluginManager.mppValue(zoom), 0) : 0;
|
||
};
|
||
|
||
Game_Minimap.prototype.paramsZoom = function () {
|
||
const params = this.params();
|
||
return params ? params.Zoom || 0 : 0;
|
||
};
|
||
|
||
Game_Minimap.prototype.setPosition = function (index) {
|
||
if (this._paramsIndex !== index) {
|
||
this._paramsIndex = index;
|
||
this.zoomTo(0);
|
||
}
|
||
};
|
||
|
||
Game_Minimap.prototype.correctionX = function () {
|
||
const sx = ($gameMap.width() - this._displayRect.width) / 2;
|
||
return sx < 0 ? -sx * this.xRate() : 0;
|
||
};
|
||
|
||
Game_Minimap.prototype.correctionY = function () {
|
||
const sy = ($gameMap.height() - this._displayRect.height) / 2;
|
||
return sy < 0 ? -sy * this.yRate() : 0;
|
||
};
|
||
|
||
Game_Minimap.prototype.zoom = function () {
|
||
return this._zoom;
|
||
};
|
||
|
||
Game_Minimap.prototype.displayRect = function () {
|
||
return this._displayRect;
|
||
};
|
||
|
||
Game_Minimap.prototype.markers = function () {
|
||
return this._markers;
|
||
};
|
||
|
||
Game_Minimap.prototype.xRate = function () {
|
||
return (MinimapImage.tileWidth() * this._zoom) / 100;
|
||
};
|
||
|
||
Game_Minimap.prototype.yRate = function () {
|
||
return (MinimapImage.tileHeight() * this._zoom) / 100;
|
||
};
|
||
|
||
Game_Minimap.prototype.isZoomBottom = function () {
|
||
return this._targetZoom === MinimapImage.minZoom();
|
||
};
|
||
|
||
Game_Minimap.prototype.isLoopHorizontal = function () {
|
||
return $gameMap.isLoopHorizontal() && !this.isZoomBottom();
|
||
};
|
||
|
||
Game_Minimap.prototype.isLoopVertical = function () {
|
||
return $gameMap.isLoopVertical() && !this.isZoomBottom();
|
||
};
|
||
|
||
Game_Minimap.prototype.zoomTo = function (zoom) {
|
||
this._zoom =
|
||
zoom || this.metadataZoom() || this.paramsZoom() || this._targetZoom;
|
||
this._targetZoom = this._zoom;
|
||
this.refreshZoom();
|
||
this.updateScroll();
|
||
};
|
||
|
||
Game_Minimap.prototype.smoothZoomTo = function (zoom) {
|
||
this._targetZoom =
|
||
zoom || this.metadataZoom() || this.paramsZoom() || this._targetZoom;
|
||
this.refreshZoom();
|
||
this._zoomDuration = 24;
|
||
};
|
||
|
||
Game_Minimap.prototype.refreshZoom = function () {
|
||
const minZoom = MinimapImage.minZoom();
|
||
this._zoom = Math.max(this._zoom, minZoom);
|
||
this._targetZoom = Math.max(this._targetZoom, minZoom);
|
||
};
|
||
|
||
Game_Minimap.prototype.adjustX = function (x) {
|
||
const { x: dx, width: dw } = this._displayRect;
|
||
if (this.isLoopHorizontal() && x < dx - ($gameMap.width() - dw) / 2) {
|
||
return x - dx + $gameMap.width();
|
||
} else {
|
||
return x - dx;
|
||
}
|
||
};
|
||
|
||
Game_Minimap.prototype.adjustY = function (y) {
|
||
const { y: dy, height: dh } = this._displayRect;
|
||
if (this.isLoopVertical() && y < dy - ($gameMap.height() - dh) / 2) {
|
||
return y - dy + $gameMap.height();
|
||
} else {
|
||
return y - dy;
|
||
}
|
||
};
|
||
|
||
Game_Minimap.prototype.addMarker = function (x, y, markerStr, tag) {
|
||
if (Game_MinimapMarker.checkMarker(markerStr)) {
|
||
const marker = new Game_MinimapMarker();
|
||
marker.setMarker(markerStr);
|
||
marker.setPosition(x, y);
|
||
marker.setTag(tag);
|
||
this._markers.push(marker);
|
||
}
|
||
};
|
||
|
||
Game_Minimap.prototype.removeMarker = function (tag) {
|
||
this._markers = this._markers.filter((marker) => marker.tag() !== tag);
|
||
};
|
||
|
||
Game_Minimap.prototype.removeMarkerXy = function (x, y) {
|
||
const mapId = $gameMap.mapId();
|
||
this._markers = this._markers.filter((marker) => !marker.pos(mapId, x, y));
|
||
};
|
||
|
||
Game_Minimap.prototype.displayX = function (tileX) {
|
||
const x = this.centerX() - tileX / 2;
|
||
return this.isLoopHorizontal()
|
||
? MathExt.mod(x, $gameMap.width())
|
||
: MathExt.clamp(x, 0, $gameMap.width() - tileX);
|
||
};
|
||
|
||
Game_Minimap.prototype.centerX = function () {
|
||
return $gamePlayer._realX;
|
||
};
|
||
|
||
Game_Minimap.prototype.displayY = function (tileY) {
|
||
const y = this.centerY() - tileY / 2;
|
||
return this.isLoopVertical()
|
||
? MathExt.mod(y, $gameMap.height())
|
||
: MathExt.clamp(y, 0, $gameMap.height() - tileY);
|
||
};
|
||
|
||
Game_Minimap.prototype.centerY = function () {
|
||
return $gamePlayer._realY;
|
||
};
|
||
|
||
Game_Minimap.prototype.update = function () {
|
||
this.updateZoom();
|
||
this.updateScroll();
|
||
};
|
||
|
||
Game_Minimap.prototype.updateZoom = function () {
|
||
if (this._zoomDuration > 0) {
|
||
const d = this._zoomDuration--;
|
||
const sz = this._targetZoom - this._zoom;
|
||
this._zoom += (sz * (d ** 2 - (d - 1) ** 2)) / d ** 2;
|
||
}
|
||
};
|
||
|
||
Game_Minimap.prototype.updateScroll = function () {
|
||
const rect = this._displayRect;
|
||
const params = this.params();
|
||
if (params) {
|
||
rect.width = params.Width / this.xRate();
|
||
rect.height = params.Height / this.yRate();
|
||
}
|
||
rect.x = this.displayX(rect.width);
|
||
rect.y = this.displayY(rect.height);
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Map
|
||
|
||
Object.defineProperty(Game_Map.prototype, "minimap", {
|
||
get() {
|
||
return this._minimap;
|
||
},
|
||
configurable: true,
|
||
});
|
||
|
||
const _Game_Map_initialize = Game_Map.prototype.initialize;
|
||
Game_Map.prototype.initialize = function () {
|
||
_Game_Map_initialize.apply(this, arguments);
|
||
this._minimap = new Game_Minimap();
|
||
};
|
||
|
||
const _Game_Map_setup = Game_Map.prototype.setup;
|
||
Game_Map.prototype.setup = function (mapId) {
|
||
_Game_Map_setup.apply(this, arguments);
|
||
this._minimap.setup();
|
||
};
|
||
|
||
Game_Map.prototype.isShowMinimap = function (mapId) {
|
||
mapId = mapId || this._mapId;
|
||
return param_MapIds.includes(mapId);
|
||
};
|
||
|
||
Game_Map.prototype.minimapImageName = function () {
|
||
return $dataMap.meta.Minimap || "";
|
||
};
|
||
|
||
Game_Map.prototype.allMinimapMarkers = function () {
|
||
return [
|
||
...this.events().map((event) => event.minimapMarker()),
|
||
...this._minimap.markers(),
|
||
...this.vehicles().map((vehicle) => vehicle.minimapMarker()),
|
||
$gamePlayer.minimapMarker(),
|
||
].filter(Boolean);
|
||
};
|
||
|
||
const _Game_Map_update = Game_Map.prototype.update;
|
||
Game_Map.prototype.update = function (sceneActive) {
|
||
_Game_Map_update.apply(this, arguments);
|
||
this._minimap.update();
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Character
|
||
|
||
Game_Character.prototype.setupMinimapMarker = function () {
|
||
const markerStr = this.getMinimapMarkerStr();
|
||
if (Game_MinimapMarker.checkMarker(markerStr)) {
|
||
this._minimapMarker = new Game_MinimapMarker();
|
||
this._minimapMarker.setMarker(markerStr);
|
||
this.setupMinimapMarkerSubject();
|
||
} else {
|
||
this._minimapMarker = null;
|
||
}
|
||
};
|
||
|
||
Game_Character.prototype.getMinimapMarkerStr = function () {
|
||
return "";
|
||
};
|
||
|
||
Game_Character.prototype.setupMinimapMarkerSubject = function () {};
|
||
|
||
Game_Character.prototype.minimapMarker = function () {
|
||
return this._minimapMarker;
|
||
};
|
||
|
||
Game_Character.prototype.isMinimapMarkerVisible = function () {
|
||
return !this.isTransparent();
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Player
|
||
|
||
const _Game_Player_initialize = Game_Player.prototype.initialize;
|
||
Game_Player.prototype.initialize = function () {
|
||
_Game_Player_initialize.apply(this, arguments);
|
||
this.setupMinimapMarker();
|
||
};
|
||
|
||
Game_Player.prototype.setupMinimapMarkerSubject = function () {
|
||
this._minimapMarker.setPlayer();
|
||
};
|
||
|
||
Game_Player.prototype.getMinimapMarkerStr = function () {
|
||
return param_PlayerMarker;
|
||
};
|
||
|
||
Game_Player.prototype.isMinimapMarkerVisible = function () {
|
||
return (
|
||
this._vehicleType !== "walk" ||
|
||
Game_Character.prototype.isMinimapMarkerVisible.call(this)
|
||
);
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Vehicle
|
||
|
||
const _Game_Vehicle_initialize = Game_Vehicle.prototype.initialize;
|
||
Game_Vehicle.prototype.initialize = function (type) {
|
||
_Game_Vehicle_initialize.apply(this, arguments);
|
||
this.setupMinimapMarker();
|
||
};
|
||
|
||
Game_Vehicle.prototype.setupMinimapMarkerSubject = function () {
|
||
this._minimapMarker.setVehicleType(this._type);
|
||
};
|
||
|
||
Game_Vehicle.prototype.getMinimapMarkerStr = function () {
|
||
return param_VehicleMarkers[this._type];
|
||
};
|
||
|
||
Game_Vehicle.prototype.isMinimapMarkerVisible = function () {
|
||
return (
|
||
!this._driving &&
|
||
Game_Character.prototype.isMinimapMarkerVisible.call(this)
|
||
);
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Event
|
||
|
||
Game_Event.prototype.setupMinimapMarkerSubject = function () {
|
||
this._minimapMarker.setEventId(this._eventId);
|
||
};
|
||
|
||
const _Game_Event_setupPage = Game_Event.prototype.setupPage;
|
||
Game_Event.prototype.setupPage = function () {
|
||
_Game_Event_setupPage.apply(this, arguments);
|
||
this.setupMinimapMarker();
|
||
};
|
||
|
||
Game_Event.prototype.getMinimapMarkerStr = function () {
|
||
if (this._pageIndex >= 0) {
|
||
return this.getCommentMinimapMarkerStr() || this.event().meta.Marker;
|
||
}
|
||
return "";
|
||
};
|
||
|
||
Game_Event.prototype.getCommentMinimapMarkerStr = function () {
|
||
const commandNames = ["MinimapMarker", "マーカー"];
|
||
for (const comment of this.generatorCommentCommand(commandNames)) {
|
||
const [_, markerStr] = comment.split(" ");
|
||
return markerStr;
|
||
}
|
||
return null;
|
||
};
|
||
|
||
Game_Event.prototype.generatorCommentCommand = function* (commandNames) {
|
||
for (const evCom of this.list()) {
|
||
switch (evCom.code) {
|
||
case 108:
|
||
case 408:
|
||
const comment = evCom.parameters[0];
|
||
if (commandNames.some((name) => comment.startsWith(name))) {
|
||
yield comment;
|
||
}
|
||
break;
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Game_Interpreter
|
||
|
||
const _mzCommands = {
|
||
ShowMinimap: { name: "show", keys: ["index"] },
|
||
SetMinimapZoom: { name: "setZoom", keys: ["zoom"] },
|
||
AddMarker: { name: "addMarker", keys: ["x", "y", "marker", "tag"] },
|
||
RemoveMarker: { name: "removeMarker", keys: ["tag"] },
|
||
RemoveMarkerXy: { name: "removeMarkerXy", keys: ["x", "y"] },
|
||
};
|
||
Object.assign(_mzCommands, {
|
||
ミニマップ表示: _mzCommands.ShowMinimap,
|
||
ミニマップ拡大率設定: _mzCommands.SetMinimapZoom,
|
||
マーカー追加: _mzCommands.AddMarker,
|
||
マーカー削除: _mzCommands.RemoveMarker,
|
||
座標マーカー削除: _mzCommands.RemoveMarkerXy,
|
||
});
|
||
|
||
const _Game_Interpreter_pluginCommand =
|
||
Game_Interpreter.prototype.pluginCommand;
|
||
Game_Interpreter.prototype.pluginCommand = function (command, args) {
|
||
_Game_Interpreter_pluginCommand.apply(this, arguments);
|
||
const mzCommand = _mzCommands[command];
|
||
if (mzCommand) {
|
||
const args2 = Object.assign(
|
||
{},
|
||
...mzCommand.keys.map((k, i) => ({ [k]: args[i] }))
|
||
);
|
||
PluginManager.callCommandMV(this, pluginName, mzCommand.name, args2);
|
||
}
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// PluginManager
|
||
|
||
if (!PluginManager.registerCommand && !PluginManager._commandsMV) {
|
||
PluginManager._commandsMV = {};
|
||
|
||
PluginManager.registerCommandMV = function (pluginName, commandName, func) {
|
||
const key = pluginName + ":" + commandName;
|
||
this._commandsMV[key] = func;
|
||
};
|
||
|
||
PluginManager.callCommandMV = function (
|
||
self,
|
||
pluginName,
|
||
commandName,
|
||
args
|
||
) {
|
||
const key = pluginName + ":" + commandName;
|
||
const func = this._commandsMV[key];
|
||
if (typeof func === "function") {
|
||
func.bind(self)(args);
|
||
}
|
||
};
|
||
}
|
||
|
||
const _registerCommandName = PluginManager.registerCommand
|
||
? "registerCommand"
|
||
: "registerCommandMV";
|
||
|
||
PluginManager[_registerCommandName](pluginName, "show", (args) => {
|
||
const index = PluginManager.mppValue(args.index);
|
||
$gameMap.minimap.setPosition(index);
|
||
});
|
||
|
||
PluginManager[_registerCommandName](pluginName, "setZoom", (args) => {
|
||
const zoom = PluginManager.mppValue(args.zoom);
|
||
$gameMap.minimap.smoothZoomTo(zoom);
|
||
});
|
||
|
||
PluginManager[_registerCommandName](pluginName, "addMarker", (args) => {
|
||
const x = PluginManager.mppValue(args.x);
|
||
const y = PluginManager.mppValue(args.y);
|
||
const tag = PluginManager.mppValue(args.tag || "0");
|
||
$gameMap.minimap.addMarker(x, y, args.marker, tag);
|
||
});
|
||
|
||
PluginManager[_registerCommandName](pluginName, "removeMarker", (args) => {
|
||
const tag = PluginManager.mppValue(args.tag);
|
||
$gameMap.minimap.removeMarker(tag);
|
||
});
|
||
|
||
PluginManager[_registerCommandName](pluginName, "removeMarkerXy", (args) => {
|
||
const x = PluginManager.mppValue(args.x);
|
||
const y = PluginManager.mppValue(args.y);
|
||
$gameMap.minimap.removeMarkerXy(x, y);
|
||
});
|
||
|
||
PluginManager.mppValue = function (value) {
|
||
const match = /^V\[(\d+)\]$/i.exec(value);
|
||
return match ? $gameVariables.value(+match[1]) : +value;
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// MinimapImage
|
||
|
||
function MinimapImage() {
|
||
throw new Error("This is a static class");
|
||
}
|
||
|
||
if (_importedPlugin(..._pluginOptions)) {
|
||
window.MinimapImage = MinimapImage;
|
||
}
|
||
|
||
MinimapImage.bitmap = null;
|
||
MinimapImage._tileSize = 3;
|
||
MinimapImage.COLORS = {
|
||
Land: "rgba(255,255,255,1.0)",
|
||
Sea: "rgba(0,0,0,0.5)",
|
||
Ford: "rgba(64,64,64,0.75)",
|
||
Mountain: "rgba(128,128,128,1.0)",
|
||
Hill: "rgba(160,160,160,1.0)",
|
||
Forest: "rgba(192,192,192,1.0)",
|
||
River: "rgba(128,128,128,0.5)",
|
||
Shallow: "rgba(160,160,160,0.75)",
|
||
Ladder: "rgba(160,160,160,1.0)",
|
||
Bush: "rgba(192,192,192,1.0)",
|
||
Counter: "rgba(160,160,160,0.5)",
|
||
Wall: "rgba(64,64,64,0.25)",
|
||
Floor: "rgba(255,255,255,1.0)",
|
||
None: "rgba(0,0,0,0)",
|
||
};
|
||
|
||
MinimapImage.destroy = function () {
|
||
if (this.bitmap && !this._isUserImage) {
|
||
this.bitmap.destroy();
|
||
}
|
||
this.bitmap = null;
|
||
};
|
||
|
||
MinimapImage.isReady = function () {
|
||
return this.bitmap && this.bitmap.isReady();
|
||
};
|
||
|
||
MinimapImage.onLoad = function (imageName) {
|
||
this._isUserImage = !!imageName;
|
||
if (this._isUserImage) {
|
||
this.bitmap = ImageManager.loadPicture(imageName);
|
||
this.bitmap.addLoadListener(() => $gameMap.minimap.refreshZoom());
|
||
} else {
|
||
const width = $gameMap.width() * this._tileSize;
|
||
const height = $gameMap.height() * this._tileSize;
|
||
this.bitmap = new Bitmap(width, height);
|
||
}
|
||
};
|
||
|
||
MinimapImage.tileColors = function () {
|
||
return this.COLORS;
|
||
};
|
||
|
||
MinimapImage.isForcedWall = function (x, y) {
|
||
const regionId = $gameMap.regionId(x, y);
|
||
return param_WallRegionIDs.includes(regionId);
|
||
};
|
||
|
||
MinimapImage.isForcedFloor = function (x, y) {
|
||
const regionId = $gameMap.regionId(x, y);
|
||
return param_FloorRegionIDs.includes(regionId);
|
||
};
|
||
|
||
MinimapImage.tileWidth = function () {
|
||
return this.bitmap ? this.bitmap.width / $gameMap.width() || 1 : 1;
|
||
};
|
||
|
||
MinimapImage.tileHeight = function () {
|
||
return this.bitmap ? this.bitmap.height / $gameMap.height() || 1 : 1;
|
||
};
|
||
|
||
MinimapImage.minZoom = function () {
|
||
const params = $gameMap.minimap.params();
|
||
if (params && this.bitmap.isReady()) {
|
||
const minRate = Math.min(
|
||
params.Width / this.bitmap.width,
|
||
params.Height / this.bitmap.height
|
||
);
|
||
return Math.max(Math.floor(minRate * 100), 1);
|
||
}
|
||
return 1;
|
||
};
|
||
|
||
MinimapImage.refresh = function () {
|
||
if (this.bitmap && !this._isUserImage) {
|
||
this.bitmap.clear();
|
||
const width = $gameMap.width();
|
||
const height = $gameMap.height();
|
||
for (let x = 0; x < width; x++) {
|
||
for (let y = 0; y < height; y++) {
|
||
this.paintSpot(x, y);
|
||
}
|
||
}
|
||
this.bitmap.baseTexture.update();
|
||
}
|
||
};
|
||
|
||
MinimapImage.paintSpot = function (x, y) {
|
||
const size = this._tileSize;
|
||
const dx = x * size;
|
||
const dy = y * size;
|
||
if ($gameMap.isOverworld()) {
|
||
const color = this.getWorldSpotColor(x, y);
|
||
this.fillRect(dx, dy, size, size, color);
|
||
} else {
|
||
const flag = this.spotFlag(x, y);
|
||
const color = this.getAreaSpotColor(flag);
|
||
this.fillRect(dx, dy, size, size, color);
|
||
this.paintPassage(dx, dy, size, size, flag);
|
||
}
|
||
};
|
||
|
||
MinimapImage.getWorldSpotColor = function (x, y) {
|
||
const colors = this.tileColors();
|
||
const type = this.autotileType(x, y);
|
||
if (type === 1) {
|
||
return colors.Sea;
|
||
} else if (type >= 0 && type < 16) {
|
||
return colors.Ford;
|
||
} else if ([20, 21, 28, 36, 44].includes(type)) {
|
||
return colors.Forest;
|
||
} else if ([22, 30, 38, 46].includes(type)) {
|
||
return colors.Hill;
|
||
} else if ([23, 31, 39, 47].includes(type)) {
|
||
return colors.Mountain;
|
||
} else {
|
||
return colors.Land;
|
||
}
|
||
};
|
||
|
||
MinimapImage.autotileType = function (x, y) {
|
||
const flags = $gameMap.tilesetFlags();
|
||
const tiles = $gameMap.layeredTiles(x, y);
|
||
for (const tile of tiles) {
|
||
const flag = flags[tile];
|
||
if ((flag & 0x10) !== 0 || tile < 2048) {
|
||
continue;
|
||
}
|
||
return Math.floor((tile - 2048) / 48);
|
||
}
|
||
return -1;
|
||
};
|
||
|
||
MinimapImage.getAreaSpotColor = function (flag) {
|
||
const colors = this.tileColors();
|
||
if (flag === 0x400) return colors.River;
|
||
if (flag === 0x200) return colors.Shallow;
|
||
if (flag === 0x10) return colors.None;
|
||
if (flag === 0x20) return colors.Ladder;
|
||
if (flag === 0x40) return colors.Bush;
|
||
if (flag === 0x80) return colors.Counter;
|
||
if (flag === 0x0f) return colors.Wall;
|
||
return colors.Floor;
|
||
};
|
||
|
||
MinimapImage.spotFlag = function (x, y) {
|
||
if (this.isForcedWall(x, y)) return 0x0f;
|
||
if (this.isForcedFloor(x, y)) return 0x00;
|
||
const flags = $gameMap.tilesetFlags();
|
||
const tiles = $gameMap.layeredTiles(x, y);
|
||
for (const tile of tiles) {
|
||
const flag = flags[tile];
|
||
if ((flag & 0x20) !== 0) return 0x20;
|
||
if ((flag & 0x40) !== 0) return 0x40;
|
||
if ((flag & 0x80) !== 0) return 0x80;
|
||
}
|
||
for (const tile of tiles) {
|
||
const flag = flags[tile];
|
||
if ((flag & 0x10) !== 0) continue;
|
||
const type = Math.floor((tile - 2048) / 48);
|
||
if (type >= 0 && type < 16) {
|
||
return (flag & 0x0f) === 0x0f ? 0x400 : 0x200;
|
||
} else {
|
||
return flag & 0x0f;
|
||
}
|
||
}
|
||
return 0x10;
|
||
};
|
||
|
||
MinimapImage.paintPassage = function (x, y, width, height, flag) {
|
||
if ((flag & 0x0f) !== 0 && (flag & 0x0f) !== 0x0f) {
|
||
const color = this.tileColors().Wall;
|
||
const wall = this._tileSize / 3;
|
||
const isBit = (bit) => (flag & bit) === bit;
|
||
const x2 = x + wall;
|
||
const x3 = x + width - wall;
|
||
const y2 = y + wall;
|
||
const y3 = y + height - wall;
|
||
if (isBit(0x02) || isBit(0x08)) {
|
||
this.fillRect(x, y, wall, wall, color);
|
||
}
|
||
if (isBit(0x08)) {
|
||
this.fillRect(x2, y, wall, wall, color);
|
||
}
|
||
if (isBit(0x04) || isBit(0x08)) {
|
||
this.fillRect(x3, y, wall, wall, color);
|
||
}
|
||
if (isBit(0x02)) {
|
||
this.fillRect(x, y2, wall, wall, color);
|
||
}
|
||
if (isBit(0x04)) {
|
||
this.fillRect(x3, y2, wall, wall, color);
|
||
}
|
||
if (isBit(0x01) || isBit(0x02)) {
|
||
this.fillRect(x, y3, wall, wall, color);
|
||
}
|
||
if (isBit(0x01)) {
|
||
this.fillRect(x2, y3, wall, wall, color);
|
||
}
|
||
if (isBit(0x01) || isBit(0x04)) {
|
||
this.fillRect(x3, y3, wall, wall, color);
|
||
}
|
||
}
|
||
};
|
||
|
||
MinimapImage.fillRect = function (x, y, width, height, color) {
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.fillStyle = color;
|
||
context.fillRect(x, y, width, height);
|
||
context.restore();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// TilingSprite_MinimapBack
|
||
|
||
function TilingSprite_MinimapBack() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
TilingSprite_MinimapBack.prototype = Object.create(TilingSprite.prototype);
|
||
TilingSprite_MinimapBack.prototype.constructor = TilingSprite_MinimapBack;
|
||
|
||
TilingSprite_MinimapBack.prototype.initialize = function () {
|
||
TilingSprite.prototype.initialize.call(this);
|
||
// if (param_BlurLevel > 0) {
|
||
// this._createBlurFilter();
|
||
// this._blurFilter.blur = param_BlurLevel / 4;
|
||
// }
|
||
};
|
||
|
||
// TilingSprite_MinimapBack.prototype._createBlurFilter = function() {
|
||
// this._blurFilter = new PIXI.filters.BlurFilter();
|
||
// if (!this.filters) {
|
||
// this.filters = [];
|
||
// }
|
||
// this.filters.push(this._blurFilter);
|
||
// };
|
||
|
||
TilingSprite_MinimapBack.prototype.updateTransform = function () {
|
||
if (MinimapImage.isReady()) {
|
||
this.bitmap = MinimapImage.bitmap;
|
||
this.updatePlacement();
|
||
this.scale.set($gameMap.minimap.zoom() / 100);
|
||
}
|
||
if (Utils.RPGMAKER_NAME === "MV") {
|
||
this.updateTransformTS();
|
||
} else {
|
||
PIXI.TilingSprite.prototype.updateTransform.call(this);
|
||
}
|
||
};
|
||
|
||
TilingSprite_MinimapBack.prototype.updatePlacement = function () {
|
||
const rect = $gameMap.minimap.displayRect();
|
||
const tileWidth = MinimapImage.tileWidth();
|
||
const tileHeight = MinimapImage.tileHeight();
|
||
this._width = Math.min(rect.width, $gameMap.width()) * tileWidth;
|
||
this._height = Math.min(rect.height, $gameMap.height()) * tileHeight;
|
||
this.tilePosition.x = -rect.x * tileWidth;
|
||
this.tilePosition.y = -rect.y * tileHeight;
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Sprite_MinimapMarker
|
||
|
||
function Sprite_MinimapMarker() {
|
||
this.initialize.apply(this, arguments);
|
||
}
|
||
|
||
if (_importedPlugin(..._pluginOptions)) {
|
||
window.Sprite_MinimapMarker = Sprite_MinimapMarker;
|
||
}
|
||
|
||
Sprite_MinimapMarker.prototype = Object.create(Sprite.prototype);
|
||
Sprite_MinimapMarker.prototype.constructor = Sprite_MinimapMarker;
|
||
|
||
Sprite_MinimapMarker._arrowBitmaps = {};
|
||
|
||
Sprite_MinimapMarker.markerSize = function () {
|
||
return param_MarkerSize;
|
||
};
|
||
|
||
Sprite_MinimapMarker.upperPadding = function () {
|
||
return this.markerSize() * 3;
|
||
};
|
||
|
||
Sprite_MinimapMarker.arrowBitmap = function (color) {
|
||
const size = this.markerSize();
|
||
const key = `${color}:${size}`;
|
||
if (!this._arrowBitmaps[key]) {
|
||
const c = size + 1;
|
||
const bitmap = new Bitmap(c * 2, c * 2);
|
||
const context = bitmap.context;
|
||
context.save();
|
||
context.beginPath();
|
||
context.moveTo(c, c + size);
|
||
context.lineTo(c + size, c - size);
|
||
context.lineTo(c, c - size / 2);
|
||
context.lineTo(c - size, c - size);
|
||
context.closePath();
|
||
context.lineWidth = 2;
|
||
context.lineJoin = "bevel";
|
||
context.strokeStyle = color;
|
||
context.stroke();
|
||
context.fillStyle = color;
|
||
context.fill();
|
||
context.restore();
|
||
this._arrowBitmaps[key] = bitmap;
|
||
}
|
||
return this._arrowBitmaps[key];
|
||
};
|
||
|
||
Sprite_MinimapMarker.destroyArrow = function () {
|
||
for (const bitmap of Object.values(this._arrowBitmaps)) {
|
||
bitmap.destroy();
|
||
}
|
||
this._arrowBitmaps = {};
|
||
};
|
||
|
||
Object.defineProperty(Sprite_MinimapMarker.prototype, "padding", {
|
||
get() {
|
||
return this._padding;
|
||
},
|
||
set(value) {
|
||
this._padding = value;
|
||
this.x = -value;
|
||
this.y = -value;
|
||
},
|
||
configurable: true,
|
||
});
|
||
|
||
Sprite_MinimapMarker.prototype.initialize = function () {
|
||
Sprite.prototype.initialize.call(this, new Bitmap(1, 1));
|
||
this._width = 1;
|
||
this._height = 1;
|
||
this._padding = 0;
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.destroy = function () {
|
||
Sprite_MinimapMarker.destroyArrow();
|
||
this.bitmap.destroy();
|
||
Sprite.prototype.destroy.call(this);
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.setSize = function (width, height) {
|
||
const realWidth = width + this._padding * 2;
|
||
const realHeight = height + this._padding * 2;
|
||
if (this._width !== realWidth || this._height !== realHeight) {
|
||
this._width = realWidth;
|
||
this._height = realHeight;
|
||
this.bitmap.resize(realWidth, realHeight);
|
||
const context = this.bitmap.context;
|
||
context.shadowColor = "black";
|
||
context.shadowOffsetX = 1;
|
||
context.shadowOffsetY = 1;
|
||
context.shadowBlur = 4;
|
||
this._onBitmapChange();
|
||
}
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.setPaintOpacity = function (opacity) {
|
||
this.bitmap.paintOpacity = opacity;
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.clear = function () {
|
||
this.bitmap.clear();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintMarker = function (x, y, marker) {
|
||
const rx = x + this._padding;
|
||
const ry = y + this._padding;
|
||
switch (marker.type()) {
|
||
case "P":
|
||
this.paintPoint(rx, ry, marker.color());
|
||
break;
|
||
case "A":
|
||
this.paintArrow(rx, ry, marker.color(), marker.angle());
|
||
break;
|
||
case "I":
|
||
this.paintIcon(rx, ry, marker.iconIndex());
|
||
break;
|
||
case "T":
|
||
this.paintTriangle(rx, ry, marker.color());
|
||
break;
|
||
case "S":
|
||
this.paintSquare(rx, ry, marker.color());
|
||
break;
|
||
case "R":
|
||
this.paintRhombus(rx, ry, marker.color());
|
||
break;
|
||
case "X":
|
||
this.paintCross(rx, ry, marker.color());
|
||
break;
|
||
case "C": {
|
||
const xRate = $gameMap.minimap.xRate();
|
||
const radius = marker.radius() * xRate;
|
||
this.paintCircle(rx, ry, radius, marker.color());
|
||
break;
|
||
}
|
||
}
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintPoint = function (x, y, color) {
|
||
const radius = Sprite_MinimapMarker.markerSize();
|
||
this.bitmap.drawCircle(x, y, radius, color);
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintArrow = function (x, y, color, angle) {
|
||
const arrowBitmap = Sprite_MinimapMarker.arrowBitmap(color);
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.translate(x, y);
|
||
context.rotate((angle * Math.PI) / 180);
|
||
context.globalCompositeOperation = "source-over";
|
||
const image = arrowBitmap._canvas;
|
||
const dx = -arrowBitmap.width / 2;
|
||
const dy = -arrowBitmap.height / 2;
|
||
context.drawImage(image, dx, dy);
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintIcon = function (x, y, iconIndex, angle) {
|
||
const icons = ImageManager.loadPicture(param_IconImage);
|
||
if (param_IconImage && icons.isReady()) {
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.translate(x, y);
|
||
context.rotate((angle * Math.PI) / 180);
|
||
context.globalCompositeOperation = "source-over";
|
||
const n = Math.floor(icons.width / 8);
|
||
const p = -n / 2;
|
||
const image = icons._canvas || icons._image;
|
||
const sx = (iconIndex % 16) * n;
|
||
const sy = Math.floor(iconIndex / 16) * n;
|
||
context.drawImage(image, sx, sy, n, n, p, p, n, n);
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
}
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintTriangle = function (x, y, color) {
|
||
const size = Sprite_MinimapMarker.markerSize() + 1;
|
||
const h = size * Math.sqrt(3);
|
||
const r = (size * 2) / Math.sqrt(3);
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.beginPath();
|
||
context.moveTo(x, y - r);
|
||
context.lineTo(x + size, y - r + h);
|
||
context.lineTo(x - size, y - r + h);
|
||
context.closePath();
|
||
context.fillStyle = color;
|
||
context.fill();
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintSquare = function (x, y, color) {
|
||
const size = Sprite_MinimapMarker.markerSize();
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.fillStyle = color;
|
||
context.fillRect(x - size, y - size, size * 2, size * 2);
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintRhombus = function (x, y, color) {
|
||
const size = Sprite_MinimapMarker.markerSize() + 1;
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.beginPath();
|
||
context.moveTo(x, y - size);
|
||
context.lineTo(x + size, y);
|
||
context.lineTo(x, y + size);
|
||
context.lineTo(x - size, y);
|
||
context.closePath();
|
||
context.fillStyle = color;
|
||
context.fill();
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintCross = function (x, y, color) {
|
||
const size = Sprite_MinimapMarker.markerSize();
|
||
const w = (size * 2) / 3;
|
||
const r = size - w / 2 + 0.25;
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.beginPath();
|
||
context.moveTo(x - r, y - r);
|
||
context.lineTo(x + r, y + r);
|
||
context.moveTo(x + r, y - r);
|
||
context.lineTo(x - r, y + r);
|
||
context.lineWidth = w;
|
||
context.lineCap = "round";
|
||
context.strokeStyle = color;
|
||
context.stroke();
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintCircle = function (x, y, radius, color) {
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.shadowColor = "#00000000";
|
||
const grad = context.createRadialGradient(x, y, 0, x, y, radius);
|
||
grad.addColorStop(0, color);
|
||
grad.addColorStop(1, color + "60");
|
||
context.fillStyle = grad;
|
||
context.beginPath();
|
||
context.arc(x, y, radius, 0, Math.PI * 2, false);
|
||
context.fill();
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
};
|
||
|
||
Sprite_MinimapMarker.prototype.paintHighlightedArrow = function (
|
||
x,
|
||
y,
|
||
radian
|
||
) {
|
||
if (!isNaN(radian)) {
|
||
const size = Sprite_MinimapMarker.markerSize();
|
||
const pad = this._padding;
|
||
const context = this.bitmap.context;
|
||
context.save();
|
||
context.translate(x + pad, y + pad);
|
||
context.rotate(radian);
|
||
context.beginPath();
|
||
context.moveTo(size * 2, 0);
|
||
context.lineTo(size, size);
|
||
context.lineTo(size, -size);
|
||
context.closePath();
|
||
context.fillStyle = "white";
|
||
context.fill();
|
||
context.restore();
|
||
this.bitmap.baseTexture.update();
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Sprite_MiniMap
|
||
|
||
function Sprite_MiniMap() {
|
||
this.initialize.apply(this, arguments);
|
||
}
|
||
|
||
if (_importedPlugin(..._pluginOptions)) {
|
||
window.Sprite_MiniMap = Sprite_MiniMap;
|
||
}
|
||
|
||
Sprite_MiniMap.prototype = Object.create(Sprite.prototype);
|
||
Sprite_MiniMap.prototype.constructor = Sprite_MiniMap;
|
||
|
||
Sprite_MiniMap.prototype.initialize = function () {
|
||
Sprite.prototype.initialize.call(this);
|
||
this.anchor.set(0.5);
|
||
this.visible = false;
|
||
this._blinkDuration = param_BlinkDuration;
|
||
this._show = true;
|
||
this._frameName = "";
|
||
this._frameLoaded = true;
|
||
this.createBackSprite();
|
||
this.createMarkerSprites();
|
||
this.createFrameSprite();
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.createBackSprite = function () {
|
||
// MVではTilingSpriteにBlurFilterが使えないため、
|
||
// PIXI.Containerに入れてこちらにブラーをかける
|
||
this._baclContainer = new PIXI.Container();
|
||
if (param_BlurLevel > 0) {
|
||
const blurFilter = new PIXI.filters.BlurFilter();
|
||
blurFilter.blur = param_BlurLevel / 4;
|
||
this._baclContainer.filters = [blurFilter];
|
||
}
|
||
this.addChild(this._baclContainer);
|
||
this._backSprite = new TilingSprite_MinimapBack();
|
||
this._baclContainer.addChild(this._backSprite);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.createMarkerSprites = function () {
|
||
this._lowerMarkerSprite = new Sprite_MinimapMarker();
|
||
this._upperMarkerSprite = new Sprite_MinimapMarker();
|
||
this._upperMarkerSprite.padding = Sprite_MinimapMarker.upperPadding();
|
||
this.addChild(this._lowerMarkerSprite);
|
||
this.addChild(this._upperMarkerSprite);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.createFrameSprite = function () {
|
||
this._frameSprite = new Sprite();
|
||
this.addChild(this._frameSprite);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.hide = function () {
|
||
this._show = false;
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.clearMarker = function () {
|
||
this._lowerMarkerSprite.clear();
|
||
this._upperMarkerSprite.clear();
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.update = function () {
|
||
Sprite.prototype.update.call(this);
|
||
const params = $gameMap.minimap.params();
|
||
if (params) {
|
||
this.updateFrame(params);
|
||
}
|
||
this.updateVisibility(params);
|
||
if (this.visible) {
|
||
this.updateBack();
|
||
this.updatePosition(params);
|
||
this.updateMarker(params);
|
||
this.updateBlink();
|
||
this.updateOpacity(params);
|
||
}
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateVisibility = function (params) {
|
||
this.visible = params && this._show && this._frameLoaded;
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateBack = function () {
|
||
const rect = $gameMap.minimap.displayRect();
|
||
const tileWidth = MinimapImage.tileWidth();
|
||
const tileHeight = MinimapImage.tileHeight();
|
||
const width = Math.min(rect.width, $gameMap.width()) * tileWidth;
|
||
const height = Math.min(rect.height, $gameMap.height()) * tileHeight;
|
||
this._backSprite.move(0, 0, width, height);
|
||
this._backSprite.origin.x = rect.x * tileWidth;
|
||
this._backSprite.origin.y = rect.y * tileHeight;
|
||
this._backSprite.scale.set($gameMap.minimap.zoom() / 100);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateFrame = function (params) {
|
||
const name = params["Frame Image"];
|
||
if (this._frameName !== name) {
|
||
this._frameName = name;
|
||
this._frameSprite.bitmap = ImageManager.loadPicture(name);
|
||
this._frameLoaded = false;
|
||
}
|
||
if (!this._frameLoaded && this._frameSprite.bitmap.isReady()) {
|
||
const { width, height } = this._frameSprite.bitmap;
|
||
this._frameSprite.x = (params.Width - width) / 2;
|
||
this._frameSprite.y = (params.Height - height) / 2;
|
||
this._frameLoaded = true;
|
||
}
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updatePosition = function (params) {
|
||
this.x = params.X + $gameMap.minimap.correctionX();
|
||
this.y = params.Y + $gameMap.minimap.correctionY();
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateMarker = function (params) {
|
||
const { Width: width, Height: height } = params;
|
||
this._lowerMarkerSprite.setSize(width, height);
|
||
this._upperMarkerSprite.setSize(width, height);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateBlink = function () {
|
||
this._blinkDuration--;
|
||
if (this._blinkDuration <= 0) {
|
||
this._blinkDuration = param_BlinkDuration;
|
||
}
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateOpacity = function (params) {
|
||
this.opacity = params.Opacity;
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.updateTransform = function () {
|
||
if (this.visible) {
|
||
this.clearMarker();
|
||
this.paintAllMarkers();
|
||
}
|
||
Sprite.prototype.updateTransform.call(this);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.paintAllMarkers = function () {
|
||
const xRate = $gameMap.minimap.xRate();
|
||
const yRate = $gameMap.minimap.yRate();
|
||
for (const marker of $gameMap.allMinimapMarkers()) {
|
||
if (marker.isVisible()) {
|
||
this.paintMarker(marker, xRate, yRate);
|
||
}
|
||
}
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.paintMarker = function (marker, xRate, yRate) {
|
||
const x = marker.minimapX();
|
||
const y = marker.minimapY();
|
||
if (marker.isHighlighted()) {
|
||
const sprite = this._upperMarkerSprite;
|
||
this.setSpriteOpacity(sprite, marker);
|
||
const [cx, cy, radian] = this.correctionPos(x, y);
|
||
const dx = cx * xRate;
|
||
const dy = cy * yRate;
|
||
sprite.paintMarker(dx, dy, marker);
|
||
sprite.paintHighlightedArrow(dx, dy, radian);
|
||
} else {
|
||
const sprite = this._lowerMarkerSprite;
|
||
this.setSpriteOpacity(sprite, marker);
|
||
const dx = x * xRate;
|
||
const dy = y * yRate;
|
||
sprite.paintMarker(dx, dy, marker);
|
||
}
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.setSpriteOpacity = function (sprite, marker) {
|
||
const opacity = marker.isBlink()
|
||
? (255 * this._blinkDuration) / param_BlinkDuration
|
||
: 255;
|
||
sprite.setPaintOpacity(opacity);
|
||
};
|
||
|
||
Sprite_MiniMap.prototype.correctionPos = function (x, y) {
|
||
const rect = $gameMap.minimap.displayRect();
|
||
const hw = rect.width / 2;
|
||
const hh = rect.height / 2;
|
||
let sx = x - hw;
|
||
let sy = y - hh;
|
||
if (sx < -hw) {
|
||
sy *= -hw / sx;
|
||
sx = -hw;
|
||
} else if (sx > hw) {
|
||
sy *= hw / sx;
|
||
sx = hw;
|
||
}
|
||
if (sy < -hh) {
|
||
sx *= -hh / sy;
|
||
sy = -hh;
|
||
} else if (sy > hh) {
|
||
sx *= hh / sy;
|
||
sy = hh;
|
||
}
|
||
return [
|
||
sx + hw,
|
||
sy + hh,
|
||
sx !== x - hw || sy !== y - hh ? Math.atan2(sy, sx) : NaN,
|
||
];
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Spriteset_Map
|
||
|
||
const _Spriteset_Map_loadTileset = Spriteset_Map.prototype.loadTileset;
|
||
Spriteset_Map.prototype.loadTileset = function () {
|
||
_Spriteset_Map_loadTileset.apply(this, arguments);
|
||
MinimapImage.refresh();
|
||
};
|
||
|
||
//-------------------------------------------------------------------------
|
||
// Scene_Map
|
||
|
||
const _Scene_Map_terminate = Scene_Map.prototype.terminate;
|
||
Scene_Map.prototype.terminate = function () {
|
||
if (this._minimapSprite) this._minimapSprite.hide();
|
||
_Scene_Map_terminate.apply(this, arguments);
|
||
if (this._minimapSprite && Utils.RPGMAKER_NAME === "MV") {
|
||
this._minimapSprite.destroy();
|
||
this.removeChild(this._minimapSprite);
|
||
}
|
||
};
|
||
|
||
const _Scene_Map_createDisplayObjects =
|
||
Scene_Map.prototype.createDisplayObjects;
|
||
Scene_Map.prototype.createDisplayObjects = function () {
|
||
MinimapImage.destroy();
|
||
if ($gameMap.isShowMinimap()) {
|
||
MinimapImage.onLoad($gameMap.minimapImageName());
|
||
}
|
||
_Scene_Map_createDisplayObjects.apply(this, arguments);
|
||
this.createMinimap();
|
||
};
|
||
|
||
Scene_Map.prototype.createMinimap = function () {
|
||
if ($gameMap.isShowMinimap()) {
|
||
this._minimapSprite = new Sprite_MiniMap();
|
||
const index = this.children.indexOf(this._windowLayer);
|
||
if (index < 0) {
|
||
this.addChild(this._minimapSprite);
|
||
} else {
|
||
this.addChildAt(this._minimapSprite, index);
|
||
}
|
||
}
|
||
};
|
||
|
||
const _Scene_Map_callMenu = Scene_Map.prototype.callMenu;
|
||
Scene_Map.prototype.callMenu = function () {
|
||
_Scene_Map_callMenu.apply(this, arguments);
|
||
if (this._minimapSprite) this._minimapSprite.hide();
|
||
};
|
||
|
||
const _Scene_Map_launchBattle = Scene_Map.prototype.launchBattle;
|
||
Scene_Map.prototype.launchBattle = function () {
|
||
_Scene_Map_launchBattle.apply(this, arguments);
|
||
if (this._minimapSprite) this._minimapSprite.hide();
|
||
};
|
||
})();
|