2066 lines
56 KiB
JavaScript
2066 lines
56 KiB
JavaScript
/*:
|
|
@target MV MZ
|
|
@plugindesc リングコマンドメニュー v1.4.1
|
|
@author うなぎおおとろ
|
|
@url https://raw.githubusercontent.com/unagiootoro/RPGMZ/master/RingCommandMenu.js
|
|
@help
|
|
リングコマンドメニューを導入するプラグインです。
|
|
|
|
【使用方法】
|
|
基本的に導入するだけで使用できますが、プラグインパラメータ「メインメニューコマンド」を編集することで
|
|
よりリングコマンドをカスタマイズすることができます。
|
|
|
|
■ メインメニューコマンドの編集について
|
|
メインメニューコマンドに一覧に表示するコマンドを登録します。
|
|
|
|
■ コマンドタイプについて
|
|
コマンドタイプではコマンドをどのように扱うかを指定します。
|
|
これを設定することでコマンド実行前にアクターの選択を行うか、またはサブコマンドの一覧を開くかを設定することができます。
|
|
commonEvent: コモンイベントを実行
|
|
script: スクリプトを実行する(主にシーンを開くために使用)
|
|
selectActor: アクターを選択してからスクリプトを実行((主にアクターを選択するシーンを開くために仕様)
|
|
subMenu: サブコマンドの一覧を開く
|
|
|
|
※v1.3.0以降より、コマンドタイプのnormalはscriptに変更になりました。
|
|
ただし互換性のためにnormalを指定した場合はscriptを指定したものとして扱います。
|
|
|
|
■ アクター選択コマンドの編集について
|
|
アクター選択画面のアイコンはキャラクターの歩行グラフィックスから自動的に生成されますが、
|
|
アクター選択コマンドを編集することで自由にアクターのアイコンを設定することが可能です。
|
|
|
|
|
|
【ライセンス】
|
|
このプラグインは、MITライセンスの条件の下で利用可能です。
|
|
|
|
|
|
@param MainMenuCommands
|
|
@text メインメニューコマンド
|
|
@type struct<MenuCommand>[]
|
|
@default ["{\"CommandType\":\"script\",\"Text\":\"アイテム\",\"IconIndex\":\"208\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_Item);\",\"SubMenuCommands\":\"\"}","{\"CommandType\":\"selectActor\",\"Text\":\"スキル\",\"IconIndex\":\"79\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_Skill);\",\"SubMenuCommands\":\"\"}","{\"CommandType\":\"selectActor\",\"Text\":\"装備\",\"IconIndex\":\"96\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_Equip);\",\"SubMenuCommands\":\"\"}","{\"CommandType\":\"selectActor\",\"Text\":\"ステータス\",\"IconIndex\":\"89\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_Status);\",\"SubMenuCommands\":\"\"}","{\"CommandType\":\"script\",\"Text\":\"オプション\",\"IconIndex\":\"129\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_Options);\",\"SubMenuCommands\":\"\"}","{\"CommandType\":\"script\",\"Text\":\"セーブ\",\"IconIndex\":\"121\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_Save);\",\"SubMenuCommands\":\"\"}","{\"CommandType\":\"script\",\"Text\":\"ゲーム終了\",\"IconIndex\":\"75\",\"Image\":\"\",\"Script\":\"SceneManager.push(Scene_GameEnd);\",\"SubMenuCommands\":\"\"}"]
|
|
@desc
|
|
メインメニューに表示するコマンドの一覧を指定します。
|
|
|
|
@param SelectActorCommands
|
|
@text アクター選択コマンド
|
|
@type struct<SelectActorCommand>[]
|
|
@default []
|
|
@desc
|
|
アクター選択のアクターコマンドを指定します。
|
|
|
|
@param EnableSubCommandRotation
|
|
@text サブコマンド回転有効
|
|
@type boolean
|
|
@default false
|
|
@desc
|
|
サブコマンド表示時の回転を有効にします。
|
|
|
|
@param SkipActorSelect
|
|
@text アクター選択スキップ
|
|
@type boolean
|
|
@default true
|
|
@desc
|
|
trueを設定するとパーティメンバーが1人しかいない場合はアクター選択画面をスキップします。
|
|
|
|
@param SaveCommandText
|
|
@text セーブコマンドテキスト
|
|
@type string
|
|
@default セーブ
|
|
@desc
|
|
セーブコマンドのテキストを指定します。このパラメータはコマンドがセーブコマンドか否かの判定に使用します。
|
|
|
|
@param OpenSe
|
|
@text 開始SE
|
|
@type struct<SE>
|
|
@default {"FileName":"Magic1","Volume":"90","Pitch":"100","Pan":"0"}
|
|
@desc
|
|
リングコマンドメニューを開始するときのSEを指定します。
|
|
|
|
@param CloseSe
|
|
@text 終了SE
|
|
@type struct<SE>
|
|
@default {"FileName":"Magic2","Volume":"90","Pitch":"100","Pan":"0"}
|
|
@desc
|
|
リングコマンドメニューを終了するときのSEを指定します。
|
|
|
|
@param SubOpenSe
|
|
@text サブ開始SE
|
|
@type struct<SE>
|
|
@default {"FileName":"Magic1","Volume":"90","Pitch":"150","Pan":"0"}
|
|
@desc
|
|
サブメニューまたはアクター選択を開始するときのSEを指定します。
|
|
|
|
@param SubCloseSe
|
|
@text サブ終了SE
|
|
@type struct<SE>
|
|
@default {"FileName":"Magic1","Volume":"90","Pitch":"150","Pan":"0"}
|
|
@desc
|
|
サブメニューまたはアクター選択を終了するときのSEを指定します。
|
|
|
|
@param BackGroundOpacity
|
|
@text 背景不透明度
|
|
@type number
|
|
@default 192
|
|
@desc
|
|
リングコマンドメニューの背景の不透明度を指定します。
|
|
|
|
@param InOutSpeed
|
|
@text 開閉スピード
|
|
@type number
|
|
@default 8
|
|
@desc
|
|
リングコマンドの開閉スピードを指定します。
|
|
|
|
@param RotationSpeed
|
|
@text 回転スピード
|
|
@type number
|
|
@default 11
|
|
@desc
|
|
リングコマンドの回転スピードを指定します。
|
|
|
|
@param StartFar
|
|
@text 開始距離
|
|
@type number
|
|
@default 300
|
|
@desc
|
|
リングコマンドのオープン開始距離を指定します。
|
|
|
|
@param EndFar
|
|
@text 終了距離
|
|
@type number
|
|
@default 70
|
|
@desc
|
|
リングコマンドのオープン終了距離を指定します。
|
|
*/
|
|
|
|
/*~struct~MenuCommand:
|
|
@param CommandType
|
|
@text コマンドタイプ
|
|
@type string
|
|
@default script
|
|
@desc
|
|
コマンドの用途(script, selectActor, subMenu)を指定します。
|
|
|
|
@param Text
|
|
@text テキスト
|
|
@type string
|
|
@desc
|
|
メニューに表示するテキストを指定します。
|
|
|
|
@param IconIndex
|
|
@text アイコン番号
|
|
@type number
|
|
@default 0
|
|
@desc
|
|
リングコマンドのアイコン番号を指定します。
|
|
|
|
@param Image
|
|
@text 画像
|
|
@type file
|
|
@dir img/pictures
|
|
@desc
|
|
リングコマンドの画像を指定します。
|
|
|
|
@param Script
|
|
@text スクリプト
|
|
@type multiline_string
|
|
@desc
|
|
リングコマンド選択時に実行するスクリプトを記述します。
|
|
|
|
@param CommonEventId
|
|
@text コモンイベントID
|
|
@type common_event
|
|
@default 0
|
|
@desc
|
|
リングコマンド選択時に実行するコモンイベントIDを設定します。0だとコモンイベントを実行しません。
|
|
|
|
@param SubMenuCommands
|
|
@text サブメニューコマンド
|
|
@type struct<MenuCommand>[]
|
|
@desc
|
|
サブメニューとして表示するコマンドの一覧を指定します。
|
|
*/
|
|
|
|
/*~struct~SE:
|
|
@param FileName
|
|
@type file
|
|
@dir audio/se
|
|
@desc
|
|
再生するSEのファイル名を指定します。
|
|
|
|
@param Volume
|
|
@type number
|
|
@default 90
|
|
@desc
|
|
再生するSEのvolumeを指定します。
|
|
|
|
@param Pitch
|
|
@type number
|
|
@default 100
|
|
@desc
|
|
再生するSEのpitchを指定します。
|
|
|
|
@param Pan
|
|
@type number
|
|
@default 0
|
|
@desc
|
|
再生するSEのpanを指定します。
|
|
*/
|
|
|
|
/*~struct~SelectActorCommand:
|
|
@param ActorId
|
|
@text アクターID
|
|
@type actor
|
|
@desc
|
|
アクター選択用のアクターIDを指定します。
|
|
|
|
@param Image
|
|
@text 画像
|
|
@type file
|
|
@dir img/pictures
|
|
@desc
|
|
アクター選択用のアクターの画像を指定します。
|
|
*/
|
|
|
|
const RingCommandMenuPluginName =
|
|
document.currentScript.src.match(/.+\/(.+)\.js/)[1];
|
|
|
|
const RingCommandMenuClassAlias = (() => {
|
|
"use strict";
|
|
|
|
const RING_COMMAND_OFFSET_Y = -32;
|
|
|
|
class PluginParamsParser {
|
|
static parse(params, typeData, predictEnable = true) {
|
|
return new PluginParamsParser(predictEnable).parse(params, typeData);
|
|
}
|
|
|
|
constructor(predictEnable = true) {
|
|
this._predictEnable = predictEnable;
|
|
}
|
|
|
|
parse(params, typeData, loopCount = 0) {
|
|
if (++loopCount > 255) throw new Error("endless loop error");
|
|
const result = {};
|
|
for (const name in typeData) {
|
|
if (params[name] === "" || params[name] === undefined) {
|
|
result[name] = null;
|
|
} else {
|
|
result[name] = this.convertParam(
|
|
params[name],
|
|
typeData[name],
|
|
loopCount
|
|
);
|
|
}
|
|
}
|
|
if (!this._predictEnable) return result;
|
|
if (typeof params === "object" && !(params instanceof Array)) {
|
|
for (const name in params) {
|
|
if (result[name]) continue;
|
|
const param = params[name];
|
|
const type = this.predict(param);
|
|
result[name] = this.convertParam(param, type, loopCount);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
convertParam(param, type, loopCount) {
|
|
if (typeof type === "string") {
|
|
return this.cast(param, type);
|
|
} else if (typeof type === "object" && type instanceof Array) {
|
|
const aryParam = JSON.parse(param);
|
|
if (type[0] === "string") {
|
|
return aryParam.map((strParam) => this.cast(strParam, type[0]));
|
|
} else {
|
|
return aryParam.map(
|
|
(strParam) => this.parse(JSON.parse(strParam), type[0]),
|
|
loopCount
|
|
);
|
|
}
|
|
} else if (typeof type === "object") {
|
|
return this.parse(JSON.parse(param), type, loopCount);
|
|
} else {
|
|
throw new Error(`${type} is not string or object`);
|
|
}
|
|
}
|
|
|
|
cast(param, type) {
|
|
switch (type) {
|
|
case "any":
|
|
if (!this._predictEnable) throw new Error("Predict mode is disable");
|
|
return this.cast(param, this.predict(param));
|
|
case "string":
|
|
return param;
|
|
case "number":
|
|
if (param.match(/\d+\.\d+/)) return parseFloat(param);
|
|
return parseInt(param);
|
|
case "boolean":
|
|
return param === "true";
|
|
default:
|
|
throw new Error(`Unknow type: ${type}`);
|
|
}
|
|
}
|
|
|
|
predict(param) {
|
|
if (param.match(/^\d+$/) || param.match(/^\d+\.\d+$/)) {
|
|
return "number";
|
|
} else if (param === "true" || param === "false") {
|
|
return "boolean";
|
|
} else {
|
|
return "string";
|
|
}
|
|
}
|
|
}
|
|
|
|
// MV Compatible
|
|
if (Utils.RPGMAKER_NAME === "MV") {
|
|
TouchInput._onMouseMove = function (event) {
|
|
const x = Graphics.pageToCanvasX(event.pageX);
|
|
const y = Graphics.pageToCanvasY(event.pageY);
|
|
if (this._mousePressed) {
|
|
this._onMove(x, y);
|
|
} else if (Graphics.isInsideCanvas(x, y)) {
|
|
this._onHover(x, y);
|
|
}
|
|
};
|
|
|
|
TouchInput._onHover = function (x, y) {
|
|
this._events.hovered = true;
|
|
this._x = x;
|
|
this._y = y;
|
|
};
|
|
|
|
const _TouchInput_update = TouchInput.update;
|
|
TouchInput.update = function () {
|
|
_TouchInput_update.call(this);
|
|
this._hovered = this._events.hovered;
|
|
this._events.hovered = false;
|
|
};
|
|
|
|
TouchInput.isHovered = function () {
|
|
return this._hovered;
|
|
};
|
|
|
|
var Sprite_ClickableMV = function () {
|
|
this.initialize(...arguments);
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype = Object.create(Sprite_Base.prototype);
|
|
Sprite_ClickableMV.prototype.constructor = Sprite_ClickableMV;
|
|
|
|
Sprite_ClickableMV.prototype.initialize = function () {
|
|
Sprite_Base.prototype.initialize.call(this);
|
|
this._pressed = false;
|
|
this._hovered = false;
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.update = function () {
|
|
Sprite_Base.prototype.update.call(this);
|
|
this.processTouch();
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.processTouch = function () {
|
|
if (this.isClickEnabled()) {
|
|
if (this.isBeingTouched()) {
|
|
if (!this._hovered && TouchInput.isHovered()) {
|
|
this._hovered = true;
|
|
this.onMouseEnter();
|
|
}
|
|
if (TouchInput.isTriggered()) {
|
|
this._pressed = true;
|
|
this.onPress();
|
|
}
|
|
} else {
|
|
if (this._hovered) {
|
|
this.onMouseExit();
|
|
}
|
|
this._pressed = false;
|
|
this._hovered = false;
|
|
}
|
|
if (this._pressed && TouchInput.isReleased()) {
|
|
this._pressed = false;
|
|
this.onClick();
|
|
}
|
|
} else {
|
|
this._pressed = false;
|
|
this._hovered = false;
|
|
}
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.isPressed = function () {
|
|
return this._pressed;
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.isClickEnabled = function () {
|
|
return this.worldVisible;
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.isBeingTouched = function () {
|
|
const touchPos = new Point(TouchInput.x, TouchInput.y);
|
|
const localPos = this.worldTransform.applyInverse(touchPos);
|
|
return this.hitTest(localPos.x, localPos.y);
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.hitTest = function (x, y) {
|
|
const rect = new Rectangle(
|
|
-this.anchor.x * this.width,
|
|
-this.anchor.y * this.height,
|
|
this.width,
|
|
this.height
|
|
);
|
|
return rect.contains(x, y);
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.onMouseEnter = function () {
|
|
//
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.onMouseExit = function () {
|
|
//
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.onPress = function () {
|
|
//
|
|
};
|
|
|
|
Sprite_ClickableMV.prototype.onClick = function () {
|
|
//
|
|
};
|
|
}
|
|
|
|
let SpriteMVMZ;
|
|
let Sprite_ClickableMVMZ;
|
|
if (Utils.RPGMAKER_NAME === "MZ") {
|
|
SpriteMVMZ = Sprite;
|
|
Sprite_ClickableMVMZ = Sprite_Clickable;
|
|
} else {
|
|
SpriteMVMZ = Sprite_Base;
|
|
Sprite_ClickableMVMZ = Sprite_ClickableMV;
|
|
}
|
|
|
|
const typeDefine = {
|
|
MainMenuCommands: [{}],
|
|
OpenSe: {},
|
|
CloseSe: {},
|
|
SubOpenSe: {},
|
|
SubCloseSe: {},
|
|
SelectActorCommands: [{}],
|
|
};
|
|
const PP = PluginParamsParser.parse(
|
|
PluginManager.parameters(RingCommandMenuPluginName),
|
|
typeDefine
|
|
);
|
|
|
|
const $ringCommnadDatas = [];
|
|
|
|
class RingCommandUtils {
|
|
static needSkipActorSelect() {
|
|
return PP.SkipActorSelect && $gameParty.members().length === 1;
|
|
}
|
|
}
|
|
|
|
class RingCommandData {
|
|
get commandType() {
|
|
return this._commandType;
|
|
}
|
|
get text() {
|
|
return this._text;
|
|
}
|
|
get iconIndex() {
|
|
return this._iconIndex;
|
|
}
|
|
get image() {
|
|
return this._image;
|
|
}
|
|
get script() {
|
|
return this._script;
|
|
}
|
|
get subCommands() {
|
|
return this._subCommands;
|
|
}
|
|
get internalIndex() {
|
|
return this._internalIndex;
|
|
}
|
|
get commonEventId() {
|
|
return this._commonEventId;
|
|
}
|
|
|
|
static fromParam(param, internalIndex) {
|
|
if (param.CommandType === "subMenu") {
|
|
const subCommands = JSON.parse(param.SubMenuCommands)
|
|
.map((strSubMenuCommandParam, i) => {
|
|
if (strSubMenuCommandParam === "") return null;
|
|
const subMenuCommandParam = PluginParamsParser.parse(
|
|
JSON.parse(strSubMenuCommandParam),
|
|
{}
|
|
);
|
|
return RingCommandData.fromParam(subMenuCommandParam, i);
|
|
})
|
|
.filter((command) => !!command);
|
|
return new this(
|
|
param.CommandType,
|
|
param.Text,
|
|
param.IconIndex,
|
|
param.Image,
|
|
param.Script,
|
|
subCommands,
|
|
param.CommonEventId,
|
|
internalIndex
|
|
);
|
|
} else {
|
|
return new this(
|
|
param.CommandType,
|
|
param.Text,
|
|
param.IconIndex,
|
|
param.Image,
|
|
param.Script,
|
|
null,
|
|
param.CommonEventId,
|
|
internalIndex
|
|
);
|
|
}
|
|
}
|
|
|
|
constructor(...args) {
|
|
this.initialize(...args);
|
|
}
|
|
|
|
initialize(
|
|
commandType,
|
|
text,
|
|
iconIndex,
|
|
image,
|
|
script,
|
|
subCommands,
|
|
commonEventId,
|
|
internalIndex
|
|
) {
|
|
this._commandType = commandType;
|
|
this._text = text;
|
|
this._iconIndex = iconIndex;
|
|
this._image = image;
|
|
this._script = script;
|
|
this._subCommands = subCommands;
|
|
this._internalIndex = internalIndex;
|
|
this._commonEventId = commonEventId;
|
|
}
|
|
|
|
isEnabled() {
|
|
if (this._text === PP.SaveCommandText) {
|
|
return $gameSystem.isSaveEnabled();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
PP.MainMenuCommands.forEach((param, i) => {
|
|
const data = RingCommandData.fromParam(param, i++);
|
|
$ringCommnadDatas.push(data);
|
|
});
|
|
|
|
Game_Temp.prototype.setRingCommandManager = function (manager) {
|
|
this._ringCommandManager = manager;
|
|
};
|
|
|
|
Game_Temp.prototype.ringCommandManager = function () {
|
|
return this._ringCommandManager;
|
|
};
|
|
|
|
Game_Temp.prototype.setRingCommandCommonEventRunner = function (
|
|
commonEventRunner
|
|
) {
|
|
this._ringCommandCommonEventRunner = commonEventRunner;
|
|
};
|
|
|
|
Game_Temp.prototype.ringCommandCommonEventRunner = function () {
|
|
return this._ringCommandCommonEventRunner;
|
|
};
|
|
|
|
class Sprite_RingCommand extends Sprite_ClickableMVMZ {
|
|
get rotateSpeed() {
|
|
return this._rotateSpeed;
|
|
}
|
|
set rotateSpeed(_rotateSpeed) {
|
|
this._rotateSpeed = _rotateSpeed;
|
|
}
|
|
|
|
get homeX() {
|
|
return this._homeX;
|
|
}
|
|
set homeX(_homeX) {
|
|
this._homeX = _homeX;
|
|
}
|
|
|
|
get homeY() {
|
|
return this._homeY;
|
|
}
|
|
set homeY(_homeY) {
|
|
this._homeY = _homeY;
|
|
}
|
|
|
|
get deg() {
|
|
return this._deg;
|
|
}
|
|
set deg(_deg) {
|
|
this._deg = this.degNormalization(_deg);
|
|
this.move(this._deg, this._far);
|
|
}
|
|
|
|
get far() {
|
|
return this._far;
|
|
}
|
|
set far(_far) {
|
|
this._far = _far;
|
|
this.move(this._deg, this._far);
|
|
}
|
|
|
|
get data() {
|
|
return this._data;
|
|
}
|
|
|
|
initialize(
|
|
homeX,
|
|
homeY,
|
|
data,
|
|
opt = { mouseEnterCbk: null, mouseExitCbk: null, clickCbk: null }
|
|
) {
|
|
super.initialize();
|
|
this._homeX = homeX;
|
|
this._homeY = homeY;
|
|
this._data = data;
|
|
this._mouseEnterCbk = opt.mouseEnterCbk;
|
|
this._mouseExitCbk = opt.mouseExitCbk;
|
|
this._clickCbk = opt.clickCbk;
|
|
this._deg = 0;
|
|
this._degPlused = 0;
|
|
this._baseDeg = 0;
|
|
this._far = 0;
|
|
this._targetDegPlus = null;
|
|
this._rotateSpeed = 4;
|
|
this._rotateWay = 1;
|
|
this.move(0, 0);
|
|
this.bitmap = new Bitmap(32, 32);
|
|
this.createBitmap(data);
|
|
this.hide();
|
|
}
|
|
|
|
createBitmap(data) {
|
|
if (data.image) {
|
|
this.bitmap = ImageManager.loadPicture(data.image);
|
|
} else {
|
|
if (data.commandType === "actorData") {
|
|
this.createActorIcon($gameParty.members()[data.internalIndex]);
|
|
} else {
|
|
const iconIndex = data.iconIndex;
|
|
this.bitmap = this.trimIconset(iconIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
trimIconset(iconIndex) {
|
|
const srcBitmap = ImageManager.loadSystem("IconSet");
|
|
const dstBitmap = new Bitmap(32, 32);
|
|
const sx = (iconIndex % 16) * 32;
|
|
const sy = Math.floor(iconIndex / 16) * 32;
|
|
dstBitmap.blt(srcBitmap, sx, sy, 32, 32, 0, 0);
|
|
return dstBitmap;
|
|
}
|
|
|
|
createActorIcon(actor) {
|
|
this._actor = actor;
|
|
this.updateActorImage();
|
|
}
|
|
|
|
updateActorImage() {
|
|
if (!this._actor) return;
|
|
const characterName = this._actor.characterName();
|
|
const characterIndex = this._actor.characterIndex();
|
|
const characterBitmap = ImageManager.loadCharacter(characterName);
|
|
if (!characterBitmap.isReady()) return;
|
|
const dstBitmap = new Bitmap(48, 32);
|
|
this.actorImageDrawCharacter(
|
|
dstBitmap,
|
|
characterBitmap,
|
|
characterName,
|
|
characterIndex
|
|
);
|
|
this.bitmap = dstBitmap;
|
|
}
|
|
|
|
actorImageDrawCharacter(
|
|
dstBitmap,
|
|
characterBitmap,
|
|
characterName,
|
|
characterIndex
|
|
) {
|
|
const big = ImageManager.isBigCharacter(characterName);
|
|
const pw = characterBitmap.width / (big ? 3 : 12);
|
|
const ph = characterBitmap.height / (big ? 4 : 8);
|
|
const n = big ? 0 : characterIndex;
|
|
const sx = ((n % 4) * 3 + 1) * pw;
|
|
const sy = Math.floor(n / 4) * 4 * ph;
|
|
dstBitmap.blt(characterBitmap, sx, sy, pw, ph, 0, 0);
|
|
}
|
|
|
|
update() {
|
|
super.update();
|
|
this.updateOpacity();
|
|
if (this._targetDegPlus != null) this.updateRotation();
|
|
}
|
|
|
|
updateOpacity() {
|
|
if (this._data.isEnabled()) {
|
|
this.opacity = 255;
|
|
} else {
|
|
this.opacity = 128;
|
|
}
|
|
}
|
|
|
|
updateRotation() {
|
|
this._degPlused += this._rotateSpeed * this._rotateWay;
|
|
let isEnd;
|
|
if (this._rotateWay > 0) {
|
|
isEnd = this._degPlused >= this._targetDegPlus;
|
|
} else {
|
|
isEnd = this._degPlused <= this._targetDegPlus;
|
|
}
|
|
if (isEnd) {
|
|
this._deg = this.degNormalization(this._baseDeg + this._targetDegPlus);
|
|
this._targetDegPlus = null;
|
|
} else {
|
|
this._deg = this.degNormalization(this._baseDeg + this._degPlused);
|
|
}
|
|
this.move(this._deg, this._far);
|
|
}
|
|
|
|
isBusy() {
|
|
return !!this._targetDegPlus;
|
|
}
|
|
|
|
// way: "left" or "right"
|
|
startRotationAbs(absDeg, way) {
|
|
let degPlus = 0;
|
|
if (way === "left") {
|
|
if (absDeg > this._deg) {
|
|
degPlus = absDeg - this._deg;
|
|
} else if (absDeg < this._deg) {
|
|
degPlus = 360 - this._deg + absDeg;
|
|
}
|
|
} else if (way === "right") {
|
|
if (this._deg > absDeg) {
|
|
degPlus = absDeg - this._deg;
|
|
} else if (this._deg < absDeg) {
|
|
degPlus = -(this._deg + 360 - absDeg);
|
|
}
|
|
}
|
|
this.startRotation(degPlus);
|
|
}
|
|
|
|
startRotation(degPlus) {
|
|
this._targetDegPlus = degPlus;
|
|
this._degPlused = 0;
|
|
this._baseDeg = this._deg;
|
|
if (degPlus > 0) {
|
|
this._rotateWay = 1;
|
|
} else {
|
|
this._rotateWay = -1;
|
|
}
|
|
}
|
|
|
|
stopRotation() {
|
|
this._rotateWay = null;
|
|
this._targetDegPlus = null;
|
|
}
|
|
|
|
move(deg, far) {
|
|
const rad = this.deg2rad(deg);
|
|
const disX = Math.round(far * Math.cos(rad));
|
|
const disY = Math.round(far * Math.sin(rad));
|
|
this.x = this._homeX + disX;
|
|
this.y = this._homeY + disY;
|
|
}
|
|
|
|
rad2deg(rad) {
|
|
return (rad * 180) / Math.PI + 90;
|
|
}
|
|
|
|
deg2rad(deg) {
|
|
return ((deg - 90) * Math.PI) / 180;
|
|
}
|
|
|
|
degNormalization(deg) {
|
|
deg %= 360;
|
|
if (deg < 0) deg = 360 + deg;
|
|
return deg;
|
|
}
|
|
|
|
onMouseEnter() {
|
|
if (this._mouseEnterCbk && !this.isBusy()) this._mouseEnterCbk(this);
|
|
}
|
|
|
|
onMouseExit() {
|
|
if (this._mouseExitCbk && !this.isBusy()) this._mouseExitCbk(this);
|
|
}
|
|
|
|
onClick() {
|
|
if (this._clickCbk && !this.isBusy()) this._clickCbk(this);
|
|
}
|
|
}
|
|
|
|
class RingCommandSpriteController {
|
|
constructor(...args) {
|
|
this.initialize(...args);
|
|
}
|
|
|
|
initialize() {
|
|
this._sprites = null;
|
|
this._baseSprite = null;
|
|
this._baseMinFar = PP.EndFar;
|
|
this._baseMaxFar = PP.StartFar;
|
|
this._minFar = this._baseMinFar;
|
|
this._maxFar = this._baseMaxFar;
|
|
this._baseRotateSpeed = PP.RotationSpeed;
|
|
this._inOutSpeed = PP.InOutSpeed;
|
|
this._state = "none";
|
|
this._currentIndex = 0;
|
|
this._startDeg = 0;
|
|
this._marginFar = 0;
|
|
}
|
|
|
|
reset(sprites, index) {
|
|
this._sprites = sprites;
|
|
this._baseSprite = this._sprites[index];
|
|
this._state = "none";
|
|
this._currentIndex = index;
|
|
}
|
|
|
|
startOutCenterAndRotation() {
|
|
this.startInOutAndRotation(
|
|
"outCenterAndRotation",
|
|
this._baseMinFar,
|
|
this._baseMaxFar,
|
|
this._baseMinFar,
|
|
false
|
|
);
|
|
}
|
|
|
|
startInCenterAndRotation() {
|
|
this.startInOutAndRotation(
|
|
"inCenterAndRotation",
|
|
this._baseMinFar,
|
|
this._baseMaxFar,
|
|
this._baseMaxFar,
|
|
true
|
|
);
|
|
}
|
|
|
|
startSubOutCenterAndRotation() {
|
|
this.startInOutAndRotation(
|
|
"outCenterAndRotation",
|
|
0,
|
|
this._baseMinFar,
|
|
0,
|
|
true
|
|
);
|
|
}
|
|
|
|
startSubInCenterAndRotation() {
|
|
this.startInOutAndRotation(
|
|
"inCenterAndRotation",
|
|
0,
|
|
this._baseMinFar,
|
|
this._baseMinFar,
|
|
false
|
|
);
|
|
}
|
|
|
|
startSubOutCenter() {
|
|
this.startInOut("outCenter", 0, this._baseMinFar, 0);
|
|
}
|
|
|
|
startSubInCenter() {
|
|
this.startInOut("inCenter", 0, this._baseMinFar, this._baseMinFar);
|
|
}
|
|
|
|
startInOutAndRotation(
|
|
changeState,
|
|
minFar,
|
|
maxFar,
|
|
startFar,
|
|
lastCycleSync
|
|
) {
|
|
this._state = changeState;
|
|
this._minFar = minFar;
|
|
this._maxFar = maxFar;
|
|
this._lastCycled = false;
|
|
this._lastCycleSync = lastCycleSync;
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.deg = this.calcIndexDeg(i);
|
|
sprite.far = startFar;
|
|
});
|
|
}
|
|
|
|
startInOut(changeState, minFar, maxFar, startFar) {
|
|
this._state = changeState;
|
|
this._minFar = minFar;
|
|
this._maxFar = maxFar;
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.deg = this.calcRelativeIndexDeg(i);
|
|
sprite.far = startFar;
|
|
});
|
|
}
|
|
|
|
update() {
|
|
switch (this._state) {
|
|
case "outCenterAndRotation":
|
|
this.updateOutCenterAndRotation();
|
|
break;
|
|
case "inCenterAndRotation":
|
|
this.updateInCenterAndRotation();
|
|
break;
|
|
case "outCenter":
|
|
this.updateOutCenter();
|
|
break;
|
|
case "inCenter":
|
|
this.updateInCenter();
|
|
break;
|
|
case "changeIndex":
|
|
this.updateChangeIndex();
|
|
break;
|
|
}
|
|
}
|
|
|
|
isBusy() {
|
|
return this._state != "none";
|
|
}
|
|
|
|
calcIndexDeg(index) {
|
|
const space = 360 / this._sprites.length;
|
|
const deg = space * index;
|
|
return deg;
|
|
}
|
|
|
|
calcRelativeIndexDeg(index) {
|
|
let relIndex = index - this._currentIndex;
|
|
if (relIndex >= this._sprites.length) {
|
|
relIndex = relIndex - this._sprites.length;
|
|
}
|
|
return this.calcIndexDeg(relIndex);
|
|
}
|
|
|
|
updateOutCenterAndRotation() {
|
|
if (this._baseSprite.far >= this._maxFar - this._marginFar) {
|
|
if (this._lastCycled) {
|
|
if (this._lastCycleSync) {
|
|
if (!this._baseSprite.isBusy()) {
|
|
this._state = "none";
|
|
}
|
|
} else {
|
|
this._state = "none";
|
|
}
|
|
} else {
|
|
this._lastCycled = true;
|
|
if (this._baseSprite.deg > 0) {
|
|
const rotationDeg = 360 - this._baseSprite.deg;
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.startRotation(rotationDeg);
|
|
sprite.far = this._maxFar;
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
if (!this._baseSprite.isBusy()) {
|
|
const speedPer =
|
|
(this._baseSprite.far - this._minFar) /
|
|
(this._maxFar - this._minFar);
|
|
for (const sprite of this._sprites) {
|
|
sprite.rotateSpeed =
|
|
this._baseRotateSpeed - (this._baseRotateSpeed / 2) * speedPer;
|
|
sprite.startRotation(360);
|
|
}
|
|
}
|
|
for (const sprite of this._sprites) {
|
|
if (this._baseSprite.far < this._maxFar) {
|
|
sprite.far += this._inOutSpeed;
|
|
} else {
|
|
sprite.far = this._maxFar;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
updateInCenterAndRotation() {
|
|
if (this._baseSprite.far <= this._minFar + this._marginFar) {
|
|
if (this._lastCycled) {
|
|
if (this._lastCycleSync) {
|
|
if (!this._baseSprite.isBusy()) {
|
|
this._state = "none";
|
|
}
|
|
} else {
|
|
this._state = "none";
|
|
}
|
|
} else {
|
|
this._lastCycled = true;
|
|
if (this._baseSprite.deg > 0) {
|
|
const rotationDeg = 360 - this._baseSprite.deg;
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.startRotation(rotationDeg);
|
|
sprite.far = this._minFar;
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
if (!this._baseSprite.isBusy()) {
|
|
const speedPer =
|
|
(this._baseSprite.far - this._minFar) /
|
|
(this._maxFar - this._minFar);
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.rotateSpeed =
|
|
this._baseRotateSpeed / 2 +
|
|
(this._baseRotateSpeed / 2) * speedPer;
|
|
sprite.startRotation(360);
|
|
});
|
|
}
|
|
for (const sprite of this._sprites) {
|
|
if (this._baseSprite.far > this._minFar) {
|
|
sprite.far -= this._inOutSpeed;
|
|
} else {
|
|
sprite.far = this._minFar;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
updateOutCenter() {
|
|
if (this._baseSprite.far >= this._maxFar - this._marginFar) {
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.far = this._maxFar;
|
|
});
|
|
this._state = "none";
|
|
} else {
|
|
for (const sprite of this._sprites) {
|
|
if (this._baseSprite.far < this._maxFar) {
|
|
sprite.far += this._inOutSpeed;
|
|
} else {
|
|
sprite.far = this._maxFar;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
updateInCenter() {
|
|
if (this._baseSprite.far <= this._minFar + this._marginFar) {
|
|
this._sprites.forEach((sprite, i) => {
|
|
sprite.far = this._minFar;
|
|
});
|
|
this._state = "none";
|
|
} else {
|
|
for (const sprite of this._sprites) {
|
|
if (this._baseSprite.far > this._minFar) {
|
|
sprite.far -= this._inOutSpeed;
|
|
} else {
|
|
sprite.far = this._minFar;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
startChangeNextCommand() {
|
|
if (this._sprites.length <= 1) return false;
|
|
let index = this._currentIndex + 1;
|
|
let rotationDeg;
|
|
if (index >= this._sprites.length) {
|
|
index = index - this._sprites.length;
|
|
rotationDeg = -this.calcIndexDeg(1);
|
|
} else {
|
|
rotationDeg = -this.calcRelativeIndexDeg(index);
|
|
}
|
|
this.startChangeCommand(index, rotationDeg);
|
|
return true;
|
|
}
|
|
|
|
startChangePrevCommand() {
|
|
if (this._sprites.length <= 1) return false;
|
|
let index = this._currentIndex - 1;
|
|
let rotationDeg;
|
|
if (index < 0) {
|
|
index = this._sprites.length + index;
|
|
rotationDeg = this.calcIndexDeg(1);
|
|
} else {
|
|
rotationDeg = -this.calcRelativeIndexDeg(index);
|
|
}
|
|
this.startChangeCommand(index, rotationDeg);
|
|
return true;
|
|
}
|
|
|
|
startChangeCommand(targetIndex, rotationDeg) {
|
|
this._baseSprite = this._sprites[this._currentIndex];
|
|
for (const sprite of this._sprites) {
|
|
sprite.rotateSpeed = this._baseRotateSpeed;
|
|
sprite.startRotation(rotationDeg);
|
|
}
|
|
this._currentIndex = targetIndex;
|
|
this._state = "changeIndex";
|
|
}
|
|
|
|
updateChangeIndex() {
|
|
const busySprite = this._sprites.find((sprite) => sprite.isBusy());
|
|
if (!busySprite) {
|
|
this._state = "none";
|
|
}
|
|
}
|
|
}
|
|
|
|
class Sprite_RingCommandLabel extends SpriteMVMZ {
|
|
static get LABEL_WIDTH() {
|
|
return 120;
|
|
}
|
|
static get LABEL_HEIGHT() {
|
|
return 32;
|
|
}
|
|
|
|
initialize() {
|
|
super.initialize();
|
|
this.x = 0;
|
|
this.y = 0;
|
|
this.bitmap = new Bitmap(
|
|
Sprite_RingCommandLabel.LABEL_WIDTH,
|
|
Sprite_RingCommandLabel.LABEL_HEIGHT
|
|
);
|
|
if (Utils.RPGMAKER_NAME === "MZ") {
|
|
this.bitmap.fontFace = $gameSystem.mainFontFace();
|
|
}
|
|
this.bitmap.fontSize = 24;
|
|
this._labelWidth = 0;
|
|
this.hide();
|
|
}
|
|
|
|
setLabel(labelText) {
|
|
this._labelWidth = this.bitmap.measureTextWidth(labelText);
|
|
this.bitmap.clear();
|
|
this.bitmap.drawText(labelText, 0, 0, this.width, this.height, "left");
|
|
}
|
|
|
|
labelWidth() {
|
|
return this._labelWidth;
|
|
}
|
|
}
|
|
|
|
class Sprite_RingCommandCursor extends SpriteMVMZ {
|
|
static get PADDING() {
|
|
return 4;
|
|
}
|
|
|
|
initialize(ringCommandSpriteWidth, ringCommandSpriteHeight) {
|
|
super.initialize();
|
|
this._createCursorSprite();
|
|
const cursorWidth =
|
|
ringCommandSpriteWidth + Sprite_RingCommandCursor.PADDING * 2;
|
|
const cursorHeight =
|
|
ringCommandSpriteHeight + Sprite_RingCommandCursor.PADDING * 2;
|
|
this._cursorRect = new Rectangle(0, 0, cursorWidth, cursorHeight);
|
|
this.contentsOpacity = 255;
|
|
this.cursorVisible = true;
|
|
this.active = true;
|
|
this._animationCount = 0;
|
|
this._refreshCursor();
|
|
this.loadWindowskin();
|
|
this.hide();
|
|
}
|
|
|
|
update() {
|
|
super.update();
|
|
if (this.visible) {
|
|
this._animationCount++;
|
|
this._updateCursor();
|
|
}
|
|
}
|
|
|
|
show() {
|
|
super.show();
|
|
for (const child of this.children) {
|
|
child.show();
|
|
}
|
|
}
|
|
|
|
hide() {
|
|
super.hide();
|
|
for (const child of this.children) {
|
|
child.hide();
|
|
}
|
|
}
|
|
|
|
loadWindowskin() {
|
|
this._windowskin = ImageManager.loadSystem("Window");
|
|
this._windowskin.addLoadListener(this._onWindowskinLoad.bind(this));
|
|
}
|
|
|
|
_onWindowskinLoad() {
|
|
this._refreshCursor();
|
|
}
|
|
|
|
_createCursorSprite() {
|
|
for (let i = 0; i < 9; i++) {
|
|
this.addChild(new SpriteMVMZ());
|
|
}
|
|
}
|
|
|
|
_refreshCursor() {
|
|
const drect = this._cursorRect.clone();
|
|
const srect = { x: 96, y: 96, width: 32, height: 32 };
|
|
const m = 4;
|
|
for (const child of this.children) {
|
|
child.bitmap = this._windowskin;
|
|
}
|
|
this._setRectPartsGeometry(this, srect, drect, m);
|
|
}
|
|
|
|
_setRectPartsGeometry(sprite, srect, drect, m) {
|
|
const sx = srect.x;
|
|
const sy = srect.y;
|
|
const sw = srect.width;
|
|
const sh = srect.height;
|
|
const dx = drect.x;
|
|
const dy = drect.y;
|
|
const dw = drect.width;
|
|
const dh = drect.height;
|
|
const smw = sw - m * 2;
|
|
const smh = sh - m * 2;
|
|
const dmw = dw - m * 2;
|
|
const dmh = dh - m * 2;
|
|
const children = sprite.children;
|
|
sprite.setFrame(0, 0, dw, dh);
|
|
sprite.move(dx, dy);
|
|
// corner
|
|
children[0].setFrame(sx, sy, m, m);
|
|
children[1].setFrame(sx + sw - m, sy, m, m);
|
|
children[2].setFrame(sx, sy + sw - m, m, m);
|
|
children[3].setFrame(sx + sw - m, sy + sw - m, m, m);
|
|
children[0].move(0, 0);
|
|
children[1].move(dw - m, 0);
|
|
children[2].move(0, dh - m);
|
|
children[3].move(dw - m, dh - m);
|
|
// edge
|
|
children[4].move(m, 0);
|
|
children[5].move(m, dh - m);
|
|
children[6].move(0, m);
|
|
children[7].move(dw - m, m);
|
|
children[4].setFrame(sx + m, sy, smw, m);
|
|
children[5].setFrame(sx + m, sy + sw - m, smw, m);
|
|
children[6].setFrame(sx, sy + m, m, smh);
|
|
children[7].setFrame(sx + sw - m, sy + m, m, smh);
|
|
children[4].scale.x = dmw / smw;
|
|
children[5].scale.x = dmw / smw;
|
|
children[6].scale.y = dmh / smh;
|
|
children[7].scale.y = dmh / smh;
|
|
// center
|
|
if (children[8]) {
|
|
children[8].setFrame(sx + m, sy + m, smw, smh);
|
|
children[8].move(m, m);
|
|
children[8].scale.x = dmw / smw;
|
|
children[8].scale.y = dmh / smh;
|
|
}
|
|
for (const child of children) {
|
|
child.visible = dw > 0 && dh > 0;
|
|
}
|
|
}
|
|
|
|
_updateCursor() {
|
|
this.alpha = this._makeCursorAlpha();
|
|
this.visible = this.cursorVisible;
|
|
this._cursorRect.x = this.x;
|
|
this._cursorRect.y = this.y;
|
|
}
|
|
|
|
_makeCursorAlpha() {
|
|
const blinkCount = this._animationCount % 40;
|
|
const baseAlpha = this.contentsOpacity / 255;
|
|
if (this.active) {
|
|
if (blinkCount < 20) {
|
|
return baseAlpha - blinkCount / 32;
|
|
} else {
|
|
return baseAlpha - (40 - blinkCount) / 32;
|
|
}
|
|
}
|
|
return baseAlpha;
|
|
}
|
|
}
|
|
|
|
class RingCommandDataStatus {
|
|
constructor(...args) {
|
|
this.initialize(...args);
|
|
}
|
|
|
|
initialize(datas) {
|
|
this._datas = datas;
|
|
this._index = 0;
|
|
}
|
|
|
|
datas() {
|
|
return this._datas;
|
|
}
|
|
|
|
index() {
|
|
return this._index;
|
|
}
|
|
|
|
setIndex(index) {
|
|
this._index = index;
|
|
}
|
|
|
|
currentData() {
|
|
return this._datas[this._index];
|
|
}
|
|
|
|
next() {
|
|
if (this._index >= this._datas.length - 1) {
|
|
this._index = 0;
|
|
} else {
|
|
this._index++;
|
|
}
|
|
}
|
|
|
|
prev() {
|
|
if (this._index <= 0) {
|
|
this._index = this._datas.length - 1;
|
|
} else {
|
|
this._index--;
|
|
}
|
|
}
|
|
|
|
getDataIndex(data) {
|
|
if (data.commandType === "actorData") {
|
|
return data.internalIndex;
|
|
} else {
|
|
return this._datas.indexOf(data);
|
|
}
|
|
}
|
|
}
|
|
|
|
class CommonEventRunner {
|
|
constructor(...args) {
|
|
this.initialize(...args);
|
|
}
|
|
|
|
initialize(opt = { startEventCallback: null, endEventCallback: null }) {
|
|
this._startEventCallback = opt.startEventCallback;
|
|
this._endEventCallback = opt.endEventCallback;
|
|
this._interpreter = new Game_Interpreter();
|
|
this._eventState = "none";
|
|
}
|
|
|
|
update() {
|
|
if (this._eventState === "start") {
|
|
if (this._startEventCallback) this._startEventCallback();
|
|
this._eventState = "running";
|
|
} else if (this._eventState === "running") {
|
|
if (this._interpreter.isRunning()) this._interpreter.update();
|
|
if (!this._interpreter.isRunning() && !$gameMessage.isBusy())
|
|
this._eventState = "end";
|
|
} else if (this._eventState === "end") {
|
|
this._eventState = "none";
|
|
this._interpreter.clear();
|
|
if (this._endEventCallback) this._endEventCallback();
|
|
}
|
|
}
|
|
|
|
isEventRunning() {
|
|
return this._eventState !== "none";
|
|
}
|
|
|
|
startCommonEvent(commonEventId) {
|
|
// If commonEventId is undefined, do not start common event.
|
|
if (!commonEventId || commonEventId === 0) return;
|
|
const commonEventData = $dataCommonEvents[commonEventId];
|
|
this._interpreter.setup(commonEventData.list);
|
|
this._eventState = "start";
|
|
}
|
|
}
|
|
|
|
class RingCommandManager {
|
|
constructor(...args) {
|
|
this.initialize(...args);
|
|
}
|
|
|
|
initialize() {
|
|
this._cursorMoveFrame = 0;
|
|
this._maxCursorMoveFrame = 8;
|
|
this._holdDataStatus = [];
|
|
}
|
|
|
|
hasHoldDatas() {
|
|
return this._holdDataStatus.length > 0;
|
|
}
|
|
|
|
addDatas(datas) {
|
|
this._holdDataStatus.push(new RingCommandDataStatus(datas, 0));
|
|
}
|
|
|
|
backDatas() {
|
|
this._holdDataStatus.pop();
|
|
}
|
|
|
|
lastDataStatus() {
|
|
return this._holdDataStatus[this._holdDataStatus.length - 1];
|
|
}
|
|
|
|
update() {
|
|
if (this._cursorMoveFrame > 0) this._cursorMoveFrame--;
|
|
}
|
|
|
|
execCommand(data) {
|
|
const commandType = data.commandType;
|
|
switch (commandType) {
|
|
case "actorData":
|
|
const actor = $gameParty.members()[data.internalIndex];
|
|
$gameParty.setMenuActor(actor);
|
|
const subjectData =
|
|
this._holdDataStatus[this._holdDataStatus.length - 2].currentData();
|
|
this.evaluateData(subjectData);
|
|
break;
|
|
case "normal":
|
|
case "script":
|
|
case "commonEvent":
|
|
this.evaluateData(data);
|
|
break;
|
|
case "selectActor":
|
|
if (RingCommandUtils.needSkipActorSelect()) {
|
|
const actor = $gameParty.members()[0];
|
|
$gameParty.setMenuActor(actor);
|
|
this.evaluateData(data);
|
|
}
|
|
break;
|
|
}
|
|
return commandType;
|
|
}
|
|
|
|
evaluateData(data) {
|
|
if (data.isEnabled()) {
|
|
switch (data.commandType) {
|
|
case "normal":
|
|
case "script":
|
|
case "selectActor":
|
|
eval(data.script);
|
|
break;
|
|
case "commonEvent":
|
|
$gameTemp
|
|
.ringCommandCommonEventRunner()
|
|
.startCommonEvent(data.commonEventId);
|
|
break;
|
|
default:
|
|
throw new Error(
|
|
`CommandType: ${data.commandType} cannot evaluate.`
|
|
);
|
|
}
|
|
} else {
|
|
SoundManager.playBuzzer();
|
|
}
|
|
}
|
|
|
|
inputCancelKey() {
|
|
this.backDatas();
|
|
}
|
|
|
|
inputLeftKey() {
|
|
if (this._cursorMoveFrame === 0) {
|
|
this._cursorMoveFrame = this._maxCursorMoveFrame;
|
|
this.lastDataStatus().next();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inputRightKey() {
|
|
if (this._cursorMoveFrame === 0) {
|
|
this._cursorMoveFrame = this._maxCursorMoveFrame;
|
|
this.lastDataStatus().prev();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inputOkKey() {
|
|
return this.execCommand(this.currentData());
|
|
}
|
|
|
|
datas() {
|
|
return this.lastDataStatus().datas();
|
|
}
|
|
|
|
index() {
|
|
return this.lastDataStatus().index();
|
|
}
|
|
|
|
currentData() {
|
|
return this.lastDataStatus().currentData();
|
|
}
|
|
|
|
getRingCommandSpriteIndex(sprite) {
|
|
return this.lastDataStatus().getDataIndex(sprite.data);
|
|
}
|
|
|
|
changeIndex(index) {
|
|
this.lastDataStatus().setIndex(index);
|
|
}
|
|
}
|
|
|
|
Scene_Map.prototype.callMenu = function () {
|
|
SceneManager.push(Scene_RingCommandMenu);
|
|
$gameTemp.clearDestination();
|
|
this._mapNameWindow.hide();
|
|
this._waitCount = 2;
|
|
};
|
|
|
|
class Scene_RingCommandMenu extends Scene_MenuBase {
|
|
create() {
|
|
this._spriteset = new Spriteset_RingCommandMenu();
|
|
this.addChild(this._spriteset);
|
|
super.create();
|
|
this._spriteset.setBackground(this._backgroundSprite);
|
|
this._ringCommandMenuState = "none";
|
|
this._needLabelUpdate = true;
|
|
this._holdClickRotationSprite = null;
|
|
this._preloadingImageObjects = [];
|
|
|
|
const mouseEnterCbk = this.ringCommandSpriteMouseEnterCbk.bind(this);
|
|
const mouseExitCbk = this.ringCommandSpriteMouseExitCbk.bind(this);
|
|
const clickCbk = this.ringCommandSpriteClickCbk.bind(this);
|
|
this._spriteset.addRingCommandSpriteCallback(
|
|
"mouseEnterCbk",
|
|
mouseEnterCbk
|
|
);
|
|
this._spriteset.addRingCommandSpriteCallback(
|
|
"mouseExitCbk",
|
|
mouseExitCbk
|
|
);
|
|
this._spriteset.addRingCommandSpriteCallback("clickCbk", clickCbk);
|
|
|
|
if (!$gameTemp.ringCommandManager()) {
|
|
const ringCommandManager = new RingCommandManager();
|
|
$gameTemp.setRingCommandManager(ringCommandManager);
|
|
}
|
|
if (!$gameTemp.ringCommandCommonEventRunner()) {
|
|
const commonEventRunner = new CommonEventRunner();
|
|
$gameTemp.setRingCommandCommonEventRunner(commonEventRunner);
|
|
}
|
|
|
|
this.preloadImages();
|
|
}
|
|
|
|
createBackground() {
|
|
this._backgroundFilter = new PIXI.filters.BlurFilter();
|
|
this._backgroundSprite = new SpriteMVMZ();
|
|
this._backgroundSprite.bitmap = SceneManager.backgroundBitmap();
|
|
const backGroundOpacity =
|
|
PP.BackGroundOpacity == null ? 192 : PP.BackGroundOpacity;
|
|
this.setBackgroundOpacity(backGroundOpacity);
|
|
}
|
|
|
|
isReady() {
|
|
const result = super.isReady();
|
|
if (!result) return false;
|
|
for (const img of this._preloadingImageObjects) {
|
|
if (!img.isReady()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
preloadImages() {
|
|
for (const data of $ringCommnadDatas) {
|
|
this._preloadingImageObjects.push(ImageManager.loadPicture(data.image));
|
|
if (data.subCommands) {
|
|
for (const subData of data.subCommands) {
|
|
this._preloadingImageObjects.push(
|
|
ImageManager.loadPicture(subData.image)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
start() {
|
|
super.start();
|
|
this.startRingCommandMenu();
|
|
}
|
|
|
|
isBusy() {
|
|
if (this._ringCommandMenuState === "active")
|
|
return this._spriteset.isRingCommandControllerBusy();
|
|
return false;
|
|
}
|
|
|
|
startRingCommandMenu() {
|
|
if ($gameTemp.ringCommandManager().hasHoldDatas()) {
|
|
this._ringCommandMenuState = "restart";
|
|
} else {
|
|
$gameTemp.ringCommandManager().addDatas($ringCommnadDatas);
|
|
this._ringCommandMenuState = "start";
|
|
}
|
|
}
|
|
|
|
update() {
|
|
super.update();
|
|
$gameTemp.ringCommandCommonEventRunner().update();
|
|
this.updateCancelButton();
|
|
this.updateRingCommand();
|
|
}
|
|
|
|
updateCancelButton() {
|
|
if (Utils.RPGMAKER_NAME === "MZ") {
|
|
if (this._cancelButton) {
|
|
this._cancelButton.visible = this._ringCommandMenuState === "active";
|
|
}
|
|
}
|
|
}
|
|
|
|
createRingCommnadActorDatas() {
|
|
return $gameParty.members().map(this.createRingiCommandActorData);
|
|
}
|
|
|
|
createRingiCommandActorData(actor, index) {
|
|
let actorImageName = "";
|
|
if (PP.SelectActorCommands) {
|
|
for (const selectActorCommand of PP.SelectActorCommands) {
|
|
if (selectActorCommand.ActorId === actor.actorId()) {
|
|
actorImageName = selectActorCommand.Image;
|
|
}
|
|
}
|
|
}
|
|
return new RingCommandData(
|
|
"actorData",
|
|
actor.name(),
|
|
0,
|
|
actorImageName,
|
|
"",
|
|
null,
|
|
0,
|
|
index
|
|
);
|
|
}
|
|
|
|
updateRingCommand() {
|
|
if (this._spriteset.isRingCommandControllerBusy()) return;
|
|
if ($gameTemp.ringCommandCommonEventRunner().isEventRunning()) return;
|
|
this._waitCount--;
|
|
if (this._waitCount > 0) return;
|
|
if (this._ringCommandMenuState === "start") {
|
|
this.processStart(false);
|
|
} else if (this._ringCommandMenuState === "restart") {
|
|
this.processStart(true);
|
|
} else if (this._ringCommandMenuState === "active") {
|
|
this.processActive();
|
|
} else if (this._ringCommandMenuState == "closing") {
|
|
this.processClosing();
|
|
} else if (this._ringCommandMenuState === "transition") {
|
|
this.processTransition();
|
|
} else if (this._ringCommandMenuState === "clickRotation") {
|
|
this.processClickRotation();
|
|
}
|
|
}
|
|
|
|
processStart(isRestart) {
|
|
this._spriteset.createRingCommandSprites(
|
|
$gameTemp.ringCommandManager().datas()
|
|
);
|
|
this._spriteset.ringCommandShow();
|
|
if (isRestart) {
|
|
this.playSubOpenSe();
|
|
this._spriteset.ringCommandSubStart();
|
|
} else {
|
|
this.playOpenSe();
|
|
this._spriteset.ringCommandStart();
|
|
}
|
|
this._ringCommandMenuState = "active";
|
|
}
|
|
|
|
processActive() {
|
|
$gameTemp.ringCommandManager().update();
|
|
if (this._needLabelUpdate) {
|
|
const label = $gameTemp.ringCommandManager().currentData().text;
|
|
this._spriteset.ringCommandShowLabel(label);
|
|
const index = $gameTemp.ringCommandManager().index();
|
|
this._spriteset.ringCommandShowCursor(index);
|
|
this._needLabelUpdate = false;
|
|
}
|
|
if (TouchInput.isCancelled()) {
|
|
this.inputCancelKey();
|
|
}
|
|
if (Input.isTriggered("cancel")) {
|
|
this.inputCancelKey();
|
|
} else if (Input.isPressed("left")) {
|
|
this.inputLeftKey();
|
|
} else if (Input.isPressed("right")) {
|
|
this.inputRightKey();
|
|
} else if (Input.isTriggered("ok")) {
|
|
this.inputOkKey();
|
|
}
|
|
}
|
|
|
|
inputOkKey() {
|
|
const execCommandType = $gameTemp.ringCommandManager().inputOkKey();
|
|
this.postExecCommand(execCommandType);
|
|
}
|
|
|
|
inputCancelKey() {
|
|
$gameTemp.ringCommandManager().inputCancelKey();
|
|
if ($gameTemp.ringCommandManager().hasHoldDatas()) {
|
|
this.playSubCloseSe();
|
|
this._spriteset.ringCommandSubEnd();
|
|
this._spriteset.ringCommandHideLabel();
|
|
this._spriteset.ringCommandHideCursor();
|
|
this._ringCommandMenuState = "transition";
|
|
} else {
|
|
this.playCloseSe();
|
|
this._spriteset.ringCommandHideLabel();
|
|
this._spriteset.ringCommandHideCursor();
|
|
this._spriteset.ringCommandEnd();
|
|
this._ringCommandMenuState = "closing";
|
|
}
|
|
}
|
|
|
|
inputLeftKey() {
|
|
let changed = $gameTemp.ringCommandManager().inputLeftKey();
|
|
if (changed) {
|
|
changed = this._spriteset.ringCommandNext();
|
|
}
|
|
if (changed) {
|
|
SoundManager.playCursor();
|
|
this._needLabelUpdate = true;
|
|
}
|
|
}
|
|
|
|
inputRightKey() {
|
|
let changed = $gameTemp.ringCommandManager().inputRightKey();
|
|
if (changed) {
|
|
changed = this._spriteset.ringCommandPrev();
|
|
}
|
|
if (changed) {
|
|
SoundManager.playCursor();
|
|
this._needLabelUpdate = true;
|
|
}
|
|
}
|
|
|
|
processClosing() {
|
|
this._ringCommandMenuState = "none";
|
|
this._spriteset.ringCommandHide();
|
|
this._spriteset.disposeRingCommandSprites();
|
|
this.popScene();
|
|
}
|
|
|
|
processTransition() {
|
|
this._ringCommandMenuState = "active";
|
|
this._needLabelUpdate = true;
|
|
this._spriteset.disposeRingCommandSprites();
|
|
this._spriteset.createRingCommandSprites(
|
|
$gameTemp.ringCommandManager().datas()
|
|
);
|
|
this._spriteset.ringCommandShow();
|
|
this._spriteset.ringCommandSubStart();
|
|
}
|
|
|
|
processClickRotation() {
|
|
this._ringCommandMenuState = "active";
|
|
const index = $gameTemp
|
|
.ringCommandManager()
|
|
.getRingCommandSpriteIndex(this._holdClickRotationSprite);
|
|
$gameTemp.ringCommandManager().changeIndex(index);
|
|
const execCommandType = $gameTemp
|
|
.ringCommandManager()
|
|
.execCommand(this._holdClickRotationSprite.data);
|
|
this.postExecCommand(execCommandType);
|
|
}
|
|
|
|
postExecCommand(execCommandType) {
|
|
let datas = null;
|
|
switch (execCommandType) {
|
|
case "selectActor":
|
|
if (!RingCommandUtils.needSkipActorSelect()) {
|
|
datas = this.createRingCommnadActorDatas();
|
|
}
|
|
break;
|
|
case "subMenu":
|
|
datas = $gameTemp.ringCommandManager().currentData().subCommands;
|
|
break;
|
|
}
|
|
if (datas) {
|
|
this.playSubOpenSe();
|
|
this._spriteset.ringCommandSubEnd();
|
|
this._spriteset.ringCommandHideLabel();
|
|
this._spriteset.ringCommandHideCursor();
|
|
$gameTemp.ringCommandManager().addDatas(datas);
|
|
this._ringCommandMenuState = "transition";
|
|
}
|
|
}
|
|
|
|
playOpenSe() {
|
|
const se = {
|
|
name: PP.OpenSe.FileName,
|
|
pan: parseInt(PP.OpenSe.Pan),
|
|
pitch: parseInt(PP.OpenSe.Pitch),
|
|
volume: parseInt(PP.OpenSe.Volume),
|
|
};
|
|
AudioManager.playSe(se);
|
|
}
|
|
|
|
playCloseSe() {
|
|
const se = {
|
|
name: PP.CloseSe.FileName,
|
|
pan: parseInt(PP.CloseSe.Pan),
|
|
pitch: parseInt(PP.CloseSe.Pitch),
|
|
volume: parseInt(PP.CloseSe.Volume),
|
|
};
|
|
AudioManager.playSe(se);
|
|
}
|
|
|
|
playSubOpenSe() {
|
|
const se = {
|
|
name: PP.SubOpenSe.FileName,
|
|
pan: parseInt(PP.SubOpenSe.Pan),
|
|
pitch: parseInt(PP.SubOpenSe.Pitch),
|
|
volume: parseInt(PP.SubOpenSe.Volume),
|
|
};
|
|
AudioManager.playSe(se);
|
|
}
|
|
|
|
playSubCloseSe() {
|
|
const se = {
|
|
name: PP.SubCloseSe.FileName,
|
|
pan: parseInt(PP.SubCloseSe.Pan),
|
|
pitch: parseInt(PP.SubCloseSe.Pitch),
|
|
volume: parseInt(PP.SubCloseSe.Volume),
|
|
};
|
|
AudioManager.playSe(se);
|
|
}
|
|
|
|
ringCommandSpriteMouseEnterCbk(sprite) {
|
|
if (this._ringCommandMenuState === "active") {
|
|
const index = $gameTemp
|
|
.ringCommandManager()
|
|
.getRingCommandSpriteIndex(sprite);
|
|
this._spriteset.ringCommandShowCursor(index);
|
|
this._spriteset.ringCommandShowLabel(sprite.data.text);
|
|
}
|
|
}
|
|
|
|
ringCommandSpriteMouseExitCbk(sprite) {
|
|
if (this._ringCommandMenuState === "active") {
|
|
const index = $gameTemp.ringCommandManager().index();
|
|
this._spriteset.ringCommandShowCursor(index);
|
|
this._spriteset.ringCommandShowLabel(
|
|
$gameTemp.ringCommandManager().currentData().text
|
|
);
|
|
}
|
|
}
|
|
|
|
ringCommandSpriteClickCbk(sprite) {
|
|
if (this._ringCommandMenuState === "active") {
|
|
this.waitStart(10);
|
|
this._holdClickRotationSprite = sprite;
|
|
this._ringCommandMenuState = "clickRotation";
|
|
const index = $gameTemp
|
|
.ringCommandManager()
|
|
.getRingCommandSpriteIndex(sprite);
|
|
this._spriteset.ringCommandChange(index);
|
|
this._spriteset.ringCommandShowCursor(
|
|
$gameTemp.ringCommandManager().index()
|
|
);
|
|
}
|
|
}
|
|
|
|
waitStart(waitCount) {
|
|
this._waitCount = waitCount;
|
|
}
|
|
}
|
|
|
|
class Spriteset_RingCommandMenu extends Spriteset_Base {
|
|
initialize() {
|
|
super.initialize();
|
|
this._ringCommandSpriteController = new RingCommandSpriteController();
|
|
this._ringCommandSpriteCallbacks = {};
|
|
}
|
|
|
|
update() {
|
|
super.update();
|
|
if (this._ringCommandSpriteController)
|
|
this._ringCommandSpriteController.update();
|
|
}
|
|
|
|
createUpperLayer() {
|
|
super.createUpperLayer();
|
|
this.createUpperLayerBaseSprite();
|
|
}
|
|
|
|
createUpperLayerBaseSprite() {
|
|
this._upperLayerBaseSprite = new Sprite();
|
|
this.addChild(this._upperLayerBaseSprite);
|
|
}
|
|
|
|
ringCommandCenterX() {
|
|
return $gamePlayer.screenX() * 1.4;
|
|
}
|
|
|
|
ringCommandCenterY() {
|
|
return $gamePlayer.screenY() * 1.4 - 30;
|
|
}
|
|
|
|
setBackground(background) {
|
|
this._baseSprite.addChild(background);
|
|
}
|
|
|
|
addRingCommandSpriteCallback(name, cbk) {
|
|
this._ringCommandSpriteCallbacks[name] = cbk;
|
|
}
|
|
|
|
createRingCommandSprites(datas) {
|
|
this._ringCommandSprites = [];
|
|
for (const data of datas) {
|
|
const sprite = new Sprite_RingCommand(
|
|
0,
|
|
0,
|
|
data,
|
|
this._ringCommandSpriteCallbacks
|
|
);
|
|
this._ringCommandSprites.push(sprite);
|
|
this._upperLayerBaseSprite.addChild(sprite);
|
|
}
|
|
this._ringCommandLabel = new Sprite_RingCommandLabel();
|
|
const baseRingCommandSprite = this._ringCommandSprites[0];
|
|
this._ringCommandCursor = new Sprite_RingCommandCursor(
|
|
baseRingCommandSprite.width,
|
|
baseRingCommandSprite.height
|
|
);
|
|
this._upperLayerBaseSprite.addChild(this._ringCommandLabel);
|
|
this._upperLayerBaseSprite.addChild(this._ringCommandCursor);
|
|
}
|
|
|
|
disposeRingCommandSprites() {
|
|
for (const sprite of this._ringCommandSprites) {
|
|
this._upperLayerBaseSprite.removeChild(sprite);
|
|
}
|
|
this._upperLayerBaseSprite.removeChild(this._ringCommandLabel);
|
|
this._upperLayerBaseSprite.removeChild(this._ringCommandCursor);
|
|
this._ringCommandSprites = [];
|
|
this._ringCommandLabel = null;
|
|
this._ringCommandCursor = null;
|
|
}
|
|
|
|
ringCommandShowLabel(label) {
|
|
this._ringCommandLabel.setLabel(label);
|
|
const baseRingCommandSprite = this._ringCommandSprites[0];
|
|
const ofsX = -this._ringCommandLabel.labelWidth() / 2;
|
|
const ofsY =
|
|
RING_COMMAND_OFFSET_Y -
|
|
baseRingCommandSprite.height -
|
|
baseRingCommandSprite.far;
|
|
const x = this.ringCommandCenterX() + ofsX;
|
|
const y = this.ringCommandCenterY() + ofsY;
|
|
this._ringCommandLabel.x = x;
|
|
this._ringCommandLabel.y = y;
|
|
this._ringCommandLabel.show();
|
|
}
|
|
|
|
ringCommandHideLabel() {
|
|
this._ringCommandLabel.hide();
|
|
}
|
|
|
|
ringCommandShowCursor(index) {
|
|
const sprite = this._ringCommandSprites[index];
|
|
this._ringCommandCursor.x = sprite.x - Sprite_RingCommandCursor.PADDING;
|
|
this._ringCommandCursor.y = sprite.y - Sprite_RingCommandCursor.PADDING;
|
|
this._ringCommandCursor.show();
|
|
}
|
|
|
|
ringCommandHideCursor() {
|
|
this._ringCommandCursor.hide();
|
|
}
|
|
|
|
isRingCommandControllerBusy() {
|
|
return this._ringCommandSpriteController.isBusy();
|
|
}
|
|
|
|
ringCommandShow() {
|
|
const baseRingCommandSprite = this._ringCommandSprites[0];
|
|
const ofsX = -baseRingCommandSprite.width / 2;
|
|
const ofsY = RING_COMMAND_OFFSET_Y;
|
|
const x = this.ringCommandCenterX() + ofsX;
|
|
const y = this.ringCommandCenterY() + ofsY;
|
|
for (const sprite of this._ringCommandSprites) {
|
|
sprite.homeX = x;
|
|
sprite.homeY = y;
|
|
sprite.show();
|
|
}
|
|
}
|
|
|
|
ringCommandStart() {
|
|
this._ringCommandSpriteController.reset(this._ringCommandSprites, 0);
|
|
this._ringCommandSpriteController.startInCenterAndRotation();
|
|
}
|
|
|
|
ringCommandSubStart() {
|
|
const index = $gameTemp.ringCommandManager().index();
|
|
this._ringCommandSpriteController.reset(this._ringCommandSprites, index);
|
|
if (PP.EnableSubCommandRotation) {
|
|
this._ringCommandSpriteController.startSubOutCenterAndRotation();
|
|
} else {
|
|
this._ringCommandSpriteController.startSubOutCenter();
|
|
}
|
|
}
|
|
|
|
ringCommandSubEnd() {
|
|
if (PP.EnableSubCommandRotation) {
|
|
this._ringCommandSpriteController.startSubInCenterAndRotation();
|
|
} else {
|
|
this._ringCommandSpriteController.startSubInCenter();
|
|
}
|
|
}
|
|
|
|
ringCommandHide() {
|
|
for (const sprite of this._ringCommandSprites) {
|
|
sprite.hide();
|
|
}
|
|
}
|
|
|
|
ringCommandEnd() {
|
|
this._ringCommandSpriteController.startOutCenterAndRotation();
|
|
}
|
|
|
|
ringCommandNext() {
|
|
return this._ringCommandSpriteController.startChangeNextCommand();
|
|
}
|
|
|
|
ringCommandPrev() {
|
|
return this._ringCommandSpriteController.startChangePrevCommand();
|
|
}
|
|
|
|
ringCommandChange(targetIndex) {
|
|
let rotationDeg =
|
|
this._ringCommandSpriteController.calcRelativeIndexDeg(targetIndex);
|
|
const sign = rotationDeg >= 0 ? 1 : -1;
|
|
rotationDeg = Math.abs(rotationDeg);
|
|
if (rotationDeg > 0) {
|
|
if (rotationDeg >= 180) {
|
|
rotationDeg = 360 - rotationDeg;
|
|
} else {
|
|
rotationDeg = -rotationDeg;
|
|
}
|
|
}
|
|
this._ringCommandSpriteController.startChangeCommand(
|
|
targetIndex,
|
|
rotationDeg * sign
|
|
);
|
|
}
|
|
}
|
|
|
|
return {
|
|
RingCommandData,
|
|
Sprite_RingCommand,
|
|
RingCommandSpriteController,
|
|
Sprite_RingCommandLabel,
|
|
Sprite_RingCommandCursor,
|
|
RingCommandDataStatus,
|
|
RingCommandManager,
|
|
CommonEventRunner,
|
|
Scene_RingCommandMenu,
|
|
Spriteset_RingCommandMenu,
|
|
};
|
|
})();
|