4262 lines
139 KiB
JavaScript
4262 lines
139 KiB
JavaScript
/*:-----------------------------------------------------------------------------------
|
||
* NUUN_BattleStyleEX.js
|
||
*
|
||
* Copyright (C) 2022 NUUN
|
||
* This software is released under the MIT License.
|
||
* http://opensource.org/licenses/mit-license.php
|
||
* -------------------------------------------------------------------------------------
|
||
*/
|
||
/*:
|
||
* @target MZ
|
||
* @plugindesc バトルスタイル拡張
|
||
* @author NUUN
|
||
* @version 3.7.4
|
||
* @base NUUN_Base
|
||
* @orderAfter NUUN_Base
|
||
* @orderAfter NUUN_ActorPicture
|
||
*
|
||
* @help
|
||
* バトルスタイル拡張プラグインのベースプラグインです。単体では動作しません。
|
||
*
|
||
* 更新履歴
|
||
* 2022/9/17 Ver.1.7.4
|
||
* 敵対象選択画面のモンスター名の表示をアクター名と同じ仕様にする機能を追加。
|
||
* 2022/9/10 Ver.3.7.3
|
||
* TPBバトルでサポートアクターが最初にコマンド選択するときにパーティコマンドが２回表示されてしまう問題を修正。
|
||
* 2022/9/10 Ver.3.7.2
|
||
* 画面サイズとUIサイズが異なるときにアクターコマンドの表示位置をactorに設定したときに、コマンドの表示がずれる問題を修正。
|
||
* 2022/9/3 Ver.3.7.1
|
||
* 外部プラグインでサイドビューアクターを表示すると正常に表示されない問題を修正。
|
||
* 2022/8/25 Ver.3.7.0
|
||
* アクター画像変化条件に防御時、反撃時、魔法反射時を追加。
|
||
* アクターコマンド可変表示時にアクターコマンドの表示がおかしくなる問題を修正。
|
||
* 2022/8/24 Ver.3.6.9
|
||
* アクターウィンドウのX座標を変更したときに、アクターコマンドがアクターの上指定時にコマンドウィンドウがずれて表示されてしまう問題を修正。
|
||
* アクターウィンドウの横幅指定時にアクターウィンドウが表示されない問題を修正。
|
||
* サイドビューアクターが表示されない問題を修正。
|
||
* 2022/8/7 Ver.3.6.8
|
||
* ステート2の表示ステートアイコンが適用されなかった問題を修正。
|
||
* 2022/8/7 Ver.3.6.7
|
||
* アニメーションの座標が適用されない問題を修正。
|
||
* 戦闘終了時にチラつく問題を修正。
|
||
* 2022/8/6 Ver.3.6.6
|
||
* 旧方式で戦闘を開始するとエラーが出る問題を修正。
|
||
* サイドビューでアクターが表示されなくなる問題を修正。
|
||
* 2022/8/6 Ver.3.6.5
|
||
* 戦闘以外でステートアイコンを表示する処理を行うとエラーが出る問題を修正。
|
||
* 可変表示をOFFにするとゲージの長さが適用されない問題を修正。
|
||
* 2022/8/6 Ver.3.6.4
|
||
* バフアイコン表示指定時のバフアイコンの２段階目のアイコンが表示されてしまう問題を修正。(現状２段階まで)
|
||
* 旧モードで設定した状態で戦闘を行うとエラーが出る問題を修正。
|
||
* 2022/8/6 Ver.3.6.3
|
||
* 表示するステートアイコン指定時にアイコンが正常に表示されない問題を修正。
|
||
* 2022/8/6 Ver.3.6.2
|
||
* ステート2が正常に表示されない問題を修正。
|
||
* スピードスターバトルと併用するとアニメーションの座標が正しく表示されない問題を修正。
|
||
* 2022/7/31 Ver.3.6.1
|
||
* アクター表示範囲可変表示の時にゲージ、名前が表示範囲内に収まるように修正。
|
||
* 2022/7/30 Ver.3.6.0
|
||
* ステータスが表示されるウィンドウに表示するステータスをウィンドウ外にも表示できるように変更。
|
||
* 表示ステータスに画像を表示できる機能を追加。
|
||
* 表示ステータスにメニューで表示されるタイプのステートを表示する機能を追加。
|
||
* 敵選択ウィンドウの表示がずれる問題を修正。
|
||
* バトルステータスウィンドウの表示がおかしくなる問題を修正。
|
||
* 2022/7/23 Ver.3.5.4
|
||
* キャンセルボタンのX座標を調整できる処理の追加。
|
||
* 処理の修正。
|
||
* 2022/7/18 Ver.3.5.3
|
||
* キャンセルボタンの表示位置を左か右か指定できる機能を追加。
|
||
* 2022/7/2 Ver.3.5.2
|
||
* TPBバトルでパーティコマンドが表示されず進行不能になる問題を修正。
|
||
* 顔グラの行動時エフェクト時に座標がずれる問題を修正。
|
||
* メンバー交代時にステートエフェクトが残ってしまう問題を修正。
|
||
* 2022/6/24 Ver.3.5.1
|
||
* 立ち絵切り替えの画像設定でデフォルトの画像を設定しなかったときにリスト0番の画像が切り替わらない問題を修正。
|
||
* アクターのアニメーションをOFFにして敵から攻撃を受けるとエラーが出る問題を修正。
|
||
* スタンダードでアクターの画像位置がおかしくなる問題を修正。
|
||
* 競合対策。
|
||
* 2022/6/19 Ver.3.5.0
|
||
* 画像切り替え時に座標がリセットされてしまう問題を修正。
|
||
* 2022/6/18 Ver.3.4.1
|
||
* アニメーションの表示をステータスの背後、ダメージポップアップをステータスの前面に表示するように変更。
|
||
* 2022/6/15 Ver.3.4.0
|
||
* パーティコマンド、アクターコマンド、アクターステータスウィンドウに任意のウィンドウスキンを設定できる機能を追加。
|
||
* 2022/6/11 Ver.3.3.7
|
||
* ステートエフェクトが画像の拡大率に依存してしまう問題を修正。
|
||
* 2022/6/7 Ver.3.3.6
|
||
* アクター画像の表示幅を指定すると行動時に画像が消える問題を修正。
|
||
* アクター行動時にステートの表示がおかしくなる問題を修正。
|
||
* アクター毎にステートエフェクトの座標を調整できる機能を追加。
|
||
* 2022/6/5 Ver.3.3.5
|
||
* アクター行動時のエフェクトがおかしくなる問題を修正。
|
||
* 2022/6/4 Ver.3.3.4
|
||
* アクター画像設定をなしに設定して戦闘を行うとアニメーション時にエラーが出る問題を修正。
|
||
* 2022/6/2 Ver.3.3.3
|
||
* 立ち絵の起点を下に設定したときに、画像の下部分がウィンドウの下側から表示されない問題を修正。
|
||
* 2022/6/1 Ver.3.3.2
|
||
* ２行目のアクターステータスの表示で表示揃えを適用できるように修正。
|
||
* アクター画像（顔グラ）の設定方法に画像起点を追加。
|
||
* 2022/5/31 Ver.3.3.1
|
||
* 敵またはアクター対象選択をキャンセルしパーティコマンドまで戻った時に、操作を受け付けなくなる問題を修正。
|
||
* 2022/5/26 Ver.3.3.0
|
||
* アクターステータスの表示する方法に独自表示設定する機能を追加。
|
||
* 上記の機能に独自パラメータ、独自ゲージを表示する機能を追加。
|
||
* 2022/5/12 Ver.3.2.2
|
||
* ステートアニメーションを表示させない機能を追加。
|
||
* 2022/5/11 Ver.3.2.1
|
||
* フロントビュー時のアクターのアニメーションをOFF、サイドビューバトル時でもステートアニメーションが適用してしまう問題を修正。
|
||
* 2022/5/11 Ver.3.2.0
|
||
* アクター画像にステート画像を表示する機能を追加。
|
||
* パーティ、アクターコマンドの表示位置を指定できる機能を追加。
|
||
* 2022/5/10 Ver.3.1.6
|
||
* MVアニメーションを再生したときにエラーが起きる問題を修正。
|
||
* 2022/5/10 Ver.3.1.5
|
||
* アクター画像にエフェクト（アニメーション）を適用するように修正。
|
||
* 2022/5/4 Ver.3.1.4
|
||
* 攻撃時のスキルをなしに設定したときに画像が切り替わらない問題を修正。
|
||
* 2022/5/3 Ver.3.1.3
|
||
* 戦闘不能時の画像を設定しても戦闘不能時に画像が消えてしまう問題を修正。
|
||
* 2022/5/2 Ver.3.1.2
|
||
* エフェクトのプロパティを中間（アクター画像とステータスの間）か最前面に表示する機能を追加。
|
||
* 2022/5/1 Ver.3.1.1
|
||
* MP、TPゲージの座標変更許可時に座標が正常に適用されてなかった問題を修正。
|
||
* 2022/4/10 Ver.3.1.0
|
||
* アクター画像条件拡張による処理追加。
|
||
* アクター画像設定のスキル、アイテム条件が適用されていなかった問題を修正。
|
||
* 2022/4/4 Ver.3.0.7
|
||
* アイコンステート枠内表示をOFFにした場合、ステートアイコンがアクター画像の背後に表示されてしまう問題を修正。
|
||
* 2022/4/1 Ver.3.0.6
|
||
* アクターコマンドの項目表示位置を中央にする機能の処理を追加。
|
||
* 2022/3/29 Ver.3.0.5
|
||
* アクターコマンドを各アクターの上指定時のサポートアクターのコマンド座標の処理を追加。
|
||
* 2022/3/27 Ver.3.0.4
|
||
* アニメーション、ダメージポップアップの表示がずれるため一時的にもとに戻す修正。
|
||
* 2022/3/26 Ver.3.0.3
|
||
* アクターウィンドウステータスのアクター配置を表示範囲可変表示にする機能を追加。
|
||
* 2022/3/26 Ver.3.0.2
|
||
* 敵選択ウィンドウのスキン非表示を設定する項目がなかった問題を修正。
|
||
* 逃走失敗時にエラーが出る問題を修正。
|
||
* 敵出現、勝利、敗北、逃走時に背景画像を指定したときに、背景のY座標が正常に適用していなかった問題を修正。
|
||
* 2022/3/25 Ver.3.0.1
|
||
* 立ち絵切り替え条件にスイッチ、武器、防具装備時、特定の職業を追加
|
||
* プラグインコマンド「アクターステータスウィンドウ透明化表示」の表記が逆だった問題を修正。
|
||
* 2022/3/24 Ver.3.0.0
|
||
* リニューアル版初版
|
||
*
|
||
*
|
||
* @command ActorStatusWindowOpacity
|
||
* @desc アクターステータスウィンドウを透明化します。
|
||
* @text アクターステータスウィンドウ透明化表示
|
||
*
|
||
* @arg WindowOpacity
|
||
* @type boolean
|
||
* @default false
|
||
* @text 不透明度表示
|
||
* @desc ONの時、アクターステータスウィンドウが透明化します。(ONで透明化)
|
||
*
|
||
* @arg WindowOpacityValue
|
||
* @type number
|
||
* @default 0
|
||
* @text 不透明度
|
||
* @desc 不透明度を指定します。0で非表示
|
||
*
|
||
*
|
||
*/
|
||
var Imported = Imported || {};
|
||
Imported.NUUN_BattleStyleEX = true;
|
||
|
||
(() => {
|
||
const parameters = PluginManager.parameters("NUUN_BattleStyleEX");
|
||
const params = NuunManager.getBattleStyleParams();
|
||
let statusData = null;
|
||
|
||
const pluginName = "NUUN_BattleStyleEX";
|
||
|
||
PluginManager.registerCommand(
|
||
pluginName,
|
||
"ActorStatusWindowOpacity",
|
||
(args) => {
|
||
BattleManager.statusWindowOpacity(
|
||
eval(args.WindowOpacity),
|
||
Number(args.WindowOpacityValue)
|
||
);
|
||
}
|
||
);
|
||
|
||
function getActorData(actorId) {
|
||
return params.ActorData.find((data) => data.actorId === actorId);
|
||
}
|
||
|
||
function getActorPositionData(actorId) {
|
||
const find = getActorData(actorId);
|
||
if (find && !find.DefaultStatusPosition) {
|
||
return find.StatusPositionData;
|
||
} else {
|
||
return params.DefaultStatusPositionData;
|
||
}
|
||
}
|
||
|
||
function getActorImgData(actorId) {
|
||
const find = getActorData(actorId);
|
||
if (find) {
|
||
find.ActorImgSetting.ActorImgHPosition = getUndefinedHPosition(
|
||
find.ActorImgSetting.ActorImgHPosition
|
||
);
|
||
find.ActorImgSetting.ActorImgVPosition = getUndefinedHPosition(
|
||
find.ActorImgSetting.ActorImgVPosition
|
||
);
|
||
return find.ActorImgSetting;
|
||
} else {
|
||
params.DefaultActorImgData.ActorImgHPosition = getUndefinedHPosition(
|
||
params.DefaultActorImgData.ActorImgHPosition
|
||
);
|
||
params.DefaultActorImgData.ActorImgVPosition = getUndefinedVPosition(
|
||
params.DefaultActorImgData.ActorImgVPosition
|
||
);
|
||
return params.DefaultActorImgData;
|
||
}
|
||
}
|
||
|
||
function getUndefinedHPosition(data) {
|
||
if (data) {
|
||
return data;
|
||
} else if ((params.bsMode = "Default")) {
|
||
return "left";
|
||
} else if ((params.bsMode = "Standard")) {
|
||
return "left";
|
||
} else if ((params.bsMode = "XP")) {
|
||
return "center";
|
||
}
|
||
}
|
||
|
||
function getUndefinedVPosition(data) {
|
||
if (data) {
|
||
return data;
|
||
} else if ((params.bsMode = "Default")) {
|
||
return "top";
|
||
} else if ((params.bsMode = "Standard")) {
|
||
return "under";
|
||
} else if ((params.bsMode = "XP")) {
|
||
return "under";
|
||
}
|
||
}
|
||
|
||
function getActorWindowCenter() {
|
||
return (Graphics.width - getActorWindowOrgWidth()) / 2;
|
||
}
|
||
|
||
function getActorWindowOrgWidth() {
|
||
return params.ActorStatusWindow_Width > 0
|
||
? params.ActorStatusWindow_Width
|
||
: Graphics.boxWidth;
|
||
}
|
||
|
||
function loadBackground(img) {
|
||
if (img) {
|
||
ImageManager.nuun_LoadPictures(img);
|
||
}
|
||
}
|
||
|
||
function getStateAnimationShow() {
|
||
return (
|
||
!$gameSystem.isSideView() &&
|
||
params.ActorEffectShow &&
|
||
params.StateAnimationShow
|
||
);
|
||
}
|
||
|
||
const _BattleManager_initMembers = BattleManager.initMembers;
|
||
BattleManager.initMembers = function () {
|
||
_BattleManager_initMembers.call(this);
|
||
this.actorStatusWindowOpacity = false;
|
||
this.actorStatusWindowOpacityValue = false;
|
||
this.battlerSprite = [];
|
||
this.visibleStateIcons = [];
|
||
this.notIconList = this.getNotVisibleIcons();
|
||
Array.prototype.push.apply(this.notIconList, this.getNotVisibleBuffIcons());
|
||
};
|
||
|
||
BattleManager.getNotVisibleIcons = function () {
|
||
return params.NotVisibleStateIcons.filter((stateId) => $dataStates[stateId])
|
||
.map((stateId) => $dataStates[stateId].iconIndex)
|
||
.filter((id) => id > 0);
|
||
};
|
||
|
||
BattleManager.getNotVisibleBuffIcons = function () {
|
||
return this.getVisibleBuffIcons(params.NotVisibleBuffIcons);
|
||
};
|
||
|
||
BattleManager.getVisibleBuffIcons = function (list) {
|
||
const icons = [];
|
||
for (const buff of list) {
|
||
if (buff >= 0 && buff < 8) {
|
||
for (const i = 0; i < 2; i++) {
|
||
icons.push(Game_BattlerBase.ICON_BUFF_START + i * 8 + buff);
|
||
}
|
||
} else if (buff >= 10 && buff < 18) {
|
||
icons.push(Game_BattlerBase.ICON_DEBUFF_START + -i * 8 + buff - 10);
|
||
}
|
||
}
|
||
return icons;
|
||
};
|
||
|
||
BattleManager.statusWindowOpacity = function (flag, opacity) {
|
||
this.actorStatusWindowOpacity = flag;
|
||
this.actorStatusWindowOpacityValue = flag ? opacity : 255;
|
||
};
|
||
|
||
const _BattleManager_displayStartMessages =
|
||
BattleManager.displayStartMessages;
|
||
BattleManager.displayStartMessages = function () {
|
||
if (!params.AppearWindowVisible) {
|
||
_BattleManager_displayStartMessages.call(this);
|
||
this.setDisplayMessagePosition(params.AppearWindowAnchorMode);
|
||
this.displayMessageType("Appear");
|
||
}
|
||
};
|
||
|
||
const _BattleManager_displayVictoryMessage =
|
||
BattleManager.displayVictoryMessage;
|
||
BattleManager.displayVictoryMessage = function () {
|
||
_BattleManager_displayVictoryMessage.call(this);
|
||
this.setDisplayMessagePosition(params.VictoryWindowAnchorMode);
|
||
this.displayMessageType("Victory");
|
||
};
|
||
|
||
const _BattleManager_displayDefeatMessage =
|
||
BattleManager.displayDefeatMessage;
|
||
BattleManager.displayDefeatMessage = function () {
|
||
_BattleManager_displayDefeatMessage.call(this);
|
||
this.setDisplayMessagePosition(params.LoseWindowAnchorMode);
|
||
this.displayMessageType("Defeat");
|
||
};
|
||
|
||
const _BattleManager_displayEscapeSuccessMessage =
|
||
BattleManager.displayEscapeSuccessMessage;
|
||
BattleManager.displayEscapeSuccessMessage = function () {
|
||
_BattleManager_displayEscapeSuccessMessage.call(this);
|
||
this.setDisplayMessagePosition(params.EscapeWindowAnchorMode);
|
||
this.displayMessageType("Escape");
|
||
};
|
||
|
||
const _BattleManager_displayEscapeFailureMessage =
|
||
BattleManager.displayEscapeFailureMessage;
|
||
BattleManager.displayEscapeFailureMessage = function () {
|
||
_BattleManager_displayEscapeFailureMessage.call(this);
|
||
this.setDisplayMessagePosition(params.EscapeWindowAnchorMode);
|
||
this.displayMessageType("EscapeFailure");
|
||
};
|
||
|
||
BattleManager.setDisplayMessagePosition = function (type) {
|
||
switch (type) {
|
||
case "top":
|
||
$gameMessage.setPositionType(0);
|
||
break;
|
||
case "center":
|
||
$gameMessage.setPositionType(1);
|
||
break;
|
||
case "under":
|
||
$gameMessage.setPositionType(2);
|
||
break;
|
||
}
|
||
};
|
||
|
||
BattleManager.displayMessageType = function (type) {
|
||
$gameMessage._messageType = type;
|
||
};
|
||
|
||
BattleManager.getDisplayMessageType = function () {
|
||
return $gameMessage._messageType;
|
||
};
|
||
|
||
const _BattleManager_startActorInput = BattleManager.startActorInput;
|
||
BattleManager.startActorInput = function () {
|
||
_BattleManager_startActorInput.call(this);
|
||
if (this._currentActor && this._currentActor.isInputting()) {
|
||
this._currentActor.battleStyleImgRefresh();
|
||
}
|
||
};
|
||
|
||
const _BattleManager_invokeCounterAttack = BattleManager.invokeCounterAttack;
|
||
BattleManager.invokeCounterAttack = function (subject, target) {
|
||
if (target.isActor()) {
|
||
target.setBattleImgId(30);
|
||
target.battleStyleImgRefresh();
|
||
}
|
||
_BattleManager_invokeCounterAttack.call(this, subject, target);
|
||
};
|
||
|
||
const _BattleManager_invokeMagicReflection =
|
||
BattleManager.invokeMagicReflection;
|
||
BattleManager.invokeMagicReflection = function (subject, target) {
|
||
if (target.isActor()) {
|
||
target.setBattleImgId(31);
|
||
target.battleStyleImgRefresh();
|
||
}
|
||
_BattleManager_invokeMagicReflection.call(this, subject, target);
|
||
};
|
||
|
||
//Game_Temp
|
||
const _Game_Temp_initialize = Game_Temp.prototype.initialize;
|
||
Game_Temp.prototype.initialize = function () {
|
||
_Game_Temp_initialize.call(this);
|
||
this._battleStyleRefresh = false;
|
||
this.onBSAction = false;
|
||
};
|
||
|
||
Game_Temp.prototype.setBattleStyleRefresh = function (flag) {
|
||
this._battleStyleRefresh = flag;
|
||
};
|
||
|
||
Game_Temp.prototype.isBattleStyleRequested = function () {
|
||
return this._battleStyleRefresh || false;
|
||
};
|
||
|
||
const _Game_BattlerBase_allIcons = Game_BattlerBase.prototype.allIcons;
|
||
Game_BattlerBase.prototype.allIcons = function () {
|
||
let icons = _Game_BattlerBase_allIcons.call(this);
|
||
if (
|
||
BattleManager.visibleStateIcons &&
|
||
BattleManager.visibleStateIcons.length > 0
|
||
) {
|
||
icons = icons.filter(
|
||
(icon) => BattleManager.visibleStateIcons.indexOf(icon) >= 0
|
||
);
|
||
BattleManager.visibleStateIcons = [];
|
||
}
|
||
if (BattleManager.notIconList && BattleManager.notIconList.length > 0) {
|
||
icons = icons.filter((id) => BattleManager.notIconList.indexOf(id) < 0);
|
||
}
|
||
return icons;
|
||
};
|
||
|
||
//Game_Actor
|
||
const _Game_Actor_initMembers = Game_Actor.prototype.initMembers;
|
||
Game_Actor.prototype.initMembers = function () {
|
||
_Game_Actor_initMembers.call(this);
|
||
this.nuun_bsUseItemId = -1;
|
||
this._battleStyleGraphicIndex = -1;
|
||
this._battleStyleGraphicOpacity = 255;
|
||
this._battleStyleGraphicName = null;
|
||
this._actionActorImg = null;
|
||
this._isEffectAction = false;
|
||
this._onDamageEffect = false;
|
||
this._isDeadImg = false;
|
||
this._imgScenes = "default";
|
||
};
|
||
|
||
const _Game_Actor_refresh = Game_Actor.prototype.refresh;
|
||
Game_Actor.prototype.refresh = function () {
|
||
_Game_Actor_refresh.call(this);
|
||
this.battleStyleImgRefresh();
|
||
};
|
||
|
||
const _Game_Actor_setup = Game_Actor.prototype.setup;
|
||
Game_Actor.prototype.setup = function (actorId) {
|
||
_Game_Actor_setup.call(this, actorId);
|
||
this.battleStyleImgRefresh();
|
||
};
|
||
|
||
Game_Actor.prototype.battleStyleImgRefresh = function () {
|
||
this.setBattleStyleActorGraphicData();
|
||
};
|
||
|
||
Game_Actor.prototype.setBattleStyleActorGraphicData = function () {
|
||
let imgIndex = -1;
|
||
let index = -1;
|
||
this._isDeadImg = false;
|
||
this._imgScenes = "default";
|
||
const actorId = this.actorId();
|
||
const imgData = getActorImgData(actorId);
|
||
const actorData = getActorData(actorId);
|
||
this.bsImgMode = imgData ? imgData.ActorImgMode : "face";
|
||
this.faceMode = !(imgData && imgData.ActorImgMode !== "face");
|
||
if (Imported.NUUN_ActorPicture && params.OnActorPictureEX) {
|
||
this.actorPictureActorGraphicData(imgData);
|
||
return;
|
||
} else if (
|
||
imgData.ActorImgMode !== "none" &&
|
||
actorData &&
|
||
actorData.ButlerActorImg
|
||
) {
|
||
index = actorData.ButlerActorImg.findIndex((data) => {
|
||
return this.battleStyleMatchConditions(data);
|
||
});
|
||
if (index >= 0) {
|
||
const data = actorData.ButlerActorImg[index];
|
||
this._battleStyleGraphicName = this.getBattleStyleImg(data);
|
||
imgIndex = this.getBattleStyleImgIndex(data);
|
||
this._isDeadImg = this.isBSActorGraphicDead(data);
|
||
this._battleStyleGraphicOpacity = data.Opacity || 255;
|
||
} else {
|
||
this._battleStyleGraphicName = null;
|
||
}
|
||
} else {
|
||
if (this.faceMode) {
|
||
this._battleStyleGraphicName = this.faceName();
|
||
imgIndex = this.faceIndex();
|
||
index = 0;
|
||
} else {
|
||
this._battleStyleGraphicName = null;
|
||
}
|
||
}
|
||
this._battleStyleGraphicIndex = index;
|
||
this._battleStyleImgIndex = imgIndex;
|
||
};
|
||
|
||
Game_Actor.prototype.actorPictureActorGraphicData = function (imgData) {
|
||
if (imgData.ActorImgMode === "none") {
|
||
this._battleStyleGraphicName = null;
|
||
this._battleStyleGraphicIndex = -1;
|
||
this._battleStyleImgIndex = -1;
|
||
} else if (imgData.ActorImgMode === "imges") {
|
||
this._battleStyleGraphicName = this.getActorGraphicImg();
|
||
this._battleStyleGraphicIndex = this._actorGraphicIndex;
|
||
this._battleStyleImgIndex = -1;
|
||
} else {
|
||
this._battleStyleGraphicName = this.getActorGraphicFace();
|
||
this._battleStyleGraphicIndex =
|
||
this._actorGraphicIndex >= 0 ? this._actorGraphicIndex : 9999;
|
||
this._battleStyleImgIndex = this.getActorGraphicFaceIndex();
|
||
}
|
||
const data = this.getActorGraphicData();
|
||
if (data) {
|
||
this._isDeadImg = this.isBSActorGraphicDead(data);
|
||
this._imgScenes = data.ChangeGraphicScenes;
|
||
}
|
||
};
|
||
|
||
Game_Actor.prototype.getBattleStyleOpacity = function () {
|
||
return Imported.NUUN_ActorPicture && params.OnActorPictureEX
|
||
? this._actorGraphicOpacity
|
||
: this._battleStyleGraphicOpacity;
|
||
};
|
||
|
||
Game_Actor.prototype.getBattleStyleImg = function (data) {
|
||
return this.faceMode
|
||
? this.actorFaceName(data)
|
||
: this.actorGraphicName(data);
|
||
};
|
||
|
||
Game_Actor.prototype.getBattleStyleImgIndex = function (data) {
|
||
return this.faceMode ? this.actorFaceIndex(data) : this.actorImgIndex(data);
|
||
};
|
||
|
||
Game_Actor.prototype.actorFaceName = function (data) {
|
||
return data && data.FaceImg ? data.FaceImg : this.faceName();
|
||
};
|
||
|
||
Game_Actor.prototype.actorGraphicName = function (data) {
|
||
return data.GraphicImg;
|
||
};
|
||
|
||
Game_Actor.prototype.actorFaceIndex = function (data) {
|
||
return data && data.ImgIndex >= 0 ? data.ImgIndex : this.faceIndex();
|
||
};
|
||
|
||
Game_Actor.prototype.actorImgIndex = function (data) {
|
||
return -1;
|
||
//return data && data.ImgIndex >= 0 ? data.ImgIndex : -1;
|
||
};
|
||
|
||
Game_Actor.prototype.getBSImgName = function () {
|
||
return this._battleStyleGraphicName;
|
||
};
|
||
|
||
Game_Actor.prototype.getBSImgIndex = function () {
|
||
return this._battleStyleImgIndex;
|
||
};
|
||
|
||
Game_Actor.prototype.getBSGraphicIndex = function () {
|
||
return this._battleStyleGraphicIndex;
|
||
};
|
||
|
||
Game_Actor.prototype.isBSActorGraphicDead = function (data) {
|
||
return (
|
||
data &&
|
||
(data.ChangeGraphicScenes === "death" ||
|
||
(data.ChangeGraphicScenes === "state" &&
|
||
(data.stateId === this.deathStateId() ||
|
||
data.ImgStateAll === this.deathStateId())))
|
||
);
|
||
};
|
||
|
||
Game_Actor.prototype.getActorGraphicDead = function () {
|
||
return this._isDeadImg;
|
||
};
|
||
|
||
Game_Actor.prototype.battleStyleMatchConditions = function (data) {
|
||
if (
|
||
data.ImgHP &&
|
||
data.ImgHP.CondValid &&
|
||
!conditionsParam(data.ImgHP, this.hp, this.param(0))
|
||
) {
|
||
return false;
|
||
}
|
||
if (data.ImgSwitch && !this.isBattleStyleSwitchImg(data)) {
|
||
return false;
|
||
}
|
||
if (data.ImgWeapon && !this.isBattleStyleWeaponImg(data)) {
|
||
return false;
|
||
}
|
||
if (data.ImgArmor && !this.isBattleStyleArmorImg(data)) {
|
||
return false;
|
||
}
|
||
if (
|
||
data.ImgStateAll &&
|
||
!this.isBattleStyleStateImg(data, data.ImgStateAll)
|
||
) {
|
||
return false;
|
||
}
|
||
if (data.ImgClass > 0 && !this.isBattleStyleClassImg(data)) {
|
||
return false;
|
||
}
|
||
if (!this.battleStyleMatchChangeGraphic(data)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
};
|
||
|
||
Game_Actor.prototype.battleStyleMatchChangeGraphic = function (data) {
|
||
const changeData = data.ChangeGraphicScenes;
|
||
this._imgScenes = changeData;
|
||
switch (changeData) {
|
||
case "default":
|
||
return true;
|
||
case "death":
|
||
return this.isDead();
|
||
case "command":
|
||
return this.isInputting();
|
||
case "dying":
|
||
return this.isDying();
|
||
case "damage":
|
||
return this.onImgId === 1;
|
||
case "recovery":
|
||
return this.onImgId === 2;
|
||
case "attack":
|
||
return this.onImgId === 10 && this.isBattleStyleUseItemImg(data.Skill);
|
||
case "recoverySkill":
|
||
return this.onImgId === 11 && this.isBattleStyleUseItemImg(data.Skill);
|
||
case "item":
|
||
return this.onImgId === 12 && this.isBattleStyleUseItemImg(data.Item);
|
||
case "chant":
|
||
return this.isChanting();
|
||
case "victory":
|
||
return this.onImgId === 20;
|
||
case "state":
|
||
return this.isBattleStyleStateImg(data, data.stateId);
|
||
case "counter":
|
||
return this.onImgId === 30;
|
||
case "reflection":
|
||
return this.onImgId === 31;
|
||
case "counterEX":
|
||
return this.onImgId === 32 && this.isBattleStyleUseItemImg(data.Item);
|
||
case "guard":
|
||
return this.onImgId === 15;
|
||
}
|
||
};
|
||
|
||
Game_Actor.prototype.isBattleStyleSwitchImg = function (data) {
|
||
return data.ImgSwitch.every((id) => $gameSwitches.value(id));
|
||
};
|
||
|
||
Game_Actor.prototype.isBattleStyleWeaponImg = function (data) {
|
||
return data.ImgWeapon.every((id) => this.isEquipped($dataWeapons[id]));
|
||
};
|
||
|
||
Game_Actor.prototype.isBattleStyleArmorImg = function (data) {
|
||
return data.ImgArmor.every((id) => this.isEquipped($dataArmors[id]));
|
||
};
|
||
|
||
Game_Actor.prototype.isBattleStyleStateImg = function (data, states) {
|
||
return states.every((id) => this.isStateAffected(id));
|
||
};
|
||
|
||
Game_Actor.prototype.isBattleStyleClassImg = function (data) {
|
||
return data.ImgClass ? this._classId === data.ImgClass : true;
|
||
};
|
||
|
||
Game_Actor.prototype.isBattleStyleUseItemImg = function (item) {
|
||
return item && item[0] > 0 ? item.includes(this.nuun_bsUseItemId) : true;
|
||
};
|
||
|
||
const _Game_Actor_isSpriteVisible = Game_Actor.prototype.isSpriteVisible;
|
||
Game_Actor.prototype.isSpriteVisible = function () {
|
||
return params.ActorEffectShow && !$gameSystem.isSideView()
|
||
? $gameParty.inBattle()
|
||
? true
|
||
: _Game_Actor_isSpriteVisible.call(this)
|
||
: _Game_Actor_isSpriteVisible.call(this);
|
||
};
|
||
|
||
const _Game_Actor_performDamage = Game_Actor.prototype.performDamage;
|
||
Game_Actor.prototype.performDamage = function () {
|
||
_Game_Actor_performDamage.call(this);
|
||
if (params.OnActorShake) {
|
||
this._onDamageEffect = true;
|
||
}
|
||
if (this.isGuard()) {
|
||
this.setBattleImgId(15);
|
||
this.battleStyleImgRefresh();
|
||
}
|
||
if (this._imgScenes !== "guard") {
|
||
this.setBattleImgId(1);
|
||
this.battleStyleImgRefresh();
|
||
}
|
||
};
|
||
|
||
const _Game_Actor_performRecovery = Game_Actor.prototype.performRecovery;
|
||
Game_Actor.prototype.performRecovery = function () {
|
||
_Game_Actor_performRecovery.call(this);
|
||
this.setBattleImgId(2);
|
||
this.battleStyleImgRefresh();
|
||
};
|
||
|
||
const _Game_Actor_performVictory = Game_Actor.prototype.performVictory;
|
||
Game_Actor.prototype.performVictory = function () {
|
||
_Game_Actor_performVictory.call(this);
|
||
this.setBattleImgId(20);
|
||
this.battleStyleImgRefresh();
|
||
};
|
||
|
||
const _Game_Actor_performActionStart =
|
||
Game_Actor.prototype.performActionStart;
|
||
Game_Actor.prototype.performActionStart = function (action) {
|
||
_Game_Actor_performActionStart.call(this, action);
|
||
if (params.OnActionZoom) {
|
||
this._isEffectAction = true;
|
||
}
|
||
this.setBattleStyleAttackImgId(action);
|
||
};
|
||
|
||
Game_Actor.prototype.setBattleStyleAttackImgId = function (action) {
|
||
if (action.isRecover()) {
|
||
this.setBattleImgId(11, action.item().id);
|
||
this.setBSActionActorImg("recovery");
|
||
} else if (action.isAttack()) {
|
||
this.setBattleImgId(10, action.item().id);
|
||
this.setBSActionActorImg("attack");
|
||
} else if (action.isMagicSkill()) {
|
||
this.setBattleImgId(10, action.item().id);
|
||
this.setBSActionActorImg("attack");
|
||
} else if (action.isSkill()) {
|
||
this.setBattleImgId(10, action.item().id);
|
||
this.setBSActionActorImg("attack");
|
||
} else if (action.isItem()) {
|
||
this.setBattleImgId(12, action.item().id);
|
||
this.setBSActionActorImg("item");
|
||
} else {
|
||
this.setBattleImgId(0, -1);
|
||
this.setBSActionActorImg(null);
|
||
}
|
||
this.battleStyleImgRefresh();
|
||
};
|
||
|
||
Game_Actor.prototype.setBattleImgId = function (id, itemId) {
|
||
if (itemId !== undefined) {
|
||
this.nuun_bsUseItemId = itemId;
|
||
}
|
||
this.onImgId = id;
|
||
};
|
||
|
||
Game_Actor.prototype.resetBattleStyleImgId = function () {
|
||
this.setBattleImgId(0, -1);
|
||
this.battleStyleImgRefresh();
|
||
};
|
||
|
||
Game_Actor.prototype.getLoadBattleStyleImg = function () {
|
||
return this.faceMode
|
||
? this.loadBattleStyleActorFace()
|
||
: this.loadBattleStyleActorGraphic();
|
||
};
|
||
|
||
Game_Actor.prototype.loadBattleStyleActorGraphic = function () {
|
||
return ImageManager.nuun_LoadPictures(this._battleStyleGraphicName);
|
||
};
|
||
|
||
Game_Actor.prototype.loadBattleStyleActorFace = function () {
|
||
return ImageManager.loadFace(this._battleStyleGraphicName);
|
||
};
|
||
|
||
Game_Actor.prototype.isBSEffectAction = function () {
|
||
return this._isEffectAction;
|
||
};
|
||
|
||
Game_Actor.prototype.isBSDamageEffect = function () {
|
||
return this._onDamageEffect;
|
||
};
|
||
|
||
Game_Actor.prototype.setBSActionActorImg = function (state) {
|
||
this._actionActorImg = state;
|
||
};
|
||
|
||
Game_Actor.prototype.isBSActionActorImg = function () {
|
||
return this._actionActorImg;
|
||
};
|
||
|
||
//Game_Enemy
|
||
Game_Enemy.prototype.attackAnimation = function () {
|
||
return this.bareHandsAnimationId();
|
||
};
|
||
|
||
Game_Enemy.prototype.bareHandsAnimationId = function () {
|
||
return this.enemy().meta.AttackAnimation
|
||
? Number(this.enemy().meta.AttackAnimation)
|
||
: params.EnemySkillAnimation;
|
||
};
|
||
|
||
//Scene_Battle
|
||
const _Scene_Battle_initialize = Scene_Battle.prototype.initialize;
|
||
Scene_Battle.prototype.initialize = function () {
|
||
_Scene_Battle_initialize.call(this);
|
||
this.loadBackgroundImg();
|
||
this.loadBattleStatusImg();
|
||
};
|
||
|
||
Scene_Battle.prototype.loadBackgroundImg = function () {
|
||
loadBackground(params.AppearBackgroundImg);
|
||
loadBackground(params.VictoryBackgroundImg);
|
||
loadBackground(params.LoseBackgroundImg);
|
||
loadBackground(params.EscapeBackgroundImg);
|
||
loadBackground(params.EscapeFailureBackgroundImg);
|
||
};
|
||
|
||
Scene_Battle.prototype.loadBattleStatusImg = function () {
|
||
//$gameTemp.actorData = getActorPositionData(actor.actorId());
|
||
//const statusData = $gameTemp.actorData.StatusListData;
|
||
};
|
||
|
||
const _Scene_Battle_start = Scene_Battle.prototype.start;
|
||
Scene_Battle.prototype.start = function () {
|
||
_Scene_Battle_start.call(this);
|
||
this._actorImges.refresh();
|
||
this._actorStatus.refresh();
|
||
};
|
||
|
||
const _Scene_Battle_stop = Scene_Battle.prototype.stop;
|
||
Scene_Battle.prototype.stop = function () {
|
||
_Scene_Battle_stop.call(this);
|
||
if (!params.BattleEndActorStatusClose) {
|
||
this._statusWindow.open();
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_updateStatusWindowVisibility =
|
||
Scene_Battle.prototype.updateStatusWindowVisibility;
|
||
Scene_Battle.prototype.updateStatusWindowVisibility = function () {
|
||
_Scene_Battle_updateStatusWindowVisibility.call(this);
|
||
if (params.BattleEndActorStatusClose) {
|
||
if (BattleManager.isBattleEnd()) {
|
||
this._statusWindow.close();
|
||
} else if (this.isActive()) {
|
||
this._statusWindow.open();
|
||
}
|
||
} else {
|
||
this._statusWindow.open();
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_createSpriteset = Scene_Battle.prototype.createSpriteset;
|
||
Scene_Battle.prototype.createSpriteset = function () {
|
||
_Scene_Battle_createSpriteset.call(this);
|
||
this._spriteset.createStatusLayer();
|
||
this.addChild(this._spriteset._battleHudBase);
|
||
};
|
||
|
||
const _Scene_Battle_createAllWindows =
|
||
Scene_Battle.prototype.createAllWindows;
|
||
Scene_Battle.prototype.createAllWindows = function () {
|
||
this._battleHudBack = this._spriteset._battleHudBack;
|
||
this._battleHudFront = this._spriteset._battleHudFront;
|
||
if (this._spriteset._battleEffects) {
|
||
this._battleEffects = this._spriteset._battleEffects;
|
||
}
|
||
this.createBackgroundWindow();
|
||
this.createHud();
|
||
this.createActorSelectWindow();
|
||
_Scene_Battle_createAllWindows.call(this);
|
||
};
|
||
|
||
Scene_Battle.prototype.createBackgroundWindow = function () {
|
||
if (params.WindowBackground) {
|
||
const bitmap = ImageManager.nuun_LoadPictures(params.WindowBackground);
|
||
const sprite = new Sprite(bitmap);
|
||
this._battleHudBack.addChild(sprite);
|
||
this._backgroundWindow = sprite;
|
||
}
|
||
};
|
||
|
||
const _Scene_Base_createWindowLayer = Scene_Base.prototype.createWindowLayer;
|
||
Scene_Base.prototype.createWindowLayer = function () {
|
||
const sprite = new Sprite();
|
||
this.addChild(sprite);
|
||
this._itemBSBackgorundWindow = sprite;
|
||
_Scene_Base_createWindowLayer.call(this);
|
||
};
|
||
|
||
if (params.CommandPosition !== "default") {
|
||
Scene_Battle.prototype.isRightInputMode = function () {
|
||
return params.CommandPosition === "right";
|
||
};
|
||
}
|
||
|
||
Scene_Battle.prototype.createHud = function () {
|
||
const rect = this.statusWindowRect();
|
||
this._statusWindow = new Window_BattleStatus(rect);
|
||
this._battleHudBack.addChild(this._statusWindow);
|
||
this.setStatusWindow_Sprite();
|
||
if (this._backgroundWindow) {
|
||
this._backgroundWindow.x =
|
||
this._statusWindow.x + params.WindowBackground_X;
|
||
this._backgroundWindow.y =
|
||
this._statusWindow.y + params.WindowBackground_Y;
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.createActorSelectWindow = function () {
|
||
const rect = this.actorWindowRect();
|
||
this._actorWindow = new Window_BattleActor(rect);
|
||
this._actorWindow.setHandler("ok", this.onActorOk.bind(this));
|
||
this._actorWindow.setHandler("cancel", this.onActorCancel.bind(this));
|
||
this._battleHudBack.addChild(this._actorWindow);
|
||
};
|
||
|
||
Scene_Battle.prototype.createStatusWindow = function () {
|
||
const rect = this.statusWindowRect();
|
||
const rect2 = this.actorStatusWindowRect(); //
|
||
this._actorImges = new Window_BattleActorImges(rect);
|
||
this._actorStatus = new Window_BattleActorStatus(rect);
|
||
this._actorStatus.sx = rect.x - rect2.x; //
|
||
this._actorStatus.sy = rect.y - rect2.y; //
|
||
this._battleHudBack.addChild(this._actorImges);
|
||
this._battleHudFront.addChild(this._actorStatus);
|
||
this._statusWindow.setActorWindow(this._actorImges, this._actorStatus);
|
||
};
|
||
|
||
const _Scene_Battle_createPartyCommandWindow =
|
||
Scene_Battle.prototype.createPartyCommandWindow;
|
||
Scene_Battle.prototype.createPartyCommandWindow = function () {
|
||
_Scene_Battle_createPartyCommandWindow.call(this);
|
||
if (params.PartyCommandBackgroundImg) {
|
||
const bitmap = ImageManager.nuun_LoadPictures(
|
||
params.PartyCommandBackgroundImg
|
||
);
|
||
const sprite = new Sprite(bitmap);
|
||
this._battleHudFront.addChild(sprite);
|
||
this._partyCommandBackgroundWindow = sprite;
|
||
sprite.x =
|
||
params.PartyBackground_X +
|
||
this._partyCommandWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
sprite.y =
|
||
params.PartyBackground_Y +
|
||
this._partyCommandWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
sprite.hide();
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_createActorCommandWindow =
|
||
Scene_Battle.prototype.createActorCommandWindow;
|
||
Scene_Battle.prototype.createActorCommandWindow = function () {
|
||
_Scene_Battle_createActorCommandWindow.call(this);
|
||
this._actorCommandWindow.homeY = this.getActorCommandY();
|
||
this._actorCommandWindow.SvActorData =
|
||
params.ActorCommandPosition === "svtop" ||
|
||
params.ActorCommandPosition === "svleft" ||
|
||
params.ActorCommandPosition === "svright"
|
||
? this._spriteset._actorSprites
|
||
: null;
|
||
if (params.ActorCommandBackgroundImg) {
|
||
const bitmap = ImageManager.nuun_LoadPictures(
|
||
params.ActorCommandBackgroundImg
|
||
);
|
||
const sprite = new Sprite(bitmap);
|
||
this._battleHudFront.addChild(sprite);
|
||
this._actorCommandBackgroundWindow = sprite;
|
||
sprite.x =
|
||
params.ActorBackground_X +
|
||
this._actorCommandWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
sprite.y =
|
||
params.ActorBackground_Y +
|
||
this._actorCommandWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
sprite.hide();
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_actorCommandWindowRect =
|
||
Scene_Battle.prototype.actorCommandWindowRect;
|
||
Scene_Battle.prototype.actorCommandWindowRect = function () {
|
||
const rect = _Scene_Battle_actorCommandWindowRect.call(this);
|
||
rect.width = this.actorCommandWidth();
|
||
rect.height = this.actorCommandHeight();
|
||
rect.x = this.getActorCommandX();
|
||
return rect;
|
||
};
|
||
|
||
Scene_Battle.prototype.actorCommandWidth = function () {
|
||
return params.ActorCommand_Width > 0
|
||
? Math.min(params.ActorCommand_Width, Graphics.width)
|
||
: 192;
|
||
};
|
||
|
||
Scene_Battle.prototype.actorCommandHeight = function () {
|
||
return this.calcWindowHeight(params.ActorCommandMaxRow, true);
|
||
};
|
||
|
||
Scene_Battle.prototype.getActorCommandX = function () {
|
||
if (
|
||
params.ActorCommandPosition === "top" ||
|
||
params.ActorCommandPosition === "middle" ||
|
||
params.ActorCommandPosition === "under" ||
|
||
params.ActorCommandPosition === "custom"
|
||
) {
|
||
return (
|
||
params.ActorCommand_X +
|
||
(params.ActorommandWindowCenter ? this.actorCommandCenter() : 0)
|
||
);
|
||
} else if (params.ActorCommandPosition === "default") {
|
||
return this.isRightInputMode()
|
||
? Graphics.boxWidth - this.actorCommandWidth()
|
||
: 0;
|
||
} else {
|
||
return params.ActorCommand_X;
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.getActorCommandY = function () {
|
||
switch (params.ActorCommandPosition) {
|
||
case "default":
|
||
return (
|
||
this._statusWindow.y +
|
||
this._statusWindow.height -
|
||
6 +
|
||
(Graphics.boxHeight - Graphics.height) / 2 -
|
||
(params.WindowFrameShow ? -6 : 0)
|
||
);
|
||
case "top":
|
||
case "svtop":
|
||
case "svleft":
|
||
case "svright":
|
||
case "custom":
|
||
return (
|
||
params.ActorCommand_Y + (Graphics.boxHeight - Graphics.height) / 2 + 4
|
||
);
|
||
case "middle":
|
||
return (
|
||
this._statusWindow.y / 2 +
|
||
(Graphics.boxHeight - Graphics.height) / 2 +
|
||
params.ActorCommand_Y
|
||
);
|
||
case "under":
|
||
case "actor":
|
||
return (
|
||
this._statusWindow.y -
|
||
4 +
|
||
(Graphics.boxHeight - Graphics.height) / 2 +
|
||
params.ActorCommand_Y
|
||
);
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.actorCommandCenter = function () {
|
||
return (Graphics.boxWidth - this.actorCommandWidth()) / 2;
|
||
};
|
||
|
||
Scene_Battle.prototype.actorWindowAreaHeight = function () {
|
||
return this.calcWindowHeight(params.ActorCommandMaxRow, true);
|
||
};
|
||
|
||
const _Scene_Battle_createActorWindow =
|
||
Scene_Battle.prototype.createActorWindow;
|
||
Scene_Battle.prototype.createActorWindow = function () {
|
||
//独自に定義するので処理しない
|
||
//_Scene_Battle_createActorWindow.call(this);
|
||
};
|
||
|
||
const _Scene_Battle_createItemWindow =
|
||
Scene_Battle.prototype.createItemWindow;
|
||
Scene_Battle.prototype.createItemWindow = function () {
|
||
_Scene_Battle_createItemWindow.call(this);
|
||
if (params.ItemWindowBackgroundImg) {
|
||
const x =
|
||
params.ItemBackground_X +
|
||
this._itemWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
const y =
|
||
params.ItemBackground_Y +
|
||
this._itemWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
const background = this.setBackgroundWindow(
|
||
params.ItemWindowBackgroundImg,
|
||
x,
|
||
y
|
||
);
|
||
this._itemWindow.setBSBackground(background);
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_createSkillWindow =
|
||
Scene_Battle.prototype.createSkillWindow;
|
||
Scene_Battle.prototype.createSkillWindow = function () {
|
||
_Scene_Battle_createSkillWindow.call(this);
|
||
if (params.SkillWindowBackgroundImg) {
|
||
const x =
|
||
params.SkillBackground_X +
|
||
this._skillWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
const y =
|
||
params.SkillBackground_Y +
|
||
this._skillWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
const background = this.setBackgroundWindow(
|
||
params.SkillWindowBackgroundImg,
|
||
x,
|
||
y
|
||
);
|
||
this._skillWindow.setBSBackground(background);
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_createEnemyWindow =
|
||
Scene_Battle.prototype.createEnemyWindow;
|
||
Scene_Battle.prototype.createEnemyWindow = function () {
|
||
_Scene_Battle_createEnemyWindow.call(this);
|
||
if (params.EnemyWindowBackgroundImg) {
|
||
const x =
|
||
params.EnemyWindowBackground_X +
|
||
this._enemyWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
const y =
|
||
params.EnemyWindowBackground_Y +
|
||
this._enemyWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
const background = this.setBackgroundWindow(
|
||
params.EnemyWindowBackgroundImg,
|
||
x,
|
||
y
|
||
);
|
||
this._enemyWindow.setBSBackground(background);
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_createHelpWindow =
|
||
Scene_Battle.prototype.createHelpWindow;
|
||
Scene_Battle.prototype.createHelpWindow = function () {
|
||
_Scene_Battle_createHelpWindow.call(this);
|
||
if (params.HelpWindowBackgroundImg) {
|
||
const x =
|
||
params.HelpBackground_X +
|
||
this._helpWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
const y =
|
||
params.HelpBackground_Y +
|
||
this._helpWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
const background = this.setBackgroundWindow(
|
||
params.HelpWindowBackgroundImg,
|
||
x,
|
||
y
|
||
);
|
||
this._helpWindow.setBSBackground(background);
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_createMessageWindow =
|
||
Scene_Battle.prototype.createMessageWindow;
|
||
Scene_Battle.prototype.createMessageWindow = function () {
|
||
_Scene_Battle_createMessageWindow.call(this);
|
||
this.MessageWindowBackGround();
|
||
};
|
||
|
||
Scene_Battle.prototype.enemyWindowRect = function () {
|
||
//再定義
|
||
const wx =
|
||
params.EnemyWindow_X +
|
||
(params.EnemyWindowMode ? 0 : (Graphics.boxWidth - Graphics.width) / 2);
|
||
const ww = this.enemyWindowWidth();
|
||
const wh = this.enemyWindowAreaHeight();
|
||
const wy =
|
||
params.EnemyWindow_Y +
|
||
(params.EnemyWindowMode
|
||
? Graphics.boxHeight - wh
|
||
: (Graphics.boxHeight - Graphics.height) / 2);
|
||
return new Rectangle(wx, wy, ww, wh);
|
||
};
|
||
|
||
Scene_Battle.prototype.enemyWindowWidth = function () {
|
||
return params.EnemyWindow_Width > 0
|
||
? Math.min(params.EnemyWindow_Width, Graphics.width)
|
||
: this._statusWindow.width;
|
||
};
|
||
|
||
Scene_Battle.prototype.enemyWindowAreaHeight = function () {
|
||
return this.calcWindowHeight(params.EnemyMaxRow, true);
|
||
};
|
||
|
||
const _Scene_Battle_partyCommandWindowRect =
|
||
Scene_Battle.prototype.partyCommandWindowRect;
|
||
Scene_Battle.prototype.partyCommandWindowRect = function () {
|
||
const rect = _Scene_Battle_partyCommandWindowRect.call(this);
|
||
if (params.PartyCommandPosition === "default") {
|
||
rect.width = this.partyCommandWidth(1);
|
||
rect.x = this.isRightInputMode()
|
||
? Graphics.boxWidth - this.partyCommandWidth(1)
|
||
: 0;
|
||
rect.y = this.partyCommand_YPosition(0);
|
||
} else if (params.PartyCommandPosition === "custom") {
|
||
rect.width = this.partyCommandWidth(1);
|
||
rect.x = this.getPartyCommandX();
|
||
rect.y = this.partyCommand_YPosition(10);
|
||
} else if (params.PartyCommandPosition === "top") {
|
||
rect.width = this.partyCommandWidth(0);
|
||
rect.x = this.getPartyCommandX();
|
||
rect.y = this.partyCommand_YPosition(1);
|
||
} else if (params.PartyCommandPosition === "middle") {
|
||
rect.width = this.partyCommandWidth(0);
|
||
rect.x = this.getPartyCommandX();
|
||
rect.y = this.partyCommand_YPosition(2);
|
||
} else if (params.PartyCommandPosition === "under") {
|
||
rect.width = this.partyCommandWidth(0);
|
||
rect.x = this.getPartyCommandX();
|
||
rect.y = this.partyCommand_YPosition(3);
|
||
}
|
||
rect.height = this.partyWindowAreaHeight();
|
||
return rect;
|
||
};
|
||
|
||
Scene_Battle.prototype.getDefaultPartyCommandPositionMode = function () {
|
||
return (
|
||
params.PartyCommandPosition === "default" ||
|
||
params.ActorCommandPosition === "default"
|
||
);
|
||
};
|
||
|
||
Scene_Battle.prototype.statusWindowRect = function () {
|
||
let ww = this.getActorWindowWidth();
|
||
let wh = this.getActorWindowHeight();
|
||
let wx =
|
||
this.getActorWindowX() +
|
||
(this.getDefaultPartyCommandPositionMode()
|
||
? this.isRightInputMode()
|
||
? 0
|
||
: Graphics.boxWidth - ww
|
||
: 0);
|
||
let wy = this.getActorWindowY();
|
||
return new Rectangle(wx, wy, ww, wh);
|
||
};
|
||
|
||
Scene_Battle.prototype.actorStatusWindowRect = function () {
|
||
let ww = Graphics.width + 40;
|
||
let wh = Graphics.height + 40;
|
||
let wx = -20;
|
||
let wy = -20;
|
||
return new Rectangle(wx, wy, ww, wh);
|
||
};
|
||
|
||
Scene_Battle.prototype.setBackgroundWindow = function (background, x, y) {
|
||
const bitmap = ImageManager.nuun_LoadPictures(background);
|
||
const sprite = new Sprite(bitmap);
|
||
this._itemBSBackgorundWindow.addChild(sprite);
|
||
sprite.x = x;
|
||
sprite.y = y;
|
||
return sprite;
|
||
};
|
||
|
||
const _Scene_Battle_updateStatusWindowPosition =
|
||
Scene_Battle.prototype.updateStatusWindowPosition;
|
||
Scene_Battle.prototype.updateStatusWindowPosition = function () {
|
||
if (!params.ActorStatusWindowLock) {
|
||
const statusWindowX = this._statusWindow.x;
|
||
const targetX = this.statusWindowX();
|
||
const battleEffects = this._battleEffects;
|
||
_Scene_Battle_updateStatusWindowPosition.call(this);
|
||
if (statusWindowX < targetX) {
|
||
if (!$gameSystem.isSideView() && battleEffects) {
|
||
battleEffects.x = Math.min(battleEffects.x + 16, targetX);
|
||
}
|
||
this._actorImges.x = Math.min(this._actorImges.x + 16, targetX);
|
||
this._actorStatus.x = Math.min(this._actorStatus.x + 16, targetX);
|
||
if (this._backgroundWindow) {
|
||
this._backgroundWindow.x =
|
||
this._statusWindow.x + params.WindowBackground_X;
|
||
}
|
||
}
|
||
if (statusWindowX > targetX) {
|
||
if (!$gameSystem.isSideView() && battleEffects) {
|
||
battleEffects.x = Math.max(battleEffects.x - 16, targetX);
|
||
}
|
||
this._actorImges.x = Math.max(this._actorImges.x - 16, targetX);
|
||
this._actorStatus.x = Math.max(this._actorStatus.x - 16, targetX);
|
||
if (this._backgroundWindow) {
|
||
this._backgroundWindow.x =
|
||
this._statusWindow.x + params.WindowBackground_X;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_update = Scene_Battle.prototype.update;
|
||
Scene_Battle.prototype.update = function () {
|
||
_Scene_Battle_update.call(this); //サポートアクターは暫定処置
|
||
const actor = this._actorCommandWindow.actor();
|
||
if (
|
||
this._statusWindow.isCommandRefresh() &&
|
||
!$gameTemp.isBattleRefreshRequested() &&
|
||
actor
|
||
) {
|
||
this._statusWindow.commandRefresh(false);
|
||
if (Imported.NUUN_SupportActor) {
|
||
$gameParty.setWithSupportActorMember();
|
||
}
|
||
const index = $gameParty.battleMembers().indexOf(actor);
|
||
if (index >= 0) {
|
||
if (Imported.NUUN_SupportActor && !actor.getSupportActor()) {
|
||
this._statusWindow.select(index);
|
||
}
|
||
} else {
|
||
this.commandCancel();
|
||
}
|
||
this._actorCommandWindow.refresh();
|
||
}
|
||
if (params.ActorCommandBackgroundImg) {
|
||
this._actorCommandBackgroundWindow.x =
|
||
params.ActorBackground_X +
|
||
this._actorCommandWindow.x +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
this._actorCommandBackgroundWindow.y =
|
||
params.ActorBackground_Y +
|
||
this._actorCommandWindow.y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
this._actorCommandBackgroundWindow.visible =
|
||
this._actorCommandWindow.visible &&
|
||
this._actorCommandWindow.active &&
|
||
this._actorCommandWindow.openness > 0;
|
||
}
|
||
if (this._partyCommandBackgroundWindow) {
|
||
this._partyCommandBackgroundWindow.visible =
|
||
this._partyCommandWindow.visible && this._partyCommandWindow.active;
|
||
}
|
||
this._enemyWindow.bsUpdateBackground();
|
||
this._itemWindow.bsUpdateBackground();
|
||
this._skillWindow.bsUpdateBackground();
|
||
this._helpWindow.bsUpdateBackground();
|
||
this.bsMessageBackground();
|
||
this.actorStatusWindowOpacity();
|
||
};
|
||
|
||
Scene_Battle.prototype.bsMessageBackground = function () {
|
||
if (
|
||
BattleManager.getDisplayMessageType() === "Appear" &&
|
||
params.AppearBackgroundImg
|
||
) {
|
||
this._messageBackground.bitmap = ImageManager.nuun_LoadPictures(
|
||
params.AppearBackgroundImg
|
||
);
|
||
this._messageBackground.x =
|
||
this._messageWindow.x +
|
||
params.AppearBackground_X +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
this._messageBackground.y =
|
||
this._messageWindow.y +
|
||
params.AppearBackground_Y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "Victory" &&
|
||
params.VictoryBackgroundImg
|
||
) {
|
||
this._messageBackground.bitmap = ImageManager.nuun_LoadPictures(
|
||
params.VictoryBackgroundImg
|
||
);
|
||
this._messageBackground.x =
|
||
this._messageWindow.x +
|
||
params.VictoryBackground_X +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
this._messageBackground.y =
|
||
this._messageWindow.y +
|
||
params.VictoryBackground_Y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "Defeat" &&
|
||
params.LoseBackgroundImg
|
||
) {
|
||
this._messageBackground.bitmap = ImageManager.nuun_LoadPictures(
|
||
params.LoseBackgroundImg
|
||
);
|
||
this._messageBackground.x =
|
||
this._messageWindow.x +
|
||
params.LoseBackground_X +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
this._messageBackground.y =
|
||
this._messageWindow.y +
|
||
params.LoseBackground_Y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "Escape" &&
|
||
params.EscapeBackgroundImg
|
||
) {
|
||
this._messageBackground.bitmap = ImageManager.nuun_LoadPictures(
|
||
params.EscapeBackgroundImg
|
||
);
|
||
this._messageBackground.x =
|
||
this._messageWindow.x +
|
||
params.EscapeBackground_X +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
this._messageBackground.y =
|
||
this._messageWindow.y +
|
||
params.EscapeBackground_Y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "EscapeFailure" &&
|
||
params.EscapeFailureBackgroundImg
|
||
) {
|
||
this._messageBackground.bitmap = ImageManager.nuun_LoadPictures(
|
||
params.EscapeFailureBackgroundImg
|
||
);
|
||
this._messageBackground.x =
|
||
this._messageWindow.x +
|
||
params.EscapeFailureBackground_X +
|
||
(Graphics.width - Graphics.boxWidth) / 2;
|
||
this._messageBackground.y =
|
||
this._messageWindow.y +
|
||
params.EscapeFailureBackground_Y +
|
||
(Graphics.height - Graphics.boxHeight) / 2;
|
||
} else {
|
||
this._messageBackground.bitmap = null;
|
||
this._messageBackground.x = this._messageWindow.x;
|
||
this._messageBackground.y = this._messageWindow.y;
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.actorStatusWindowOpacity = function () {
|
||
if (BattleManager.actorStatusWindowOpacity) {
|
||
this.setActorStatusWindowOpacity(
|
||
BattleManager.actorStatusWindowOpacityValue
|
||
);
|
||
} else if (this._skillWindow.active) {
|
||
this.setActorStatusWindowOpacity(params.SkillWindowOpacity);
|
||
} else if (this._itemWindow.active) {
|
||
this.setActorStatusWindowOpacity(params.ItemWindowOpacity);
|
||
} else if (this._enemyWindow.active) {
|
||
this.setActorStatusWindowOpacity(params.EnemyWindowOpacity);
|
||
} else if (
|
||
$gameMessage.isBusy() &&
|
||
BattleManager.getDisplayMessageType() === "Appear" &&
|
||
$gameMessage.positionType() === 2
|
||
) {
|
||
this.setActorStatusWindowOpacity(params.AppearWindowOpacity);
|
||
} else if (
|
||
$gameMessage.isBusy() &&
|
||
BattleManager.getDisplayMessageType() === "Victory" &&
|
||
$gameMessage.positionType() === 2
|
||
) {
|
||
this.setActorStatusWindowOpacity(params.VictoryWindowOpacity);
|
||
} else if (
|
||
$gameMessage.isBusy() &&
|
||
BattleManager.getDisplayMessageType() === "Defeat" &&
|
||
$gameMessage.positionType() === 2
|
||
) {
|
||
this.setActorStatusWindowOpacity(params.LoseWindowOpacity);
|
||
} else if (
|
||
$gameMessage.isBusy() &&
|
||
BattleManager.getDisplayMessageType() === "Escape" &&
|
||
$gameMessage.positionType() === 2
|
||
) {
|
||
this.setActorStatusWindowOpacity(params.EscapeWindowOpacity);
|
||
} else if (
|
||
$gameMessage.isBusy() &&
|
||
BattleManager.getDisplayMessageType() === "EscapeFailure" &&
|
||
$gameMessage.positionType() === 2
|
||
) {
|
||
this.setActorStatusWindowOpacity(params.EscapeWindowOpacity);
|
||
} else if ($gameMessage.isBusy() && $gameMessage.positionType() === 2) {
|
||
this.setActorStatusWindowOpacity(params.MessageWindowOpacity);
|
||
} else {
|
||
this.setActorStatusWindowOpacity(255);
|
||
if (!$gameMessage.isBusy()) {
|
||
BattleManager.displayMessageType(null);
|
||
}
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.setActorStatusWindowOpacity = function (opacity) {
|
||
this._battleHudBack.opacity = opacity;
|
||
this._battleHudFront.opacity = opacity;
|
||
};
|
||
|
||
const _Scene_Battle_createCancelButton =
|
||
Scene_Battle.prototype.createCancelButton;
|
||
Scene_Battle.prototype.createCancelButton = function () {
|
||
_Scene_Battle_createCancelButton.call(this);
|
||
if (params.ButtonMode === "left") {
|
||
this._cancelButton.x = 4 + params.CancelButtonX;
|
||
} else {
|
||
this._cancelButton.x += params.CancelButtonX;
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.statusWindowX = function () {
|
||
//再定義
|
||
if (this.isAnyInputWindowActive()) {
|
||
return this.statusWindowRect().x;
|
||
} else {
|
||
return (
|
||
this._partyCommandWindow.width / 2 +
|
||
(Graphics.width - Graphics.boxWidth) / 2
|
||
);
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.getActorWindowX = function () {
|
||
if (params.ActorStatusWindowCenter) {
|
||
return getActorWindowCenter() + params.ActorStatusWindow_X;
|
||
} else {
|
||
return params.ActorStatusWindow_X;
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.getActorWindowY = function () {
|
||
if (params.ActorStatusWindowPosition === "ui_under") {
|
||
return (
|
||
Graphics.boxHeight -
|
||
this.getActorWindowHeight() +
|
||
6 +
|
||
params.ActorStatusWindow_Y +
|
||
(Graphics.height - Graphics.boxHeight) / 2 +
|
||
(params.WindowFrameShow ? -6 : 0)
|
||
);
|
||
} else if (params.ActorStatusWindowPosition === "under") {
|
||
return (
|
||
Graphics.height -
|
||
this.getActorWindowHeight() +
|
||
params.ActorStatusWindow_Y +
|
||
(params.WindowFrameShow ? -6 : 0)
|
||
);
|
||
} else {
|
||
return params.ActorStatusWindow_Y;
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.setStatusWindow_Sprite = function () {
|
||
statusData = this._statusWindow;
|
||
};
|
||
|
||
Scene_Battle.prototype.MessageWindowBackGround = function () {
|
||
this._messageBackground = this.setBackgroundWindow(null, 0, 0);
|
||
};
|
||
|
||
Scene_Battle.prototype.getActorWindowWidth = function () {
|
||
return (
|
||
(params.ActorStatusWindow_Width > 0
|
||
? params.ActorStatusWindow_Width
|
||
: Graphics.boxWidth) -
|
||
(params.WidthWithCommand ? this.partyCommandWidth() : 0)
|
||
);
|
||
};
|
||
|
||
Scene_Battle.prototype.getActorWindowHeight = function () {
|
||
return params.ActorStatusWindow_Height > 0
|
||
? params.ActorStatusWindow_Height
|
||
: this.windowAreaHeight() + (params.WindowFrameShow ? 0 : 10);
|
||
};
|
||
|
||
Scene_Battle.prototype.getPartyCommandX = function () {
|
||
return (
|
||
params.PartyCommand_X +
|
||
(params.PartyCommandWindowCenter ? this.partyCommandCenter() : 0)
|
||
);
|
||
};
|
||
|
||
Scene_Battle.prototype.partyCommandCenter = function () {
|
||
return (Graphics.boxWidth - this.partyCommandWidth(0)) / 2;
|
||
};
|
||
|
||
Scene_Battle.prototype.partyCommand_YPosition = function (mode) {
|
||
if (mode === 0) {
|
||
//デフォルト
|
||
return (
|
||
this._statusWindow.y +
|
||
(Graphics.boxHeight - Graphics.height) / 2 +
|
||
(params.WindowFrameShow ? 0 : 4)
|
||
);
|
||
} else if (mode === 10) {
|
||
//カスタム
|
||
return params.PartyCommand_Y;
|
||
} else if (mode === 1) {
|
||
//上部
|
||
return (
|
||
params.PartyCommand_Y + (Graphics.boxHeight - Graphics.height) / 2 + 4
|
||
);
|
||
} else if (mode === 2) {
|
||
//中間
|
||
return (
|
||
this._statusWindow.y / 2 -
|
||
this.partyWindowAreaHeight() / 2 +
|
||
(Graphics.boxHeight - Graphics.height) / 2 +
|
||
params.PartyCommand_Y
|
||
);
|
||
} else if (mode === 3) {
|
||
//アクターステータス上
|
||
return (
|
||
this._statusWindow.y -
|
||
this.partyWindowAreaHeight() +
|
||
(Graphics.boxHeight - Graphics.height) / 2 +
|
||
params.PartyCommand_Y
|
||
);
|
||
}
|
||
};
|
||
|
||
Scene_Battle.prototype.partyCommandWidth = function (mode) {
|
||
return params.PartyCommand_Width > 0
|
||
? Math.min(params.PartyCommand_Width, Graphics.width)
|
||
: mode === 0
|
||
? Graphics.boxWidth
|
||
: 192;
|
||
};
|
||
|
||
Scene_Battle.prototype.partyWindowAreaHeight = function () {
|
||
return this.calcWindowHeight(params.PartyCommandMaxRow, true);
|
||
};
|
||
|
||
const _Scene_Battle_startActorSelection =
|
||
Scene_Battle.prototype.startActorSelection;
|
||
Scene_Battle.prototype.startActorSelection = function () {
|
||
_Scene_Battle_startActorSelection.call(this);
|
||
this._skillWindow.hide();
|
||
this._itemWindow.hide();
|
||
this._statusWindow.deselect();
|
||
};
|
||
|
||
const _Scene_Battle_startEnemySelection =
|
||
Scene_Battle.prototype.startEnemySelection;
|
||
Scene_Battle.prototype.startEnemySelection = function () {
|
||
_Scene_Battle_startEnemySelection.call(this);
|
||
this._statusWindow.show();
|
||
this._skillWindow.hide();
|
||
this._itemWindow.hide();
|
||
if (!this.commandDefaultMode()) {
|
||
this._actorCommandWindow.hide();
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_onEnemyCancel = Scene_Battle.prototype.onEnemyCancel;
|
||
Scene_Battle.prototype.onEnemyCancel = function () {
|
||
_Scene_Battle_onEnemyCancel.call(this);
|
||
$gameTemp.onBSAction = false;
|
||
switch (this._actorCommandWindow.currentSymbol()) {
|
||
case "attack":
|
||
case "special":
|
||
this._actorCommandWindow.show();
|
||
break;
|
||
}
|
||
};
|
||
|
||
const _Scene_Battle_onActorCancel = Scene_Battle.prototype.onActorCancel;
|
||
Scene_Battle.prototype.onActorCancel = function () {
|
||
_Scene_Battle_onActorCancel.call(this);
|
||
$gameTemp.onBSAction = false;
|
||
};
|
||
|
||
const _Scene_Battle_startPartyCommandSelection =
|
||
Scene_Battle.prototype.startPartyCommandSelection;
|
||
Scene_Battle.prototype.startPartyCommandSelection = function () {
|
||
_Scene_Battle_startPartyCommandSelection.call(this);
|
||
$gameTemp.onBSAction = false;
|
||
};
|
||
|
||
const _Scene_Battle_selectPreviousCommand =
|
||
Scene_Battle.prototype.selectPreviousCommand;
|
||
Scene_Battle.prototype.selectPreviousCommand = function () {
|
||
_Scene_Battle_selectPreviousCommand.call(this);
|
||
$gameTemp.onBSAction = false;
|
||
this._partyCommandWindow.show();
|
||
};
|
||
|
||
const _Scene_Battle_onSelectAction = Scene_Battle.prototype.onSelectAction;
|
||
Scene_Battle.prototype.onSelectAction = function () {
|
||
$gameTemp.onBSAction = BattleManager.isTpb() && !this.commandDefaultMode();
|
||
_Scene_Battle_onSelectAction.call(this);
|
||
};
|
||
|
||
const _Scene_Battle_endCommandSelection =
|
||
Scene_Battle.prototype.endCommandSelection;
|
||
Scene_Battle.prototype.endCommandSelection = function () {
|
||
_Scene_Battle_endCommandSelection.call(this);
|
||
$gameTemp.onBSAction = false;
|
||
};
|
||
|
||
const _Scene_Battle_commandSkill = Scene_Battle.prototype.commandSkill;
|
||
Scene_Battle.prototype.commandSkill = function () {
|
||
_Scene_Battle_commandSkill.call(this);
|
||
this._statusWindow.show();
|
||
};
|
||
|
||
const _Scene_Battle_commandItem = Scene_Battle.prototype.commandItem;
|
||
Scene_Battle.prototype.commandItem = function () {
|
||
_Scene_Battle_commandItem.call(this);
|
||
this._statusWindow.show();
|
||
};
|
||
|
||
const _Scene_Battle_selectNextCommand =
|
||
Scene_Battle.prototype.selectNextCommand;
|
||
Scene_Battle.prototype.selectNextCommand = function () {
|
||
_Scene_Battle_selectNextCommand.call(this);
|
||
$gameTemp.onBSAction = false;
|
||
};
|
||
|
||
Scene_Battle.prototype.commandDefaultMode = function () {
|
||
return params.bsMode === "Default" || params.bsMode === "Standard";
|
||
};
|
||
|
||
//Window_Base
|
||
Window_Base.prototype.setBSBackground = function (background) {
|
||
this._bsBackground = background;
|
||
};
|
||
|
||
Window_Base.prototype.bsUpdateBackground = function () {
|
||
if (this._bsBackground) {
|
||
this._bsBackground.visible = this.visible;
|
||
}
|
||
};
|
||
|
||
const _Window_Selectable_paint = Window_Selectable.prototype.paint;
|
||
Window_Selectable.prototype.paint = function () {
|
||
const className = String(this.constructor.name);
|
||
if (className === "Window_ActorCommand") {
|
||
this.setCommandHeight();
|
||
}
|
||
_Window_Selectable_paint.call(this);
|
||
};
|
||
|
||
//Window_PartyCommand
|
||
const _Window_PartyCommand_initialize =
|
||
Window_PartyCommand.prototype.initialize;
|
||
Window_PartyCommand.prototype.initialize = function (rect) {
|
||
_Window_PartyCommand_initialize.call(this, rect);
|
||
this.windowColor = null;
|
||
this.opacity = params.PartyCommandWindowShow ? 255 : 0;
|
||
};
|
||
|
||
Window_PartyCommand.prototype.loadWindowskin = function () {
|
||
if (params.PartyCommandWindowSkin) {
|
||
this.windowskin = ImageManager.loadSystem(params.PartyCommandWindowSkin);
|
||
this.windowColor = params.ActorStatusWindowColor;
|
||
} else {
|
||
Window_Base.prototype.loadWindowskin.call(this);
|
||
}
|
||
};
|
||
|
||
Window_PartyCommand.prototype.updateTone = function () {
|
||
if (params.PartyCommandWindowColor) {
|
||
const tone = params.PartyCommandWindowColor;
|
||
this.setTone(tone.red, tone.green, tone.bule);
|
||
} else {
|
||
Window_Base.prototype.updateTone.call(this);
|
||
}
|
||
};
|
||
|
||
Window_PartyCommand.prototype.maxCols = function () {
|
||
return params.PartyCommandMode
|
||
? params.PartyCommandMaxCol
|
||
: Math.min(
|
||
this._list ? this.maxItems() : params.PartyCommandMaxCol,
|
||
params.PartyCommandMaxCol
|
||
);
|
||
};
|
||
|
||
const _Window_PartyCommand_itemRect = Window_PartyCommand.prototype.itemRect;
|
||
Window_PartyCommand.prototype.itemRect = function (index) {
|
||
const rect = _Window_PartyCommand_itemRect.call(this, index);
|
||
if (params.PartyCommandMode) {
|
||
rect.x +=
|
||
(this.itemWidth() / 2) *
|
||
(this.maxCols() - Math.min(this.maxItems(), this.maxCols()));
|
||
}
|
||
return rect;
|
||
};
|
||
|
||
const _Window_PartyCommand_setup = Window_PartyCommand.prototype.setup;
|
||
Window_PartyCommand.prototype.setup = function () {
|
||
if (!$gameTemp.onBSAction) {
|
||
_Window_PartyCommand_setup.call(this);
|
||
} else {
|
||
$gameTemp.onBSAction = false;
|
||
}
|
||
};
|
||
|
||
//Window_ActorCommand
|
||
const _Window_ActorCommand_initialize =
|
||
Window_ActorCommand.prototype.initialize;
|
||
Window_ActorCommand.prototype.initialize = function (rect) {
|
||
_Window_ActorCommand_initialize.call(this, rect);
|
||
this.opacity = params.ActorCommandWindowShow ? 255 : 0;
|
||
};
|
||
|
||
Window_ActorCommand.prototype.loadWindowskin = function () {
|
||
if (params.ActorCommandWindowSkin) {
|
||
this.windowskin = ImageManager.loadSystem(params.ActorCommandWindowSkin);
|
||
} else {
|
||
Window_Base.prototype.loadWindowskin.call(this);
|
||
}
|
||
};
|
||
|
||
Window_ActorCommand.prototype.setWindowSkin = function (data) {
|
||
if (data.WindowSkin) {
|
||
this.windowskin = ImageManager.loadSystem(data.WindowSkin);
|
||
this.windowColor = data.WindowColor;
|
||
} else {
|
||
this.loadWindowskin();
|
||
this.windowColor = null;
|
||
}
|
||
};
|
||
|
||
Window_ActorCommand.prototype.updateTone = function () {
|
||
if (this.windowColor) {
|
||
const tone = this.windowColor;
|
||
this.setTone(tone.red, tone.green, tone.bule);
|
||
} else {
|
||
Window_Base.prototype.updateTone.call(this);
|
||
}
|
||
};
|
||
|
||
Window_ActorCommand.prototype.maxCols = function () {
|
||
return params.ActorCommandMode
|
||
? params.ActorCommandMaxCol
|
||
: Math.min(
|
||
this._list ? this.maxItems() : params.ActorCommandMaxCol,
|
||
params.ActorCommandMaxCol
|
||
);
|
||
//return Math.min((this._list ? this.maxItems() : params.ActorCommandMaxCol), params.ActorCommandMaxCol);
|
||
};
|
||
|
||
Window_ActorCommand.prototype.setCommandHeight = function () {
|
||
const maxCols = params.ActorCommandVariable
|
||
? Math.ceil(this.maxItems() / params.ActorCommandMaxCol)
|
||
: params.ActorCommandMaxRow;
|
||
const cols = params.ActorCommandVariable
|
||
? maxCols.clamp(params.ActorCommandMinRow, params.ActorCommandMaxRow)
|
||
: maxCols;
|
||
this.height = this.fittingHeight(cols);
|
||
};
|
||
|
||
Window_ActorCommand.prototype.selectActor = function (actor) {
|
||
const members = $gameParty.battleMembers();
|
||
return members.indexOf(actor);
|
||
};
|
||
|
||
const _Window_ActorCommand_itemRect = Window_ActorCommand.prototype.itemRect;
|
||
Window_ActorCommand.prototype.itemRect = function (index) {
|
||
const rect = _Window_ActorCommand_itemRect.call(this, index);
|
||
if (params.ActorCommandMode) {
|
||
rect.x +=
|
||
(this.itemWidth() / 2) *
|
||
(this.maxCols() - Math.min(this.maxItems(), this.maxCols()));
|
||
}
|
||
return rect;
|
||
};
|
||
|
||
const _Window_ActorCommand_refresh = Window_ActorCommand.prototype.refresh;
|
||
Window_ActorCommand.prototype.refresh = function () {
|
||
_Window_ActorCommand_refresh.call(this);
|
||
const actorIndex = this.selectActor(this._actor);
|
||
if ((statusData && this._actor) || actorIndex >= 0) {
|
||
const data = getActorPositionData(this._actor.actorId());
|
||
this.setWindowSkin(data);
|
||
const rect = statusData.itemRect(actorIndex);
|
||
//this.setCommandHeight();
|
||
if (params.ActorCommandPosition === "actor") {
|
||
if (Imported.NUUN_SupportActor && this._actor.getSupportActor()) {
|
||
this.x = params.SupportActorCommand_X;
|
||
this.y = params.SupportActorCommand_Y;
|
||
} else {
|
||
this.x =
|
||
rect.x +
|
||
(statusData.x - (Graphics.width - Graphics.boxWidth) / 2) +
|
||
statusData.itemPadding() +
|
||
(rect.width - this.width) / 2 +
|
||
params.ActorCommand_X;
|
||
this.y = this.homeY - this.height + rect.y;
|
||
}
|
||
} else if (params.ActorCommandPosition === "svtop") {
|
||
data = this.SvActorData[actorIndex];
|
||
this.x =
|
||
data.x - (this.width + data.width) / 2 + 32 + params.ActorCommand_X;
|
||
this.y =
|
||
data.y - (this.height + data.height + 48) + params.ActorCommand_Y;
|
||
} else if (params.ActorCommandPosition === "svleft") {
|
||
data = this.SvActorData[actorIndex];
|
||
this.x = data.x - this.width - 32 + params.ActorCommand_X;
|
||
this.y =
|
||
data.y - (this.height + data.height + 48) / 2 + params.ActorCommand_Y;
|
||
} else if (params.ActorCommandPosition === "svright") {
|
||
data = this.SvActorData[actorIndex];
|
||
this.x = data.x + 32 + params.ActorCommand_X;
|
||
this.y =
|
||
data.y - (this.height + data.height + 48) / 2 + params.ActorCommand_Y;
|
||
} else if (params.ActorCommandPosition === "top") {
|
||
this.y = this.homeY;
|
||
} else if (params.ActorCommandPosition === "middle") {
|
||
this.y = this.homeY - Math.floor(this.height / 2);
|
||
} else {
|
||
this.y = this.homeY - this.height;
|
||
}
|
||
}
|
||
};
|
||
|
||
//Window_BattleStatus
|
||
const _Window_BattleStatus_initialize =
|
||
Window_BattleStatus.prototype.initialize;
|
||
Window_BattleStatus.prototype.initialize = function (rect) {
|
||
_Window_BattleStatus_initialize.call(this, rect);
|
||
this.frameVisible = params.WindowFrameShow;
|
||
this.opacity = params.WindowShow ? 255 : 0;
|
||
this._opening = true;
|
||
this.visible = true;
|
||
$gameTemp.actorData = null;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.loadWindowskin = function () {
|
||
if (params.ActorStatusWindowSkin) {
|
||
this.windowskin = ImageManager.loadSystem(params.ActorStatusWindowSkin);
|
||
} else {
|
||
Window_Base.prototype.loadWindowskin.call(this);
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.updateTone = function () {
|
||
if (params.ActorStatusWindowColor) {
|
||
const tone = params.ActorStatusWindowColor;
|
||
this.setTone(tone.red, tone.green, tone.bule);
|
||
} else {
|
||
Window_Base.prototype.updateTone.call(this);
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_maxCols = Window_BattleStatus.prototype.maxCols;
|
||
Window_BattleStatus.prototype.maxCols = function () {
|
||
return params.ActorStatusVariable
|
||
? Math.min(
|
||
$gameParty.battleMembers().length,
|
||
_Window_BattleStatus_maxCols.call(this),
|
||
params.ActorMaxCol
|
||
)
|
||
: params.ActorMaxCol;
|
||
};
|
||
|
||
const _Window_BattleStatus_itemHeight =
|
||
Window_BattleStatus.prototype.itemHeight;
|
||
Window_BattleStatus.prototype.itemHeight = function () {
|
||
const row =
|
||
params.ActorMaxRow > 0
|
||
? params.ActorMaxRow
|
||
: Math.ceil($gameParty.battleMembers().length / this.maxCols());
|
||
return Math.floor(_Window_BattleStatus_itemHeight.call(this) / row);
|
||
};
|
||
|
||
const _Window_BattleStatus_rowSpacing =
|
||
Window_BattleStatus.prototype.rowSpacing;
|
||
Window_BattleStatus.prototype.rowSpacing = function () {
|
||
return Math.ceil($gameParty.battleMembers().length / this.maxCols()) > 1
|
||
? 4
|
||
: _Window_BattleStatus_rowSpacing.call(this);
|
||
};
|
||
|
||
Window_BattleStatus.prototype.itemRect = function (index) {
|
||
let rect = Window_Selectable.prototype.itemRect.call(this, index);
|
||
rect = this.statusPosition(index, rect);
|
||
return rect;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.faceRect = function (index) {
|
||
//再定義
|
||
const rect = this.itemRect(index);
|
||
rect.pad(-1);
|
||
let height;
|
||
if (params.bsMode === "Standard") {
|
||
height =
|
||
params.FaceHeight > 0
|
||
? Math.min(params.FaceHeight, ImageManager.faceHeight)
|
||
: ImageManager.faceHeight;
|
||
rect.height = params.FaceHeightOnWindow
|
||
? Math.min(rect.height, height)
|
||
: height;
|
||
//rect.x -= Math.floor((rect.width / 2) - (ImageManager.faceWidth / 2));
|
||
} else if (params.bsMode === "Type4") {
|
||
height =
|
||
params.FaceHeight > 0
|
||
? Math.min(params.FaceHeight, ImageManager.faceHeight)
|
||
: ImageManager.faceHeight;
|
||
rect.height = params.FaceHeightOnWindow
|
||
? Math.min(rect.height, height)
|
||
: height;
|
||
} else {
|
||
height =
|
||
params.FaceHeight > 0
|
||
? Math.min(params.FaceHeight, ImageManager.faceHeight)
|
||
: this.basicGaugesY(rect) -
|
||
this.gaugeLineHeight() +
|
||
this.gaugeLineHeight() / 2 -
|
||
rect.y;
|
||
rect.height = params.FaceHeightOnWindow
|
||
? Math.min(rect.height, height)
|
||
: height;
|
||
}
|
||
rect.y += this.colSpacing();
|
||
return rect;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.preparePartyRefresh = function () {
|
||
this.performPartyRefresh();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.performPartyRefresh = function () {
|
||
$gameTemp.setBattleStyleRefresh(true);
|
||
this.refresh();
|
||
this.commandRefresh(true);
|
||
};
|
||
|
||
Window_BattleStatus.prototype.commandRefresh = function (flag) {
|
||
this._commandRefresh = flag;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.isCommandRefresh = function () {
|
||
return this._commandRefresh;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.setActorWindow = function (
|
||
battleActorImges,
|
||
BattleActorStatus
|
||
) {
|
||
this._window_battleActorImges = battleActorImges;
|
||
this._window_BattleActorStatus = BattleActorStatus;
|
||
};
|
||
|
||
const _Window_BattleStatus_refreshCursor =
|
||
Window_BattleStatus.prototype.refreshCursor;
|
||
Window_BattleStatus.prototype.refreshCursor = function () {
|
||
if (params.SelectBackShow) {
|
||
_Window_BattleStatus_refreshCursor.call(this);
|
||
} else {
|
||
this.setCursorRect(0, 0, 0, 0);
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.statusPosition = function (index, rect) {
|
||
const itemWidth = this.itemWidth();
|
||
const maxCols = Math.min(
|
||
this.maxItems() - Math.floor(index / this.maxCols()) * this.maxCols(),
|
||
this.maxCols(),
|
||
this.maxItems()
|
||
);
|
||
if (params.ActorStatusMode === "center") {
|
||
rect.x +=
|
||
Math.floor(this.width / 2 - (itemWidth * maxCols) / 2) -
|
||
this.itemPadding();
|
||
} else if (params.ActorStatusMode === "raigt") {
|
||
rect.x += this.width - maxCols * itemWidth - this.itemPadding() * 2;
|
||
} else if (params.ActorStatusMode === "triangle") {
|
||
//const topCol = this.maxItems() % maxCols;
|
||
//console.log(topCol)
|
||
if (index < topCol) {
|
||
rect.x +=
|
||
Math.floor(this.width / 2 - (itemWidth * topCol) / 2) -
|
||
this.itemPadding();
|
||
} else {
|
||
rect.x +=
|
||
Math.floor(this.width / 2 - (itemWidth * maxCols) / 2) -
|
||
this.itemPadding();
|
||
}
|
||
} else if (params.ActorStatusMode === "Inverted_triangle") {
|
||
}
|
||
return rect;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawItem = function (index) {};
|
||
|
||
Window_BattleStatus.prototype.drawItemBackground = function (index) {
|
||
const actor = this.actor(index);
|
||
const data = getActorPositionData(actor.actorId());
|
||
if (data.ActorBackground) {
|
||
const rect = this.itemRect(index);
|
||
const bitmap = ImageManager.nuun_LoadPictures(data.ActorBackground);
|
||
this.actorBackGround(
|
||
actor,
|
||
bitmap,
|
||
rect.x,
|
||
rect.y,
|
||
rect.width,
|
||
rect.height
|
||
);
|
||
} else if (params.CursorBackShow) {
|
||
Window_Selectable.prototype.drawItemBackground.call(this, index);
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawItemStatus = function (index) {
|
||
//再定義
|
||
const actor = this.actor(index);
|
||
$gameTemp.actorData = getActorPositionData(actor.actorId());
|
||
const statusData = $gameTemp.actorData.StatusListData;
|
||
if (statusData && statusData.length > 0) {
|
||
this.drawStatusListData(actor, statusData, index);
|
||
} else {
|
||
const rect = this.itemRectWithPadding(index);
|
||
this.getGaugeMaxWidth(rect.width, rect.width);
|
||
const stateIconX = this.stateIconX(rect);
|
||
const stateIconY = this.stateIconY(rect);
|
||
if (params.StateVisible && !params.OutsideWindowVisible) {
|
||
this.placeStateIcon(actor, stateIconX, stateIconY);
|
||
}
|
||
if (params.TPBShow) {
|
||
const timeX = this.timeX(rect);
|
||
const timeY = this.timeY(rect);
|
||
this.placeTimeGauge(actor, timeX, timeY);
|
||
}
|
||
if (params.NameShow) {
|
||
const nameX = this.nameX(rect);
|
||
const nameY = this.nameY(rect);
|
||
this.placeActorName(actor, nameX, nameY);
|
||
}
|
||
const basicGaugesX = this.basicGaugesX(rect);
|
||
const basicGaugesY = this.basicGaugesY(rect);
|
||
this.placeBasicGauges(actor, basicGaugesX, basicGaugesY, rect);
|
||
}
|
||
$gameTemp.actorData = null;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawStatusListData = function (
|
||
actor,
|
||
list,
|
||
index
|
||
) {
|
||
const rect = this.itemRectWithPadding(index);
|
||
list.forEach((data) => {
|
||
this.getGaugeMaxWidth(rect.width, data.Width);
|
||
$gameTemp.userStatusParam = data;
|
||
switch (data.Status) {
|
||
case "hpgauge":
|
||
this.placeGauge(
|
||
actor,
|
||
"hp",
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY
|
||
);
|
||
break;
|
||
case "mpgauge":
|
||
this.placeGauge(
|
||
actor,
|
||
"mp",
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY
|
||
);
|
||
break;
|
||
case "tpgauge":
|
||
this.placeGauge(
|
||
actor,
|
||
"tp",
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY
|
||
);
|
||
break;
|
||
case "tpb":
|
||
this.placeTimeGauge(
|
||
actor,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY
|
||
);
|
||
break;
|
||
case "state":
|
||
if (!params.OutsideWindowVisible) {
|
||
this.placeStateIcon(
|
||
actor,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
data
|
||
);
|
||
}
|
||
break;
|
||
case "state2":
|
||
this.drawActorIcons(
|
||
actor,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
Math.min(rect.width, data.Width),
|
||
data
|
||
);
|
||
break;
|
||
case "name":
|
||
this.bs_PlaceActorName(
|
||
actor,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY
|
||
);
|
||
break;
|
||
case "lv":
|
||
this.drawLevel(
|
||
actor,
|
||
data,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
Math.min(rect.width, data.Width)
|
||
);
|
||
break;
|
||
case "param":
|
||
this.drawUserParam(
|
||
actor,
|
||
data,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
Math.min(rect.width, data.Width)
|
||
);
|
||
break;
|
||
case "usergauge":
|
||
this.placeGauge(
|
||
actor,
|
||
data.UserParamID,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY
|
||
);
|
||
break;
|
||
case "dparam":
|
||
this.placeUserParam(
|
||
actor,
|
||
data.UserParamID,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
Math.min(rect.width, data.Width)
|
||
);
|
||
break;
|
||
case "imges":
|
||
this.drawActorImges(
|
||
actor,
|
||
data,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
Math.min(rect.width, data.Width)
|
||
);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
});
|
||
$gameTemp.userStatusParam = null;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawLevel = function (
|
||
actor,
|
||
data,
|
||
x,
|
||
y,
|
||
width
|
||
) {
|
||
this.contents.fontSize = $gameSystem.mainFontSize() + (data.FontSize || 0);
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
const nameText = data.ParamName ? data.ParamName : TextManager.levelA;
|
||
const textWidth = this.textWidth(nameText);
|
||
this.drawText(nameText, x, y, textWidth);
|
||
this.resetTextColor();
|
||
this.drawText(
|
||
actor.level,
|
||
x + textWidth + 8,
|
||
y,
|
||
width - (textWidth + 8),
|
||
"right"
|
||
);
|
||
this.contents.fontSize = $gameSystem.mainFontSize();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawUserParam = function (
|
||
actor,
|
||
data,
|
||
x,
|
||
y,
|
||
width
|
||
) {
|
||
this.contents.fontSize = $gameSystem.mainFontSize() + (data.FontSize || 0);
|
||
const a = actor;
|
||
const d = actor.actor();
|
||
const nameText = data.ParamName ? data.ParamName : "";
|
||
const textWidth = Math.max(60, this.textWidth(nameText));
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
if (nameText) {
|
||
this.drawText(nameText, x + textWidth, y, width - textWidth);
|
||
}
|
||
this.resetTextColor();
|
||
if (data.DetaEval) {
|
||
this.drawText(
|
||
eval(data.DetaEval),
|
||
x + textWidth + 8,
|
||
y,
|
||
width - (textWidth + 8),
|
||
"right"
|
||
);
|
||
}
|
||
this.contents.fontSize = $gameSystem.mainFontSize();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawActorIcons = function (
|
||
actor,
|
||
x,
|
||
y,
|
||
width,
|
||
data
|
||
) {
|
||
const key = "actor%1-stateIcon%2".format(
|
||
actor.actorId(),
|
||
data.UserParamID || "_bsStateIcon2"
|
||
);
|
||
const sprite = this.createInnerSprite(key, Sprite_BSStateIcon);
|
||
sprite.setup(actor, data);
|
||
sprite.move(x, y);
|
||
sprite.setupVisibleIcons(
|
||
this.getVisibleIcons(data.DetaEval1),
|
||
this.getVisibleIcons(data.DetaEval2)
|
||
);
|
||
sprite.show();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawActorImges = function (
|
||
actor,
|
||
data,
|
||
x,
|
||
y,
|
||
width
|
||
) {
|
||
if (data.ContentsImges) {
|
||
const key = "actor%1-imges%2".format(
|
||
actor.actorId(),
|
||
data.UserParamID || "_img"
|
||
);
|
||
const bitmap = ImageManager.nuun_LoadPictures(data.ContentsImges);
|
||
const sprite = this.createInnerSprite(key, Sprite);
|
||
sprite.bitmap = bitmap;
|
||
sprite.x = x;
|
||
sprite.y = y;
|
||
sprite.anchor.x = 0.5;
|
||
sprite.anchor.y = 0.5;
|
||
sprite.show();
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.placeUserParam = function (actor, data, x, y) {
|
||
const key = "actor%1-userParam%2".format(
|
||
actor.actorId(),
|
||
data.UserParamID || "dparam"
|
||
);
|
||
const sprite = this.createInnerSprite(key, Sprite_NuunUserParam);
|
||
sprite.setup(actor);
|
||
sprite.move(x, y);
|
||
sprite.show();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.bs_PlaceActorName = function (actor, x, y) {
|
||
const key = "actor%1-name".format(actor.actorId());
|
||
const sprite = $gameTemp.userStatusParam
|
||
? this.createInnerSprite(key, Sprite_BSName)
|
||
: this.createInnerSprite(key, Sprite_Name);
|
||
sprite.setup(actor);
|
||
sprite.move(x, y);
|
||
sprite.show();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.placeStateIcon = function (actor, x, y, data) {
|
||
const key = "actor%1-stateIcon%2".format(
|
||
actor.actorId(),
|
||
data && data.UserParamID ? data.UserParamID : "_bsStateIcon"
|
||
);
|
||
const sprite = this.createInnerSprite(key, Sprite_StateIcon);
|
||
sprite.setup(actor);
|
||
sprite.move(x, y);
|
||
if (data) {
|
||
sprite.setupVisibleIcons(
|
||
this.getVisibleIcons(data.DetaEval1),
|
||
this.getVisibleIcons(data.DetaEval2)
|
||
);
|
||
}
|
||
sprite.show();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.placeBasicGauges = function (
|
||
actor,
|
||
x,
|
||
y,
|
||
rect
|
||
) {
|
||
let x2 = $gameTemp.actorData.HPChangePosition
|
||
? $gameTemp.actorData.ActorHP_X + rect.x
|
||
: this.defaultGaugeX(x, "hp");
|
||
let y2 = $gameTemp.actorData.HPChangePosition
|
||
? $gameTemp.actorData.ActorHP_Y + rect.y
|
||
: this.defaultGaugeY(y, "hp");
|
||
this.placeGauge(actor, "hp", x2, y2);
|
||
x2 = $gameTemp.actorData.MPChangePosition
|
||
? $gameTemp.actorData.ActorMP_X + rect.x
|
||
: this.defaultGaugeX(x, "mp");
|
||
y2 = $gameTemp.actorData.MPChangePosition
|
||
? $gameTemp.actorData.ActorMP_Y + rect.y
|
||
: this.defaultGaugeY(y, "mp");
|
||
this.placeGauge(actor, "mp", x2, y2);
|
||
if ($dataSystem.optDisplayTp) {
|
||
x2 = $gameTemp.actorData.TPChangePosition
|
||
? $gameTemp.actorData.ActorTP_X + rect.x
|
||
: this.defaultGaugeX(x, "tp");
|
||
y2 = $gameTemp.actorData.TPChangePosition
|
||
? $gameTemp.actorData.ActorTP_Y + rect.y
|
||
: this.defaultGaugeY(y, "tp");
|
||
this.placeGauge(actor, "tp", x2, y2);
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.getVisibleIcons = function (str) {
|
||
let states = [];
|
||
const dataEval = str;
|
||
if (dataEval) {
|
||
const stateList = dataEval.split(",");
|
||
for (const id of stateList) {
|
||
Array.prototype.push.apply(states, NuunManager.nuun_getListIdData(id));
|
||
}
|
||
}
|
||
return states;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.defaultGaugeX = function (x, type) {
|
||
switch (type) {
|
||
case "hp":
|
||
return params.bsMode === "Standard" ? x : x;
|
||
case "mp":
|
||
return params.bsMode === "Standard" ? x + 134 : x;
|
||
case "tp":
|
||
return params.bsMode === "Standard" ? x + 268 : x;
|
||
case "time":
|
||
return;
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.defaultGaugeY = function (y, type) {
|
||
switch (type) {
|
||
case "hp":
|
||
return params.bsMode === "Standard" ? y : y;
|
||
case "mp":
|
||
return params.bsMode === "Standard" ? y : y + this.gaugeLineHeight();
|
||
case "tp":
|
||
return params.bsMode === "Standard"
|
||
? y
|
||
: y + this.gaugeLineHeight() * 2;
|
||
case "time":
|
||
return params.bsMode === "Standard" ? y : y;
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.placeGauge = function (actor, type, x, y) {
|
||
$gameTemp.bsGaugeType = type;
|
||
if (Imported.NUUN_GaugeImage) {
|
||
this.placeGaugeImg(actor, type, x, y);
|
||
}
|
||
const key = "actor%1-gauge-%2".format(actor.actorId(), type);
|
||
const sprite =
|
||
$gameTemp.userStatusParam || $gameTemp.actorData
|
||
? this.createInnerSprite(key, Sprite_BSGauge)
|
||
: this.createInnerSprite(key, Sprite_Gauge);
|
||
sprite.setup(actor, type);
|
||
sprite.move(x, y);
|
||
sprite.show();
|
||
};
|
||
|
||
const _Window_BattleStatus_nameX = Window_BattleStatus.prototype.nameX;
|
||
Window_BattleStatus.prototype.nameX = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return $gameTemp.actorData.NameChangePosition
|
||
? $gameTemp.actorData.ActorName_X + rect.x
|
||
: rect.x;
|
||
} else {
|
||
return $gameTemp.actorData.NameChangePosition
|
||
? $gameTemp.actorData.ActorName_X + rect.x
|
||
: _Window_BattleStatus_nameX.call(this, rect);
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_nameY = Window_BattleStatus.prototype.nameY;
|
||
Window_BattleStatus.prototype.nameY = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return $gameTemp.actorData.NameChangePosition
|
||
? $gameTemp.actorData.ActorName_Y + rect.y
|
||
: rect.y + 10;
|
||
} else {
|
||
return $gameTemp.actorData.NameChangePosition
|
||
? $gameTemp.actorData.ActorName_Y + rect.y
|
||
: _Window_BattleStatus_nameY.call(this, rect);
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_basicGaugesX =
|
||
Window_BattleStatus.prototype.basicGaugesX;
|
||
Window_BattleStatus.prototype.basicGaugesX = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return rect.x + 180;
|
||
} else {
|
||
return _Window_BattleStatus_basicGaugesX.call(this, rect);
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_basicGaugesY =
|
||
Window_BattleStatus.prototype.basicGaugesY;
|
||
Window_BattleStatus.prototype.basicGaugesY = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return rect.y + 8;
|
||
} else {
|
||
return _Window_BattleStatus_basicGaugesY.call(this, rect);
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_stateIconX =
|
||
Window_BattleStatus.prototype.stateIconX;
|
||
Window_BattleStatus.prototype.stateIconX = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return $gameTemp.actorData.StateChangePosition
|
||
? $gameTemp.actorData.ActorState_X + rect.x
|
||
: rect.x + 156;
|
||
} else {
|
||
return $gameTemp.actorData.StateChangePosition
|
||
? $gameTemp.actorData.ActorState_X + rect.x
|
||
: _Window_BattleStatus_stateIconX.call(this, rect);
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_stateIconY =
|
||
Window_BattleStatus.prototype.stateIconY;
|
||
Window_BattleStatus.prototype.stateIconY = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return $gameTemp.actorData.StateChangePosition
|
||
? $gameTemp.actorData.ActorState_Y + rect.y
|
||
: rect.y + 22;
|
||
} else {
|
||
return $gameTemp.actorData.StateChangePosition
|
||
? $gameTemp.actorData.ActorState_Y + rect.y
|
||
: _Window_BattleStatus_stateIconY.call(this, rect);
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.timeX = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return $gameTemp.actorData.TPBChangePosition
|
||
? $gameTemp.actorData.ActorTPB_X + rect.x
|
||
: rect.x;
|
||
} else {
|
||
return $gameTemp.actorData.TPBChangePosition
|
||
? $gameTemp.actorData.ActorTPB_X + rect.x
|
||
: rect.x;
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.timeY = function (rect) {
|
||
if (params.bsMode === "Standard") {
|
||
return $gameTemp.actorData.TPBChangePosition
|
||
? $gameTemp.actorData.ActorTPB_Y + rect.y
|
||
: rect.y + 12;
|
||
} else {
|
||
return $gameTemp.actorData.TPBChangePosition
|
||
? $gameTemp.actorData.ActorTPB_Y + rect.y
|
||
: this.basicGaugesY(rect) - this.gaugeLineHeight();
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.actorBackGround = function (
|
||
actor,
|
||
bitmap,
|
||
x,
|
||
y,
|
||
width,
|
||
height
|
||
) {
|
||
this.contentsBack.blt(bitmap, 0, 0, width, height, x, y);
|
||
};
|
||
|
||
Window_BattleStatus.prototype.open = function () {
|
||
Window_Base.prototype.open.call(this);
|
||
if (this._window_battleActorImges) {
|
||
this._window_battleActorImges.open();
|
||
this._window_BattleActorStatus.open();
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.close = function () {
|
||
Window_Base.prototype.close.call(this);
|
||
if (this._window_battleActorImges) {
|
||
this._window_battleActorImges.close();
|
||
this._window_BattleActorStatus.close();
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_show = Window_BattleStatus.prototype.show;
|
||
Window_BattleStatus.prototype.show = function () {
|
||
_Window_BattleStatus_show.call(this);
|
||
if (this._window_battleActorImges) {
|
||
this._window_battleActorImges.show();
|
||
this._window_BattleActorStatus.show();
|
||
}
|
||
};
|
||
|
||
const _Window_BattleStatus_hide = Window_BattleStatus.prototype.hide;
|
||
Window_BattleStatus.prototype.hide = function () {
|
||
_Window_BattleStatus_hide.call(this);
|
||
if (this._window_battleActorImges) {
|
||
this._window_battleActorImges.hide();
|
||
this._window_BattleActorStatus.hide();
|
||
}
|
||
};
|
||
|
||
//Window_BattleActorImges
|
||
function Window_BattleActorImges() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleActorImges.prototype = Object.create(
|
||
Window_BattleStatus.prototype
|
||
);
|
||
Window_BattleActorImges.prototype.constructor = Window_BattleActorImges;
|
||
|
||
Window_BattleActorImges.prototype.initialize = function (rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this.openness = 0;
|
||
this.opacity = 0;
|
||
this._opening = true;
|
||
this.visible = true;
|
||
this._bitmapsReady = 0;
|
||
this.setActorBaseSprite();
|
||
this.preparePartyRefresh();
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.setActorBaseSprite = function () {
|
||
const sprite = new Sprite();
|
||
this._actorImgBaseSprite = sprite;
|
||
this.addChild(sprite);
|
||
sprite.hide();
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawItem = function (index) {
|
||
this.drawItemImage(index);
|
||
this.drawStatusBack(index);
|
||
//this.drawItemStatus(index);
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawStatusListData = function (
|
||
actor,
|
||
list,
|
||
index
|
||
) {
|
||
const rect = this.itemRectWithPadding(index);
|
||
list.forEach((data) => {
|
||
switch (data.Status) {
|
||
case "imges":
|
||
this.drawActorImges(
|
||
actor,
|
||
data,
|
||
rect.x + data.PositionX,
|
||
rect.y + data.PositionY,
|
||
Math.min(rect.width, data.Width)
|
||
);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
});
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawItemStatus = function (index) {
|
||
//再定義
|
||
const actor = this.actor(index);
|
||
const actorData = getActorPositionData(actor.actorId());
|
||
const statusData = actorData.StatusListData;
|
||
if (statusData && statusData.length > 0) {
|
||
this.drawStatusListData(actor, statusData, index);
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawActorImges = function (
|
||
actor,
|
||
data,
|
||
x,
|
||
y,
|
||
width
|
||
) {
|
||
if (data.ContentsImges) {
|
||
const key = "actor%1-imges%2".format(
|
||
actor.actorId(),
|
||
data.UserParamID || "_img"
|
||
);
|
||
const bitmap = ImageManager.nuun_LoadPictures(data.ContentsImges);
|
||
const sprite = this.createActorImgSprite(key, Sprite);
|
||
sprite.bitmap = bitmap;
|
||
sprite.x = x;
|
||
sprite.y = y;
|
||
sprite.anchor.x = 0.5;
|
||
sprite.anchor.y = 0.5;
|
||
sprite.show();
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawStatusBack = function (index) {
|
||
if (this._bitmapsReady >= $gameParty.members().length) {
|
||
const actor = this.actor(index);
|
||
const data = getActorPositionData(actor.actorId());
|
||
if (data.ActorFrontBackground) {
|
||
const rect = this.itemRect(index);
|
||
const bitmap = ImageManager.nuun_LoadPictures(
|
||
data.ActorFrontBackground
|
||
);
|
||
this.actorFrontBackGround(
|
||
actor,
|
||
bitmap,
|
||
rect.x,
|
||
rect.y,
|
||
rect.width,
|
||
rect.height
|
||
);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.actorFrontBackGround = function (
|
||
actor,
|
||
bitmap,
|
||
x,
|
||
y,
|
||
width,
|
||
height
|
||
) {
|
||
const key = "actor%1-Frontback-%2".format(actor.actorId());
|
||
const sprite = this.createActorImgSprite(key, Sprite);
|
||
sprite.bitmap = bitmap;
|
||
sprite.move(x + this.colSpacing(), y + 8);
|
||
sprite.width = width;
|
||
sprite.height = height;
|
||
sprite.show();
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawItemBackground = function (index) {};
|
||
|
||
Window_BattleActorImges.prototype.preparePartyRefresh = function () {
|
||
this._bitmapsReady = 0;
|
||
this.actorMainSprite = [];
|
||
let bitmap = null;
|
||
for (const actor of $gameParty.members()) {
|
||
actor.battleStyleImgRefresh();
|
||
bitmap = actor.getLoadBattleStyleImg();
|
||
this.actorMainSprite.push(bitmap);
|
||
if (bitmap && !bitmap.isReady()) {
|
||
bitmap.addLoadListener(this.performPartyRefresh.bind(this, bitmap));
|
||
} else {
|
||
this.performPartyRefresh(bitmap);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.performPartyRefresh = function () {
|
||
this._bitmapsReady++;
|
||
if (this._bitmapsReady >= $gameParty.members().length) {
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawItemImage = function (index) {
|
||
const actor = this.actor(index);
|
||
if (actor.bsImgMode !== "none" && actor.faceMode) {
|
||
this.drawItemFace(index, actor);
|
||
} else if (actor.bsImgMode !== "none") {
|
||
this.drawItemButler(index, actor);
|
||
}
|
||
if (
|
||
$gameTemp.actorData &&
|
||
params.StateVisible &&
|
||
params.OutsideWindowVisible
|
||
) {
|
||
const rect = this.itemRectWithPadding(index);
|
||
const statusData = $gameTemp.actorData.StatusListData;
|
||
if (statusData) {
|
||
const find = statusData.find((data) => data.Status === "state");
|
||
if (find) {
|
||
this.placeStateIcon(
|
||
actor,
|
||
rect.x + find.PositionX,
|
||
rect.y + find.PositionY
|
||
);
|
||
}
|
||
} else {
|
||
const stateIconX = this.stateIconX(rect);
|
||
const stateIconY = this.stateIconY(rect);
|
||
this.placeStateIcon(actor, stateIconX, stateIconY);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawItemButler = function (index, actor) {
|
||
const bitmap = this.actorMainSprite[index];
|
||
const actorId = actor.actorId();
|
||
const positionData = getActorPositionData(actorId);
|
||
const actorImgData = getActorImgData(actorId);
|
||
const rect = this.itemRect(index);
|
||
let stateSprite = null;
|
||
if (bitmap) {
|
||
const key = "actor%1-BSImg".format(actor.actorId());
|
||
const sprite = this.createActorImgSprite(key, Sprite_ActorImges);
|
||
const imgIndex = actor.getBSImgIndex();
|
||
if (!sprite._stateSprite && getStateAnimationShow()) {
|
||
stateSprite = new Sprite_StateOverlay();
|
||
this.addChild(stateSprite);
|
||
}
|
||
sprite.setup(actor, actorImgData, imgIndex, stateSprite);
|
||
const x =
|
||
rect.x +
|
||
(actorImgData.ActorImgHPosition === "center"
|
||
? Math.floor(this.itemWidth() / 2) + 4
|
||
: 8) +
|
||
(positionData.ImgChangePosition ? positionData.ActorImg_X : 0) +
|
||
(actorImgData ? actorImgData.Actor_X : 0);
|
||
//const x = rect.x + (positionData.ImgChangePosition ? positionData.ActorImg_X : Math.floor(this.itemWidth() / 2) + 4) + (actorImgData ? actorImgData.Actor_X : 0);
|
||
const y =
|
||
rect.y +
|
||
(actorImgData.ActorImgVPosition === "under" ? this.height : 0) +
|
||
(positionData.ImgChangePosition ? positionData.ActorImg_Y : 0) +
|
||
this.itemPadding() +
|
||
(actorImgData ? actorImgData.Actor_Y : 0);
|
||
const scale = actorImgData.Actor_Scale / 100;
|
||
sprite.scale.x = scale;
|
||
sprite.scale.y = scale;
|
||
sprite._rectWidth = bitmap.width;
|
||
sprite._rectHeight = bitmap.height;
|
||
sprite.setHome(x, y);
|
||
sprite.show();
|
||
if (params.Img_SW > 0 || params.Img_SH > 0) {
|
||
const oriScale = 1 / scale;
|
||
const sw = (params.Img_SW || Infinity) * oriScale;
|
||
const sh = (params.Img_SH || Infinity) * oriScale;
|
||
const sx =
|
||
(actorImgData.Img_SX || 0) * oriScale +
|
||
(actorImgData.ActorImgHPosition === "center"
|
||
? (bitmap.width - sw) / 2
|
||
: 0);
|
||
const sy = (actorImgData.Img_SY || 0) * oriScale;
|
||
sprite.setFrame(sx, sy, sw, sh);
|
||
}
|
||
BattleManager.battlerSprite[index] = sprite;
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.drawItemFace = function (index, actor) {
|
||
const actorId = actor.actorId();
|
||
const positionData = getActorPositionData(actorId);
|
||
const actorImgData = getActorImgData(actorId);
|
||
const rect = this.faceRect(index);
|
||
let stateSprite = null;
|
||
let width = rect.width || ImageManager.faceWidth;
|
||
let height = rect.height || ImageManager.faceHeight;
|
||
const key = "actor%1-BSImg".format(actor.actorId());
|
||
const sprite = this.createActorImgSprite(key, Sprite_ActorImges);
|
||
const imgIndex = actor.getBSImgIndex();
|
||
if (!sprite._stateSprite && getStateAnimationShow()) {
|
||
stateSprite = new Sprite_StateOverlay();
|
||
this.addChild(stateSprite);
|
||
}
|
||
sprite.setup(actor, actorImgData, imgIndex, stateSprite);
|
||
const scale = actorImgData.Actor_Scale / 100;
|
||
sprite.scale.x = scale;
|
||
sprite.scale.y = scale;
|
||
const pw = ImageManager.faceWidth;
|
||
const ph = ImageManager.faceHeight;
|
||
const sw = Math.min(width, pw);
|
||
const sh = Math.min(height, ph);
|
||
const x =
|
||
rect.x +
|
||
(actorImgData.ActorImgHPosition === "center"
|
||
? Math.floor(this.itemWidth() / 2) + 4
|
||
: 8) +
|
||
(positionData.ImgChangePosition ? positionData.ActorImg_X : 0) +
|
||
(actorImgData ? actorImgData.Actor_X : 0);
|
||
//const x = rect.x + (positionData.ImgChangePosition ? positionData.ActorImg_X : Math.floor(this.itemWidth() / 2) + 4) + (actorImgData ? actorImgData.Actor_X : 0);
|
||
const y =
|
||
rect.y +
|
||
(actorImgData.ActorImgVPosition === "under" ? sh : 1) +
|
||
(positionData.ImgChangePosition ? positionData.ActorImg_Y : 0) +
|
||
(actorImgData ? actorImgData.Actor_Y : 0);
|
||
sprite.setHome(x, y);
|
||
const sx = Math.floor((imgIndex % 4) * pw + (pw - sw) / 2);
|
||
const sy = Math.floor(Math.floor(imgIndex / 4) * ph + (ph - sh) / 2);
|
||
sprite.setFrame(sx, sy, sw, sh);
|
||
sprite._rectWidth = Math.min(pw, rect.width);
|
||
sprite._rectHeight = rect.height;
|
||
sprite.show();
|
||
BattleManager.battlerSprite[index] = sprite;
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.placeStateIcon = function (
|
||
actor,
|
||
x,
|
||
y,
|
||
data
|
||
) {
|
||
const key = "actor%1-stateIcon%2".format(
|
||
actor.actorId(),
|
||
data ? data.UserParamID || "dparam" : "dparam"
|
||
);
|
||
const sprite = this.createActorImgSprite(key, Sprite_StateIcon);
|
||
sprite.setup(actor);
|
||
sprite.move(x, y);
|
||
if (data) {
|
||
sprite.setupVisibleIcons(
|
||
this.getVisibleIcons(data.detaEval1),
|
||
this.getVisibleIcons(data.detaEval2)
|
||
);
|
||
}
|
||
sprite.show();
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.createActorImgSprite = function (
|
||
key,
|
||
spriteClass
|
||
) {
|
||
const dict = this._additionalSprites;
|
||
if (dict[key]) {
|
||
return dict[key];
|
||
} else {
|
||
const sprite = new spriteClass();
|
||
dict[key] = sprite;
|
||
this._actorImgBaseSprite.addChild(sprite);
|
||
return sprite;
|
||
}
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.open = function () {
|
||
Window_Base.prototype.open.call(this);
|
||
this._actorImgBaseSprite.show();
|
||
};
|
||
|
||
Window_BattleActorImges.prototype.close = function () {
|
||
Window_Base.prototype.close.call(this);
|
||
this._actorImgBaseSprite.hide();
|
||
};
|
||
|
||
//Window_BattleActorStatus
|
||
function Window_BattleActorStatus() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleActorStatus.prototype = Object.create(
|
||
Window_BattleStatus.prototype
|
||
);
|
||
Window_BattleActorStatus.prototype.constructor = Window_BattleActorStatus;
|
||
|
||
Window_BattleActorStatus.prototype.initialize = function (rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
const filterArea = this._clientArea.filterArea;
|
||
this.openness = 0;
|
||
this.opacity = 0;
|
||
this._opening = true;
|
||
this.visible = true;
|
||
BattleManager.gaugeMaxWidth = params.ActorStatusVariable
|
||
? this.width
|
||
: this.itemRectWithPadding(0).width;
|
||
BattleManager.rectMaxWidth = BattleManager.gaugeMaxWidth;
|
||
this.preparePartyRefresh();
|
||
};
|
||
|
||
Window_BattleActorStatus.prototype.getGaugeMaxWidth = function (
|
||
width,
|
||
width2
|
||
) {
|
||
BattleManager.rectMaxWidth = Math.min(width, width2);
|
||
};
|
||
|
||
Window_BattleActorStatus.prototype._updateFilterArea = function () {
|
||
const pos = this._clientArea.worldTransform.apply(new Point(0, 0));
|
||
const filterArea = this._clientArea.filterArea;
|
||
filterArea.x = 0;
|
||
filterArea.y = 0;
|
||
filterArea.width = Graphics.width;
|
||
filterArea.height = Graphics.height;
|
||
};
|
||
|
||
Window_BattleActorStatus.prototype.preparePartyRefresh = function () {
|
||
$gameTemp.clearBattleRefreshRequest();
|
||
this.performPartyRefresh();
|
||
};
|
||
|
||
Window_BattleActorStatus.prototype.performPartyRefresh = function () {
|
||
this.refresh();
|
||
};
|
||
|
||
Window_BattleActorStatus.prototype.drawItemBackground = function (index) {};
|
||
|
||
Window_BattleActorStatus.prototype.drawItem = function (index) {
|
||
this.drawItemStatus(index);
|
||
};
|
||
|
||
//Window_BattleActor
|
||
const _Window_BattleActor_initialize =
|
||
Window_BattleActor.prototype.initialize;
|
||
Window_BattleActor.prototype.initialize = function (rect) {
|
||
_Window_BattleActor_initialize.call(this, rect);
|
||
this.opacity = 0;
|
||
};
|
||
|
||
Window_BattleActor.prototype.drawItemBackground = function (index) {};
|
||
|
||
Window_BattleActor.prototype.preparePartyRefresh = function () {
|
||
this.refresh();
|
||
};
|
||
|
||
Window_BattleActor.prototype.drawItem = function (index) {};
|
||
|
||
const _Window_BattleActor_refreshCursor =
|
||
Window_BattleActor.prototype.refreshCursor;
|
||
Window_BattleActor.prototype.refreshCursor = function () {
|
||
if (params.ActorSelectBackShow) {
|
||
_Window_BattleActor_refreshCursor.call(this);
|
||
} else {
|
||
this.setCursorRect(0, 0, 0, 0);
|
||
}
|
||
};
|
||
|
||
//Window_BattleEnemy
|
||
const _Window_BattleEnemy_initialize =
|
||
Window_BattleEnemy.prototype.initialize;
|
||
Window_BattleEnemy.prototype.initialize = function (rect) {
|
||
_Window_BattleEnemy_initialize.call(this, rect);
|
||
this._bsBackground = null;
|
||
this.opacity = params.EnemyWindowShow ? 255 : 0;
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.maxCols = function () {
|
||
return params.EnemyMaxCol;
|
||
};
|
||
|
||
console.log(params.EnemyNameDyingColor);
|
||
if (params.EnemyNameDyingColor) {
|
||
Window_BattleEnemy.prototype.drawItem = function (index) {
|
||
//再定義
|
||
const enemy = this._enemies[index];
|
||
this.changeTextColor(ColorManager.hpColor(enemy));
|
||
const name = enemy.name();
|
||
const rect = this.itemLineRect(index);
|
||
this.drawText(name, rect.x, rect.y, rect.width);
|
||
};
|
||
}
|
||
|
||
//Window_BattleSkill
|
||
const _Window_BattleSkill_initialize =
|
||
Window_BattleSkill.prototype.initialize;
|
||
Window_BattleSkill.prototype.initialize = function (rect) {
|
||
_Window_BattleSkill_initialize.call(this, rect);
|
||
this._bsBackground = null;
|
||
this.opacity = params.SkillWindowShow ? 255 : 0;
|
||
};
|
||
|
||
//Window_BattleItem
|
||
const _Window_BattleItem_initialize = Window_BattleItem.prototype.initialize;
|
||
Window_BattleItem.prototype.initialize = function (rect) {
|
||
_Window_BattleItem_initialize.call(this, rect);
|
||
this._bsBackground = null;
|
||
this.opacity = params.ItemWindowShow ? 255 : 0;
|
||
};
|
||
|
||
//Window_Help
|
||
const _Window_Help_initialize = Window_Help.prototype.initialize;
|
||
Window_Help.prototype.initialize = function (rect) {
|
||
_Window_Help_initialize.call(this, rect);
|
||
this._bsBackground = null;
|
||
this.opacity = params.HelpWindowShow ? 255 : 0;
|
||
};
|
||
|
||
//Window_BattleLog
|
||
const _Window_BattleLog_showEnemyAttackAnimation =
|
||
Window_BattleLog.prototype.showEnemyAttackAnimation;
|
||
Window_BattleLog.prototype.showEnemyAttackAnimation = function (
|
||
subject,
|
||
targets
|
||
) {
|
||
const id = subject.attackAnimation();
|
||
if (id > 0) {
|
||
this.showNormalAnimation(targets, id, false);
|
||
} else {
|
||
_Window_BattleLog_showEnemyAttackAnimation.call(this);
|
||
}
|
||
};
|
||
|
||
//Window_Message
|
||
const _Window_Message_updateBackground =
|
||
Window_Message.prototype.updateBackground;
|
||
Window_Message.prototype.updateBackground = function () {
|
||
_Window_Message_updateBackground.call(this);
|
||
if (
|
||
BattleManager.getDisplayMessageType() === "Appear" &&
|
||
params.AppearBackgroundImg
|
||
) {
|
||
this.opacity = 0;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "Victory" &&
|
||
params.VictoryBackgroundImg
|
||
) {
|
||
this.opacity = 0;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "Defeat" &&
|
||
params.LoseBackgroundImg
|
||
) {
|
||
this.opacity = 0;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "Escape" &&
|
||
params.EscapeBackgroundImg
|
||
) {
|
||
this.opacity = 0;
|
||
} else if (
|
||
BattleManager.getDisplayMessageType() === "EscapeFailure" &&
|
||
params.EscapeFailureBackgroundImg
|
||
) {
|
||
this.opacity = 0;
|
||
}
|
||
};
|
||
|
||
//Sprite_Actor
|
||
function Sprite_BSFrontActor() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Sprite_BSFrontActor.prototype = Object.create(Sprite_Actor.prototype);
|
||
Sprite_BSFrontActor.prototype.constructor = Sprite_BSFrontActor;
|
||
|
||
Sprite_BSFrontActor.prototype.initialize = function (battler) {
|
||
Sprite_Actor.prototype.initialize.call(this, battler);
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.initMembers = function () {
|
||
Sprite_Actor.prototype.initMembers.call(this);
|
||
this.viewFrontActor = !$gameSystem.isSideView() && params.ActorEffectShow;
|
||
this.bsSprite = null;
|
||
this._bsHomeX = 0;
|
||
this._bsHomeY = 0;
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.updateVisibility = function () {
|
||
Sprite_Actor.prototype.updateVisibility.call(this);
|
||
if (this.viewFrontActor) {
|
||
//this.visible = true;
|
||
this.visible = false;
|
||
}
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.setActorHome = function (index) {
|
||
if (this.viewFrontActor) {
|
||
this.actorHomeRefresh(index);
|
||
}
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.actorHomeRefresh = function (index) {
|
||
const rect = statusData.itemRectWithPadding(index);
|
||
let x = rect.x + Math.floor(rect.width / 2) + statusData.itemPadding();
|
||
let y = rect.y + statusData.y + Math.floor(rect.height / 2);
|
||
if (params.StyleMode === "Standard") {
|
||
x -= Math.floor(ImageManager.faceWidth / 2);
|
||
}
|
||
this.setHome(x + params.ActorEffect_X, y + params.ActorEffect_Y);
|
||
this._bsHomeX = x + params.ActorEffect_X;
|
||
this._bsHomeY = y + params.ActorEffect_Y;
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.setBattler = function (battler) {
|
||
Sprite_Actor.prototype.setBattler.call(this, battler);
|
||
const index = battler ? battler.index() : -1;
|
||
if (
|
||
battler &&
|
||
battler === this._actor &&
|
||
this.viewFrontActor &&
|
||
$gameTemp.isBattleStyleRequested() &&
|
||
params.ActorEffectShow
|
||
) {
|
||
this.setActorHome(index);
|
||
}
|
||
if (battler) {
|
||
this.bsSprite = BattleManager.battlerSprite[index];
|
||
}
|
||
$gameTemp.setBattleStyleRefresh(false);
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.startMove = function (x, y, duration) {};
|
||
|
||
Sprite_BSFrontActor.prototype.updateMotion = function () {};
|
||
|
||
Sprite_BSFrontActor.prototype.update = function () {
|
||
Sprite_Actor.prototype.update.call(this);
|
||
if (this._actor) {
|
||
this.updateFrontActor();
|
||
this.updateBsPosition();
|
||
}
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.updateFrontActor = function () {
|
||
if (this.viewFrontActor && $gameTemp.isBattleStyleRequested()) {
|
||
this.setActorHome(this._actor.index());
|
||
}
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.updateBsPosition = function () {
|
||
if (this.viewFrontActor) {
|
||
if (this._bsHomeX !== this._homeX) {
|
||
this._homeX = this._bsHomeX;
|
||
}
|
||
if (this._bsHomeY !== this._homeY) {
|
||
this._homeY = this._bsHomeY;
|
||
}
|
||
}
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.damageOffsetX = function () {
|
||
return (
|
||
(this.viewFrontActor
|
||
? 0
|
||
: Sprite_Actor.prototype.damageOffsetX.call(this)) +
|
||
params.ActorDamage_X
|
||
);
|
||
};
|
||
|
||
Sprite_BSFrontActor.prototype.damageOffsetY = function () {
|
||
return (
|
||
(this.viewFrontActor
|
||
? 0
|
||
: Sprite_Actor.prototype.damageOffsetY.call(this)) +
|
||
params.ActorDamage_Y
|
||
);
|
||
};
|
||
|
||
const _Sprite_Animation_updateFlash = Sprite_Animation.prototype.updateFlash;
|
||
Sprite_Animation.prototype.updateFlash = function () {
|
||
const t = this._targets;
|
||
if (!$gameSystem.isSideView() && params.ActorEffectShow) {
|
||
this._targets = this._targets.map((sprite) =>
|
||
sprite._actor && sprite.bsSprite ? sprite.bsSprite : sprite
|
||
);
|
||
}
|
||
_Sprite_Animation_updateFlash.call(this);
|
||
this._targets = t;
|
||
};
|
||
|
||
const _Sprite_AnimationMV_updateFlashMV =
|
||
Sprite_AnimationMV.prototype.updateFlash;
|
||
Sprite_AnimationMV.prototype.updateFlash = function () {
|
||
const t = this._targets;
|
||
if (!$gameSystem.isSideView() && params.ActorEffectShow) {
|
||
this._targets = this._targets.map((sprite) =>
|
||
sprite._actor && sprite.bsSprite ? sprite.bsSprite : sprite
|
||
);
|
||
}
|
||
_Sprite_AnimationMV_updateFlashMV.call(this);
|
||
this._targets = t;
|
||
};
|
||
|
||
//Sprite_ActorImges
|
||
function Sprite_ActorImges() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Sprite_ActorImges.prototype = Object.create(Sprite.prototype);
|
||
Sprite_ActorImges.prototype.constructor = Sprite_ActorImges;
|
||
|
||
Sprite_ActorImges.prototype.initialize = function () {
|
||
Sprite.prototype.initialize.call(this);
|
||
this.initMembers();
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.initMembers = function () {
|
||
this._battler = null;
|
||
this._data = null;
|
||
this._imgScenes = "default";
|
||
this._imgIndex = -1;
|
||
this._selectionEffectCount = 0;
|
||
this._shake = 0;
|
||
this._shakePower = params.ActorShakePower;
|
||
this._shakeSpeed = params.ActorShakeSpeed;
|
||
this._shakeDuration = 0;
|
||
this._shakeDirection = 1;
|
||
this._zoomDuration = 0;
|
||
this._zoomScale = 1;
|
||
this._zoomScaleTarget = 1.2;
|
||
this._updateCount = 0;
|
||
this._imgListId = -1;
|
||
this._durationOpacity = 0;
|
||
this._startUpdate = true;
|
||
this._zoomEffect = false;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setup = function (
|
||
battler,
|
||
data,
|
||
index,
|
||
stateSprite
|
||
) {
|
||
this._battler = battler;
|
||
this._data = data;
|
||
this.anchor.x = data.ActorImgHPosition === "center" ? 0.5 : 0.0;
|
||
this.anchor.y = data.ActorImgVPosition === "top" ? 0.0 : 1.0;
|
||
this._imgIndex = index;
|
||
battler.resetBattleStyleImgId();
|
||
this.updateActorGraphic();
|
||
this._stateSprite = stateSprite || this._stateSprite;
|
||
if (this._stateSprite && getStateAnimationShow()) {
|
||
this._stateSprite.setup(battler);
|
||
this._stateSprite.anchor.y = 0.5;
|
||
this._stateSprite.x =
|
||
this.x + this.getStateRectX() + this.getStatePositionX();
|
||
this._stateSprite.y =
|
||
this.y + this.getStateRectY() + this.getStatePositionY();
|
||
}
|
||
this.setBlendColor([0, 0, 0, 0]);
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setHome = function (x, y) {
|
||
this._homeX = x;
|
||
this._homeY = y;
|
||
this._baseScale = this._data ? this._data.Actor_Scale / 100 : 1;
|
||
this.move(x, y);
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.update = function () {
|
||
Sprite.prototype.update.call(this);
|
||
if (this._battler) {
|
||
this.updateActorGraphic();
|
||
this.updateMotion();
|
||
this.updateSelectionEffect();
|
||
} else {
|
||
this._stateSprite = null;
|
||
this.bitmap = null;
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.refreshStateOverlay = function () {
|
||
if (this._stateSprite && getStateAnimationShow()) {
|
||
this._stateSprite.visible = this.visible;
|
||
this._stateSprite.x =
|
||
this.x + this.getStateRectX() + this.getStatePositionX();
|
||
this._stateSprite.y =
|
||
this.y + this.getStateRectY() + this.getStatePositionY();
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.updateMotion = function () {
|
||
this.refreshStateOverlay();
|
||
this.setupEffect();
|
||
this.updateDamage();
|
||
this.updateZoom();
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setupEffect = function () {
|
||
if (params.OnActorShake && this._battler.isBSDamageEffect()) {
|
||
this._shakeDuration = params.ActorShakeFlame;
|
||
this._battler._onDamageEffect = false;
|
||
}
|
||
if (params.OnActionZoom && this._battler.isBSEffectAction()) {
|
||
this._zoomDuration = params.ActionZoomDuration;
|
||
this._zoomEffect = true;
|
||
this._battler._isEffectAction = false;
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.updateDamage = function () {
|
||
if (this._shakeDuration > 0 || this._shake !== 0) {
|
||
const delta =
|
||
(this._shakePower * this._shakeSpeed * this._shakeDirection) / 10;
|
||
if (
|
||
this._shakeDirection <= 1 &&
|
||
this._shake * (this._shake + delta) < 0
|
||
) {
|
||
this._shake = 0;
|
||
} else {
|
||
this._shake += delta;
|
||
}
|
||
if (this._shake > this._shakePower * 2) {
|
||
this._shakeDirection = -1;
|
||
}
|
||
if (this._shake < -this._shakePower * 2) {
|
||
this._shakeDirection = 1;
|
||
}
|
||
this._shakeDuration--;
|
||
this.x += Math.round(this._shake);
|
||
} else if (this.x !== this._homeX) {
|
||
this.resetDamage();
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.updateZoom = function () {
|
||
if (this._zoomDuration > 0) {
|
||
this.anchor.y = 0.5;
|
||
this.anchor.x = 0.5;
|
||
const d = this._zoomDuration;
|
||
const t =
|
||
this._zoomDuration <= params.ActionZoomDuration / 2
|
||
? 1
|
||
: this._zoomScaleTarget;
|
||
this._zoomScale = (this._zoomScale * (d - 1) + t) / d;
|
||
this._zoomDuration--;
|
||
const scale = this._zoomScale * this._baseScale;
|
||
this.scale.x = scale;
|
||
this.scale.y = scale;
|
||
if (this.x === this._homeX) {
|
||
this.x =
|
||
this._homeX +
|
||
(this._data.ActorImgHPosition === "left"
|
||
? (this._rectWidth / 2) * scale
|
||
: 0);
|
||
}
|
||
if (this.y === this._homeY) {
|
||
this.y =
|
||
this._homeY -
|
||
(this._rectHeight / 2) *
|
||
scale *
|
||
(this._data.ActorImgVPosition === "top" ? -1 : 1);
|
||
}
|
||
if (getStateAnimationShow()) {
|
||
//this._stateSprite.x = params.ActorState_X;
|
||
//this._stateSprite.y = params.ActorState_Y + (this._rectHeight / 2) * (this._data.ActorImgVPosition === 'top' ? -1 : 1) + this.getStatePositionY();
|
||
}
|
||
} else {
|
||
if (this.scale.x !== this._baseScale) {
|
||
this.resetZoom();
|
||
}
|
||
if (this._zoomEffect) {
|
||
this._zoomEffect = false;
|
||
this.y = this._homeY;
|
||
this.x = this._homeX;
|
||
this.anchor.x = this._data.ActorImgHPosition === "left" ? 0.0 : 0.5;
|
||
this.anchor.y = this._data.ActorImgVPosition === "top" ? 0.0 : 1.0;
|
||
if (getStateAnimationShow()) {
|
||
//this._stateSprite.x = this.getStateRectX() + this.getStatePositionX();
|
||
//this._stateSprite.y = this.getStateRectY() + this.getStatePositionY();
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.getStateRectX = function () {
|
||
//const tag = 'BSStateA_X' + this._stateSprite._overlayIndex;
|
||
return params.ActorState_X + this._data.ActorState_X; // + (Number(this._battler.actor().meta[tag]) || 0);
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.getStateRectY = function () {
|
||
//const tag = 'BSStateA_Y' + this._stateSprite._overlayIndex;console.log(tag)
|
||
return params.ActorState_Y + this._data.ActorState_Y; // + (Number(this._battler.actor().meta[tag]) || 0);
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.getStatePositionX = function () {
|
||
return this._data.ActorImgHPosition === "left" ? this.width / 2 : 0;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.getStatePositionY = function () {
|
||
return this._data.ActorImgVPosition === "under" ? this._rectHeight * -1 : 0;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.resetDamage = function () {
|
||
this.x = this._homeX;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.resetZoom = function () {
|
||
this.scale.x = this._baseScale;
|
||
this.scale.y = this._baseScale;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.updateSelectionEffect = function () {
|
||
if (!params.ActorFlash) {
|
||
return;
|
||
}
|
||
const target = this;
|
||
if (this._battler.isSelected()) {
|
||
this._selectionEffectCount++;
|
||
if (this._selectionEffectCount % 30 < 15) {
|
||
target.setBlendColor([255, 255, 255, 64]);
|
||
} else {
|
||
target.setBlendColor([0, 0, 0, 0]);
|
||
}
|
||
} else if (this._selectionEffectCount > 0) {
|
||
this._selectionEffectCount = 0;
|
||
target.setBlendColor([0, 0, 0, 0]);
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.updateActorGraphic = function () {
|
||
const actor = this._battler;
|
||
if (actor) {
|
||
if (actor.isDead() && !this.isDead()) {
|
||
this.setDeadUpdateCount();
|
||
} else if (actor.isAlive() && this.isDead()) {
|
||
this.setReviveUpdateCount();
|
||
} else if (
|
||
actor.isAlive() &&
|
||
actor.getBSImgName() &&
|
||
this._imgListId !== actor.getBSGraphicIndex()
|
||
) {
|
||
if (
|
||
actor.onImgId === 1 ||
|
||
actor.onImgId === 2 ||
|
||
actor.onImgId === 15
|
||
) {
|
||
this._updateCount = this.setDamageDuration();
|
||
} else if (actor.onImgId === 30 || actor.onImgId === 31) {
|
||
this._updateCount = this.setCounterDuration();
|
||
} else if (actor.onImgId === 20) {
|
||
this._updateCount = Infinity;
|
||
} else {
|
||
this._updateCount = 1;
|
||
}
|
||
}
|
||
}
|
||
this.refreshActorGraphic(actor);
|
||
if (this._startUpdate) {
|
||
this._startUpdate = false;
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.refreshActorGraphic = function (actor) {
|
||
if (actor && actor.getBSImgName()) {
|
||
if (
|
||
this._imgListId !== actor.getBSGraphicIndex() &&
|
||
this._updateCount > 0
|
||
) {
|
||
const bitmap = actor.getLoadBattleStyleImg();
|
||
if (bitmap && !bitmap.isReady()) {
|
||
bitmap.addLoadListener(
|
||
this.setActorGraphic.bind(this, actor, bitmap)
|
||
);
|
||
} else if (bitmap) {
|
||
this.setActorGraphic(actor, bitmap);
|
||
}
|
||
this._imgScenes = this.getImgScenes(actor);
|
||
this._imgListId = actor.getBSGraphicIndex();
|
||
}
|
||
}
|
||
this.updateAnimation();
|
||
if (this._imgScenes === "chant" && !actor.isChanting()) {
|
||
this.resetBattleStyleImg(actor);
|
||
} else if (actor.isBSActionActorImg()) {
|
||
if (!actor.isActing()) {
|
||
actor.setBSActionActorImg(null);
|
||
this.resetBattleStyleImg(actor);
|
||
}
|
||
} else if (this._updateCount === 0) {
|
||
this.resetBattleStyleImg(actor);
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.resetBattleStyleImg = function (actor) {
|
||
if (Imported.NUUN_ActorPicture && params.OnActorPictureEX) {
|
||
actor.imgRefresh();
|
||
}
|
||
actor.resetBattleStyleImgId();
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setActorGraphic = function (actor, bitmap) {
|
||
this.bitmap = bitmap;
|
||
if (actor.faceMode) {
|
||
this.faceRefresh(actor.getBSImgIndex());
|
||
} else {
|
||
this.imgFrameRefresh();
|
||
}
|
||
if (!this.isDead() && this._updateCount === 0) {
|
||
this.opacity = actor.getBattleStyleOpacity() || 255;
|
||
this._actorImgesOpacity = this.opacity;
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.updateAnimation = function () {
|
||
if (this._updateCount > 0) {
|
||
this._updateCount--;
|
||
if (this._durationOpacity > 0) {
|
||
this.opacity -= this.getFadeoutOpacity() / this.setDeadDuration();
|
||
this.opacity = Math.max(this.opacity, 0);
|
||
this._durationOpacity = this.opacity;
|
||
} else if (this._durationOpacity < 0) {
|
||
this.opacity += this.getFadeoutOpacity() / this.setDeadDuration();
|
||
this.opacity = Math.min(this.opacity, this.getFadeoutOpacity());
|
||
this._durationOpacity = this.opacity - this.getFadeoutOpacity();
|
||
}
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.getFadeoutOpacity = function () {
|
||
if (!this._actorImgesOpacity) {
|
||
this._actorImgesOpacity = this.opacity;
|
||
}
|
||
return this._actorImgesOpacity;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.getImgScenes = function (actor) {
|
||
return actor._imgScenes;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.faceRefresh = function (faceIndex) {
|
||
const pw = ImageManager.faceWidth;
|
||
const ph = ImageManager.faceHeight;
|
||
const sw = Math.min(this._rectWidth, pw);
|
||
const sh = Math.min(this._rectHeight, ph);
|
||
const sx = Math.floor((faceIndex % 4) * pw + (pw - sw) / 2);
|
||
const sy = Math.floor(Math.floor(faceIndex / 4) * ph + (ph - sh) / 2);
|
||
this.setFrame(sx, sy, sw, sh);
|
||
this._imgIndex = faceIndex;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.imgFrameRefresh = function () {
|
||
//画像を切り替えるリセットされるため再設定
|
||
const scale = this._data.Actor_Scale / 100;
|
||
if (params.Img_SW > 0 || params.Img_SH > 0) {
|
||
const oriScale = 1 / scale;
|
||
const sw = (params.Img_SW || Infinity) * oriScale;
|
||
const sh = (params.Img_SH || Infinity) * oriScale;
|
||
const sx =
|
||
(this._data.Img_SX || 0) * oriScale +
|
||
(this._data.ActorImgHPosition === "center"
|
||
? (this.bitmap.width - sw) / 2
|
||
: 0);
|
||
const sy = (this._data.Img_SY || 0) * oriScale;
|
||
this.setFrame(sx, sy, sw, sh);
|
||
}
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setDeadUpdateCount = function () {
|
||
if (!params.ImgDeathHide || this.isActorGraphicDead()) {
|
||
this._updateCount = 1;
|
||
} else {
|
||
this._updateCount = this.setDeadDuration();
|
||
this._durationOpacity = this.getFadeoutOpacity();
|
||
}
|
||
this.setActorDead(true);
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setReviveUpdateCount = function () {
|
||
this._updateCount = this.setDeadDuration();
|
||
this._durationOpacity = this.getFadeoutOpacity() * -1;
|
||
this.setActorDead(false);
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.isActorGraphicDead = function () {
|
||
return this._battler.getActorGraphicDead();
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setDeadDuration = function () {
|
||
return this._startUpdate ? 1 : 30;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setDamageDuration = function () {
|
||
return params.DamageImgFrame;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setCounterDuration = function () {
|
||
return params.CounterImgFrame;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.setActorDead = function (flag) {
|
||
this._isDead = flag;
|
||
};
|
||
|
||
Sprite_ActorImges.prototype.isDead = function () {
|
||
return this._isDead;
|
||
};
|
||
|
||
//Sprite_BSGauge
|
||
function Sprite_BSGauge() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Sprite_BSGauge.prototype = Object.create(Sprite_Gauge.prototype);
|
||
Sprite_BSGauge.prototype.constructor = Sprite_BSGauge;
|
||
|
||
Sprite_BSGauge.prototype.initialize = function () {
|
||
this._statusType = $gameTemp.bsGaugeType;
|
||
this.userStatusParam = $gameTemp.userStatusParam;
|
||
this._data = $gameTemp.actorData;
|
||
this._gaugeHeight = this.getGBSGaugeHeight();
|
||
if (!params.ActorStatusVariable) {
|
||
this._gaugeWidth = Math.min(
|
||
BattleManager.rectMaxWidth,
|
||
this.getGBSGaugeWidth()
|
||
);
|
||
}
|
||
Sprite_Gauge.prototype.initialize.call(this);
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.setup = function (battler, statusType) {
|
||
Sprite_Gauge.prototype.setup.call(this, battler, statusType);
|
||
const width = BattleManager.rectMaxWidth;
|
||
if (params.ActorStatusVariable && this.bitmapWidth() !== width) {
|
||
this._gaugeWidth = Math.min(
|
||
BattleManager.rectMaxWidth,
|
||
this.getGBSGaugeWidth()
|
||
);
|
||
this.redraw();
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.bitmapWidth = function () {
|
||
return this._gaugeWidth ? this._gaugeWidth : this.bitmapBaseWidth();
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.gaugeHeight = function () {
|
||
return this._gaugeHeight;
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.bitmapBaseWidth = function () {
|
||
return params.ActorStatusVariable
|
||
? BattleManager.gaugeMaxWidth
|
||
: Math.min(BattleManager.gaugeMaxWidth, BattleManager.rectMaxWidth);
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.getGBSGaugeWidth = function () {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Width
|
||
: this._data.HPGaugeWidth;
|
||
case "mp":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Width
|
||
: this._data.MPGaugeWidth;
|
||
case "tp":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Width
|
||
: this._data.TPGaugeWidth;
|
||
case "time":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Width
|
||
: this._data.TPBGaugeWidth;
|
||
default:
|
||
return this.userStatusParam ? this.userStatusParam.Width : 128;
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.getGBSGaugeHeight = function () {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Height
|
||
: this._data.HPGaugeHeight;
|
||
case "mp":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Height
|
||
: this._data.MPGaugeHeight;
|
||
case "tp":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Height
|
||
: this._data.TPGaugeHeight;
|
||
case "time":
|
||
return this.userStatusParam
|
||
? this.userStatusParam.Height
|
||
: this._data.TPBGaugeHeight;
|
||
default:
|
||
return this.userStatusParam ? this.userStatusParam.Height : 12;
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.currentValue = function () {
|
||
if (this._battler && this.userStatusParam) {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
case "mp":
|
||
case "tp":
|
||
case "time":
|
||
return Sprite_Gauge.prototype.currentValue.call(this);
|
||
default:
|
||
return eval(this.userStatusParam.DetaEval1);
|
||
}
|
||
} else {
|
||
return Sprite_Gauge.prototype.currentValue.call(this);
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.currentMaxValue = function () {
|
||
if (this._battler && this.userStatusParam) {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
case "mp":
|
||
case "tp":
|
||
case "time":
|
||
return Sprite_Gauge.prototype.currentMaxValue.call(this);
|
||
default:
|
||
return eval(this.userStatusParam.DetaEval2);
|
||
}
|
||
} else {
|
||
return Sprite_Gauge.prototype.currentMaxValue.call(this);
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.label = function () {
|
||
if (this._battler && this.userStatusParam) {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
case "mp":
|
||
case "tp":
|
||
case "time":
|
||
return Sprite_Gauge.prototype.label.call(this);
|
||
default:
|
||
return this.userStatusParam.ParamName;
|
||
}
|
||
} else {
|
||
return Sprite_Gauge.prototype.label.call(this);
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.gaugeColor1 = function () {
|
||
if (this._battler && this.userStatusParam) {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
case "mp":
|
||
case "tp":
|
||
case "time":
|
||
return Sprite_Gauge.prototype.gaugeColor1.call(this);
|
||
default:
|
||
return NuunManager.getColorCode(this.userStatusParam.Color1);
|
||
}
|
||
} else {
|
||
return Sprite_Gauge.prototype.gaugeColor1.call(this);
|
||
}
|
||
};
|
||
|
||
Sprite_BSGauge.prototype.gaugeColor2 = function () {
|
||
if (this._battler && this.userStatusParam) {
|
||
switch (this._statusType) {
|
||
case "hp":
|
||
case "mp":
|
||
case "tp":
|
||
case "time":
|
||
return Sprite_Gauge.prototype.gaugeColor2.call(this);
|
||
default:
|
||
return NuunManager.getColorCode(this.userStatusParam.Color2);
|
||
}
|
||
} else {
|
||
return Sprite_Gauge.prototype.gaugeColor2.call(this);
|
||
}
|
||
};
|
||
|
||
//Sprite_NuunUserParam
|
||
function Sprite_NuunUserParam() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Sprite_NuunUserParam.prototype = Object.create(Sprite.prototype);
|
||
Sprite_NuunUserParam.prototype.constructor = Sprite_NuunUserParam;
|
||
|
||
Sprite_NuunUserParam.prototype.initialize = function () {
|
||
Sprite.prototype.initialize.call(this);
|
||
this.initMembers();
|
||
this.createBitmap();
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.initMembers = function () {
|
||
this._battler = null;
|
||
this._textColor = "";
|
||
this.userStatusParam = $gameTemp.userStatusParam;
|
||
this._gaugeWidth = this.userStatusParam.Width;
|
||
this._gaugeHeight = this.userStatusParam.Height;
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.setup = function (battler) {
|
||
this._battler = battler;
|
||
this._paramData = null;
|
||
this.updateBitmap();
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.destroy = function (options) {
|
||
this.bitmap.destroy();
|
||
Sprite.prototype.destroy.call(this, options);
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.update = function () {
|
||
Sprite.prototype.update.call(this);
|
||
this.updateBitmap();
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.createBitmap = function () {
|
||
const width = this.bitmapWidth();
|
||
const height = this.bitmapHeight();
|
||
this.bitmap = new Bitmap(width, height);
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.bitmapWidth = function () {
|
||
return this._gaugeWidth;
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.bitmapHeight = function () {
|
||
return this._gaugeHeight;
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.updateBitmap = function () {
|
||
const _param = eval(this.userStatusParam.DetaEval1);
|
||
if (this._paramData !== _param) {
|
||
this._paramData = _param;
|
||
this.redraw();
|
||
}
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.redraw = function () {
|
||
const paramName = this.userStatusParam.ParamName
|
||
? this.userStatusParam.ParamName
|
||
: "";
|
||
const width = this.bitmapWidth();
|
||
const height = this.bitmapHeight();
|
||
this.setupFont();
|
||
this.bitmap.clear();
|
||
this.bitmap.textColor = ColorManager.systemColor();
|
||
const textWidth = Math.max(60, this.bitmap.measureTextWidth(paramName));
|
||
this.bitmap.drawText(paramName, 0, 0, width - textWidth, height);
|
||
this.bitmap.textColor = ColorManager.normalColor();
|
||
this.bitmap.drawText(
|
||
this._paramData,
|
||
textWidth + 8,
|
||
0,
|
||
width - (textWidth + 8),
|
||
height,
|
||
"right"
|
||
);
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.fontSize = function () {
|
||
return $gameSystem.mainFontSize() + (this.userStatusParam.FontSize || 0);
|
||
};
|
||
|
||
Sprite_NuunUserParam.prototype.setupFont = function () {
|
||
this.bitmap.fontSize = this.fontSize();
|
||
};
|
||
|
||
function Sprite_BSName() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Sprite_BSName.prototype = Object.create(Sprite_Name.prototype);
|
||
Sprite_BSName.prototype.constructor = Sprite_BSName;
|
||
|
||
Sprite_BSName.prototype.initialize = function () {
|
||
this.userStatusParam = $gameTemp.userStatusParam;
|
||
this._nameHeight =
|
||
this.userStatusParam.Height > 24 ? this.userStatusParam.Height : 24;
|
||
if (!params.ActorStatusVariable) {
|
||
this._nameWidth = Math.min(
|
||
BattleManager.rectMaxWidth,
|
||
this.getGBSNameWidth()
|
||
);
|
||
}
|
||
Sprite_Name.prototype.initialize.call(this);
|
||
};
|
||
|
||
Sprite_BSName.prototype.setup = function (battler) {
|
||
Sprite_Name.prototype.setup.call(this, battler);
|
||
const width = BattleManager.rectMaxWidth;
|
||
if (params.ActorStatusVariable && this.bitmapWidth() !== width) {
|
||
this._nameWidth = Math.min(
|
||
BattleManager.rectMaxWidth,
|
||
this.getGBSNameWidth()
|
||
);
|
||
this.redraw();
|
||
}
|
||
};
|
||
|
||
Sprite_BSName.prototype.bitmapWidth = function () {
|
||
return this._nameWidth ? this._nameWidth : this.bitmapBaseWidth();
|
||
};
|
||
|
||
Sprite_BSName.prototype.bitmapHeight = function () {
|
||
return this._nameHeight;
|
||
};
|
||
|
||
Sprite_BSName.prototype.bitmapBaseWidth = function () {
|
||
return params.ActorStatusVariable
|
||
? BattleManager.gaugeMaxWidth
|
||
: Math.min(BattleManager.gaugeMaxWidth, BattleManager.rectMaxWidth);
|
||
};
|
||
|
||
Sprite_BSName.prototype.getGBSNameWidth = function () {
|
||
return this.userStatusParam ? this.userStatusParam.Width : 128;
|
||
};
|
||
|
||
Sprite_BSName.prototype.fontSize = function () {
|
||
return $gameSystem.mainFontSize() + (this.userStatusParam.FontSize || 0);
|
||
};
|
||
|
||
const _Sprite_StateIcon_initMembers = Sprite_StateIcon.prototype.initMembers;
|
||
Sprite_StateIcon.prototype.initMembers = function () {
|
||
_Sprite_StateIcon_initMembers.call(this);
|
||
this._visibleStateIcons = [];
|
||
};
|
||
|
||
Sprite_StateIcon.prototype.setupVisibleIcons = function (list1, list2) {
|
||
this._visibleStateIcons = [];
|
||
this._visibleStateIcons = list1
|
||
.filter((stateId) => stateId > 0 && $dataStates[stateId].iconIndex > 0)
|
||
.map((stateId) => $dataStates[stateId].iconIndex);
|
||
Array.prototype.push.apply(
|
||
this._visibleStateIcons,
|
||
BattleManager.getVisibleBuffIcons(list2)
|
||
);
|
||
};
|
||
|
||
const _Sprite_StateIcon_shouldDisplay =
|
||
Sprite_StateIcon.prototype.shouldDisplay;
|
||
Sprite_StateIcon.prototype.shouldDisplay = function () {
|
||
const result = _Sprite_StateIcon_shouldDisplay.call(this);
|
||
if (result && this._battler.isActor()) {
|
||
BattleManager.visibleStateIcons = this._visibleStateIcons;
|
||
}
|
||
return result;
|
||
};
|
||
|
||
const _Sprite_StateIcon_updateFrame = Sprite_StateIcon.prototype.updateFrame;
|
||
Sprite_StateIcon.prototype.updateFrame = function () {
|
||
this._index = params.NoneStateIcon > 0 ? params.NoneStateIcon : this._index;
|
||
_Sprite_StateIcon_updateFrame.call(this);
|
||
};
|
||
|
||
const _Sprite_StateIcon_setFrameIcon =
|
||
Sprite_StateIcon.prototype.setFrameIcon;
|
||
Sprite_StateIcon.prototype.setFrameIcon = function (sprite) {
|
||
sprite._iconIndex =
|
||
params.NoneStateIcon > 0 ? params.NoneStateIcon : sprite._iconIndex;
|
||
_Sprite_StateIcon_setFrameIcon.call(this, sprite);
|
||
};
|
||
|
||
function Sprite_BSStateIcon() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Sprite_BSStateIcon.prototype = Object.create(Sprite_StateIcon.prototype);
|
||
Sprite_BSStateIcon.prototype.constructor = Sprite_BSStateIcon;
|
||
|
||
Sprite_BSStateIcon.prototype.initialize = function () {
|
||
Sprite.prototype.initialize.call(this);
|
||
this.initMembers();
|
||
this.createBitmap();
|
||
this.loadBitmap();
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.initMembers = function () {
|
||
//this.userStatusParam = $gameTemp.userStatusParam;
|
||
this._battler = null;
|
||
this._animationCount = 0;
|
||
this.anchor.x = 0;
|
||
this.anchor.y = 0;
|
||
this._visibleIcons = [];
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.bitmapWidth = function () {
|
||
return this._iconWidth ? this._iconWidth : BattleManager.gaugeMaxWidth;
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.bitmapHeight = function () {
|
||
return 36;
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.createBitmap = function () {
|
||
const width = this.bitmapWidth();
|
||
const height = this.bitmapHeight();
|
||
this.bitmap = new Bitmap(width, height);
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.loadBitmap = function () {
|
||
this.iconBitmap = ImageManager.loadSystem("IconSet");
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.setupVisibleIcons = function (list1, list2) {
|
||
this._visibleIcons = [];
|
||
this._visibleIcons = list1
|
||
.filter((stateId) => stateId > 0 && $dataStates[stateId].iconIndex > 0)
|
||
.map((stateId) => $dataStates[stateId].iconIndex);
|
||
Array.prototype.push.apply(
|
||
this._visibleIcons,
|
||
BattleManager.getVisibleBuffIcons(list2)
|
||
);
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.setup = function (battler, data) {
|
||
if (this._battler !== battler) {
|
||
this._battler = battler;
|
||
this._animationCount = this.updateWait();
|
||
}
|
||
const width = BattleManager.rectMaxWidth;
|
||
if (this._iconWidth !== width) {
|
||
this._iconWidth = width;
|
||
this.updateIcon();
|
||
}
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.update = function () {
|
||
Sprite.prototype.update.call(this);
|
||
this._animationCount++;
|
||
if (this._animationCount >= this.updateWait()) {
|
||
this.updateIcon();
|
||
this._animationCount = 0;
|
||
}
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.updateWait = function () {
|
||
return 1;
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.updateIcon = function () {
|
||
this.bitmap.clear();
|
||
let icons = [];
|
||
const iconWidth = ImageManager.iconWidth;
|
||
const actor = this._battler;
|
||
if (this.shouldDisplay()) {
|
||
if (this._visibleIcons.length > 0) {
|
||
icons = actor
|
||
.stateIcons()
|
||
.filter((icon) => this._visibleIcons.some((i) => i === icon))
|
||
.slice(0, Math.floor(this.bitmapWidth() / iconWidth));
|
||
} else {
|
||
icons = actor
|
||
.stateIcons()
|
||
.slice(0, Math.floor(this.bitmapWidth() / iconWidth));
|
||
}
|
||
}
|
||
if (icons.length > 0) {
|
||
let iconX = 0;
|
||
const y = 0;
|
||
for (const icon of icons) {
|
||
this.drawIcon(icon, iconX, y);
|
||
iconX += iconWidth;
|
||
}
|
||
}
|
||
};
|
||
|
||
Sprite_BSStateIcon.prototype.drawIcon = function (iconIndex, x, y) {
|
||
const bitmap = ImageManager.loadSystem("IconSet");
|
||
const pw = ImageManager.iconWidth;
|
||
const ph = ImageManager.iconHeight;
|
||
const sx = (iconIndex % 16) * pw;
|
||
const sy = Math.floor(iconIndex / 16) * ph;
|
||
this.bitmap.blt(bitmap, sx, sy, pw, ph, x, y);
|
||
};
|
||
|
||
//Spriteset_Base
|
||
const _Spriteset_Base_animationShouldMirror =
|
||
Spriteset_Base.prototype.animationShouldMirror;
|
||
Spriteset_Base.prototype.animationShouldMirror = function (target) {
|
||
return params.ActorsMirror
|
||
? _Spriteset_Base_animationShouldMirror.call(this, target)
|
||
: false;
|
||
};
|
||
|
||
//Spriteset_Battle
|
||
const _Spriteset_Battle_initialize = Spriteset_Battle.prototype.initialize;
|
||
Spriteset_Battle.prototype.initialize = function () {
|
||
_Spriteset_Battle_initialize.call(this);
|
||
};
|
||
|
||
const _Spriteset_Battle_findTargetSprite =
|
||
Spriteset_Battle.prototype.findTargetSprite;
|
||
Spriteset_Battle.prototype.findTargetSprite = function (target) {
|
||
const targetSprite = _Spriteset_Battle_findTargetSprite.call(this, target);
|
||
this._effectsContainer = this.animationTarget(targetSprite)
|
||
? this._effectsFrontContainer
|
||
: this._effectsBackContainer;
|
||
return targetSprite;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.animationTarget = function (targetSprites) {
|
||
if (
|
||
!$gameSystem.isSideView() &&
|
||
params.ActorEffectShow &&
|
||
targetSprites &&
|
||
targetSprites.viewFrontActor
|
||
) {
|
||
return !!targetSprites._battler.isActor();
|
||
}
|
||
return false;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createStatusLayer = function () {
|
||
this.createBattleHud(); //ベーススプライト
|
||
this.createHudBack(); //ウィンドウ、アクターグラフィック
|
||
this.createEffects(); //アニメーション
|
||
this.createHudStatus(); //ステータス
|
||
this.createFrontActors();
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createBattleHud = function () {
|
||
const sprite = new Sprite();
|
||
this.addChild(sprite);
|
||
this._battleHudBase = sprite;
|
||
};
|
||
|
||
const _Spriteset_Battle_update = Spriteset_Battle.prototype.update;
|
||
Spriteset_Battle.prototype.update = function () {
|
||
_Spriteset_Battle_update.call(this);
|
||
this.updateEffects();
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createHudBack = function () {
|
||
const sprite = new Sprite();
|
||
this._battleHudBase.addChild(sprite);
|
||
this._battleHudBack = sprite;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createHudStatus = function () {
|
||
const sprite = new Sprite();
|
||
this._battleHudBase.addChild(sprite);
|
||
this._battleHudFront = sprite;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createEffects = function () {
|
||
const sprite = this.setBattleBase();
|
||
this._battleHudBase.addChild(sprite);
|
||
this._battleEffects = sprite;
|
||
this._effectsFrontContainer = sprite;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createDamege = function () {
|
||
const sprite = this.setBattleBase();
|
||
this._battleHudBase.addChild(sprite);
|
||
this._battleDamege = sprite;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.updateEffects = function () {
|
||
this._battleDamege.x = this._battleEffects.x;
|
||
this._battleDamege.y = this._battleEffects.y;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.setBattleBase = function () {
|
||
const width =
|
||
params.ActorStatusWindow_Width > 0
|
||
? params.ActorStatusWindow_Width
|
||
: Graphics.boxWidth;
|
||
const height = Graphics.boxHeight;
|
||
const x =
|
||
(params.ActorStatusWindowCenter ? getActorWindowCenter() : 0) +
|
||
params.ActorStatusWindow_X;
|
||
const y = 0;
|
||
const sprite = new Sprite();
|
||
sprite.setFrame(0, 0, width, height);
|
||
sprite.x = x;
|
||
sprite.y = y - this.battleFieldOffsetY();
|
||
sprite.home_x = x;
|
||
return sprite;
|
||
};
|
||
|
||
Spriteset_Battle.prototype.createFrontActors = function () {
|
||
this.createDamege();
|
||
if (!$gameSystem.isSideView() && params.ActorEffectShow) {
|
||
this._actorSprites = [];
|
||
for (let i = 0; i < $gameParty.maxBattleMembers(); i++) {
|
||
const sprite = new Sprite_BSFrontActor();
|
||
this._actorSprites.push(sprite);
|
||
this._battleDamege.addChild(sprite);
|
||
}
|
||
}
|
||
};
|
||
|
||
const _Spriteset_Battle_createBattleField =
|
||
Spriteset_Battle.prototype.createBattleField;
|
||
Spriteset_Battle.prototype.createBattleField = function () {
|
||
_Spriteset_Battle_createBattleField.call(this);
|
||
this._effectsBackContainer = this._battleField;
|
||
};
|
||
|
||
function conditionsParam(data, param, maxParam) {
|
||
return (
|
||
param >= (maxParam * data.DwLimit) / 100 &&
|
||
(data.UpLimit > 0 ? param <= (maxParam * data.UpLimit) / 100 : true)
|
||
);
|
||
}
|
||
})();
|