关于Hakubox_BreakBar韧性条的显示bug

Doolet · 发表于昨天 19:41

本帖最后由 Doolet 于 2026-10-18 19:44 编辑

各位老大好！！

我在使用Hakubox_BreakBar韧性条插件攻击敌人显示韧性条的时候，遇到了韧性条击破归0时，突然重新跳到满韧性的显示问题。
只是显示问题，实际上是已经处于破韧的状态了.

想求助各位老大们，这个韧性条的显示问题到底是出在哪

每回合开始时敌人的韧性条都会从满格突然跳一下回到当前韧性，我不知道是不是和这个有关系.

这里是bug的项目案例链接:(QQ文件闪传)
https://qfile.qq.com/q/YUpMfsRE4I

这里是韧性条的脚本

//=============================================================================
// ** RPG Maker MZ - Hakubox_BreakBar.js
//=============================================================================
// #region 脚本注释
/*:
* @plugindesc 韧性条插件
* @version 1.0.1
* @author hakubox
* @email hakubox226@gmail.com
* @target MV MZ
*
* @help
* 给BOSS添加了一个韧性条，加了之后boss会破防
* 修复：破防后韧性条显示0，破防期间不能增减韧性，不会重复破韧
*
* // 给敌人设置最大破防值，加了这个之后才会显示韧性条
* <haku-ap:900>
* // 在技能的备注里加，给自己涨韧性条
* <haku-ap-add:500>
* // 破防结束后会增加某个状态，破防时则移除状态
* <haku-not-break-state:42>
*
* 调用脚本：
* HakuBreakBarUtils.setAp(enemyId, ap);
*
* → enemyId 敌人Id（在数据库敌人列表中查看）
* → ap Ap值（破防值）
*
*
* @param breakSound
* @text 破防音频
* @desc 破防Break时播放的音频
* @type file
* @dir audio/se/
*
* @param ui
* @text ——————— 界面配置 ———————
* @default ————————————————————————
*
* @param bgImage
* @parent ui
* @text 韧性条背景图
* @desc 韧性条背景图
* @type file
* @dir img/pictures/
*
* @param x
* @parent ui
* @text 韧性条横向X坐标
* @desc 韧性条横向X坐标
* @type number
* @min -1000
*
* @param y
* @parent ui
* @text 韧性条纵向Y坐标
* @desc 韧性条纵向Y坐标
* @type number
* @min -1000
*
* @param bgBarImage
* @parent ui
* @text 破防槽图片
* @desc 破防槽图片
* @type file
* @dir img/pictures/
*
* @param barX
* @parent ui
* @text 破防槽图片横向X坐标
* @desc 破防槽图片横向X坐标
* @type number
* @min -1000
*
* @param barY
* @parent ui
* @text 破防槽图片纵向Y坐标
* @desc 破防槽图片纵向Y坐标
* @type number
* @min -1000
*
*
* @param barLabel
* @parent ui
* @text ——— 韧性标签文本 ———
* @default ——————————
*
* @param labelX
* @parent barLabel
* @text 标签横向X坐标
* @desc 标签横向X坐标
* @type number
* @min -1000
*
* @param labelY
* @parent barLabel
* @text 标签纵向Y坐标
* @desc 标签纵向Y坐标
* @type number
* @min -1000
*
* @param barLabelText
* @parent barLabel
* @text 标签文字
* @desc 标签文字
* @type text
* @default 韧性
*
* @param barLabelFontColor
* @parent barLabel
* @text 标签文字颜色
* @desc 标签文字颜色
* @type text
* @default #FFFFFF
*
* @param barLabelFontSize
* @parent barLabel
* @text 标签文字大小
* @desc 标签文字大小
* @type number
* @default 12
*
* @param barLabelLineHeight
* @parent barLabel
* @text 标签文字行高
* @desc 标签文字行高
* @type number
* @default 30
*
* @param barLabelAlign
* @parent barLabel
* @text 标签文字对齐方式
* @desc 标签文字对齐方式
* @type select
* @option left
* @value left
* @option center
* @value center
* @option right
* @value right
* @default left
*
*
* @param barValue
* @parent ui
* @text ——— 韧性数值文本 ———
* @default ——————————
*
* @param barTextFontColor
* @parent barValue
* @text 数值文字颜色
* @desc 数值文字颜色
* @type string
* @default #FFFFFF
*
* @param barTextFontSize
* @parent barValue
* @text 数值文字大小
* @desc 数值文字大小
* @type number
* @default 12
*
* @param barTextLineHeight
* @parent barValue
* @text 数值文字行高
* @desc 数值文字行高
* @type number
* @default 30
*
* @param barTextAlign
* @parent barValue
* @text 数值文字对齐
* @desc 数值文字对齐方式
* @type select
* @option left
* @value left
* @option center
* @value center
* @option right
* @value right
* @default center
*
*
* @param feature
* @text ——————— 功能配置 ———————
* @default ————————————————————————
*
* @param turnRecovery
* @parent feature
* @text 每回合回复数值
* @desc 每回合回复数值，大于1为具体数值，小于1则为百分比
* @type text
*
* @param breakState
* @parent feature
* @text 破防后附加状态
* @desc 破防后附加状态
* @type state
*
* @param bossTag
* @parent feature
* @text 指定boss的标签
* @desc 指定boss的标签
* @type text
* @default Boss HP
*
* @param basicDamageRate
* @parent feature
* @text 基础AP伤害倍率
* @desc 基础AP伤害倍率
* @type text
* @default 1
*
* @param propConfig
* @parent feature
* @text 属性倍率设置
* @desc 包含属性类型和倍率设置
* @type struct<PropConfig>[]
* @min []
*
* @param weaponConfig
* @parent feature
* @text 武器类型倍率设置
* @desc 包含武器类型和倍率设置
* @type struct<WeaponConfig>[]
* @min []
*
* @param stateConfig
* @parent feature
* @text 己方状态倍率设置
* @desc 包含自身状态和倍率设置
* @type struct<StateConfig>[]
* @min []
*
* @param enemyStateConfig
* @parent feature
* @text 敌方状态倍率设置
* @desc 包含敌方状态和倍率设置
* @type struct<StateConfig>[]
* @min []
*
*/
/*~struct~PropConfig:
*
* @param remark
* @text 备注
* @desc 该配置项的备注说明
* @type note
*
* @param propElementId
* @text 属性类型
* @type number
* @min -1
*
* @param rate
* @text 倍率
* @desc 对韧性条的伤害倍率，填写百分比数值
* @type number
* @min 0
* @default 100
*
*/
/*~struct~WeaponConfig:
*
* @param remark
* @text 备注
* @desc 该配置项的备注说明
* @type note
*
* @param weaponTypeId
* @text 武器类型
* @type number
* @min -1
*
* @param rate
* @text 倍率
* @desc 对韧性条的伤害倍率，填写百分比数值
* @type number
* @min 0
* @default 100
*
*/
/*~struct~StateConfig:
*
* @param remark
* @text 备注
* @desc 该配置项的备注说明
* @type note
*
* @param stateId
* @text 状态类型
* @type state
* @min -1
*
* @param rate
* @text 倍率
* @desc 对韧性条的伤害倍率，填写百分比数值
* @type number
* @min 0
* @default 100
*
*/
(() => {
/** 插件名称 */
const PluginName = document.currentScript ? decodeURIComponent(document.currentScript.src.match(/^.*\/(.+)\.js$/)[1]) : "Hakubox_BreakBar";
// #region 插件参数解释器
class PluginParamsParser {
constructor(predictEnable = true) {
this._predictEnable = predictEnable;
}
static parse(params, typeData, predictEnable = true) {
return new PluginParamsParser(predictEnable).parse(params, typeData);
}
parse(params, typeData, loopCount = 0) {
if (++loopCount > 255)
throw new Error("endless loop error");
const result = {};
for (const name in typeData) {
if (params[name] === "" || params[name] === undefined) {
result[name] = null;
}
else {
result[name] = this.convertParam(params[name], typeData[name], loopCount);
}
}
if (!this._predictEnable)
return result;
if (typeof params === "object" && !(params instanceof Array)) {
for (const name in params) {
if (result[name])
continue;
const param = params[name];
const type = this.predict(param);
result[name] = this.convertParam(param, type, loopCount);
}
}
return result;
}
convertParam(param, type, loopCount) {
if (typeof type === "string") {
let str = param;
if (str[0] == '"' && str[str.length - 1] == '"') {
str = str.substring(1, str.length - 1).replace(/\\n/g, '\n').replace(/\"/g, '"')
}
return this.cast(str, type);
}
else if (typeof type === "object" && type instanceof Array) {
const aryParam = JSON.parse(param);
if (type[0] === "string") {
return aryParam.map((strParam) => this.cast(strParam, type[0]));
} else if (type[0] === "number") {
return aryParam.map((strParam) => this.cast(strParam, type[0]));
} else {
if (!aryParam.length) return [];
else {
if (typeof aryParam === "string") {
return JSON.parse(aryParam);
} else {
return aryParam.map((strParam) => this.parse(JSON.parse(strParam), type[0]), loopCount);
}
}
}
}
else if (typeof type === "object") {
return this.parse(JSON.parse(param), type, loopCount);
}
else {
throw new Error(`${type} is not string or object`);
}
}
cast(param, type) {
switch (type) {
case "any":
if (!this._predictEnable)
throw new Error("Predict mode is disable");
return this.cast(param, this.predict(param));
case "string":
return param;
case "number":
if (param.match(/^\-?\d+\.\d+$/))
return parseFloat(param);
return parseInt(param);
case "boolean":
return param === "true";
default:
throw new Error(`Unknow type: ${type}`);
}
}
predict(param) {
if (param.match(/^\-?\d+$/) || param.match(/^\-?\d+\.\d+$/)) {
return "number";
}
else if (param === "true" || param === "false") {
return "boolean";
}
else {
return "string";
}
}
}
const typeDefine = {
propConfig: [],
weaponConfig: [],
stateConfig: [],
enemyStateConfig: [],
};
const params = PluginParamsParser.parse(PluginManager.parameters(PluginName), typeDefine);
// #region 基础配置
/** 基础配置 */
const config = {
/** 每回合自动回复量 */
addTurnRecovery(maxAp) {
let value = 0;
if (params.turnRecovery) {
if (params.turnRecovery <= 1) {
value = params.turnRecovery * maxAp;
} else {
value = params.turnRecovery;
}
}
return +value;
},
/** 是否显示 */
visible: true,
container: undefined,
/** 当前敌人索引 */
enemyId: 0,
/** 多个敌人的信息 */
enemyInfos: {},
/** 敌人信息 */
enemyInfo: {
enemy: undefined,
ap: 0,
map: 0,
},
/** 获得当前敌人 */
get enemy() {
return this.enemyInfos[this.enemyId].enemy;
},
/** 赋值敌人 */
set enemy(value) {
this.enemyInfos[value._enemyId].enemy = value;
},
/** 当前敌人是否有Ap */
get hasAp() {
return this.enemyInfos[this.enemyId].hasAp;
},
/** 获得当前AP */
get ap() {
if (this.enemyInfos[this.enemyId]) {
return this.enemyInfos[this.enemyId].ap || 0;
} else {
return 0;
}
},
/** 赋值AP */
set ap(value) {
if (!this.enemyInfos[this.enemyId]) return;
let _val = value;
if (_val > this.map) {
_val = this.map;
} else if (_val < 0) {
_val = 0;
}
this.enemyInfos[this.enemyId].ap = _val;
},
/** 获得当前MaxAP */
get map() {
if (this.enemyInfos[this.enemyId]) {
return this.enemyInfos[this.enemyId].map || 0;
} else {
return 0;
}
},
/** 赋值MaxAP */
set map(value) {
if (!this.enemyInfos[this.enemyId]) return;
this.enemyInfos[this.enemyId].map = value;
},
/** 上一次的韧性 */
get prevValue() {
return this.enemyInfos[this.enemyId].prevValue || 0;
},
/** 赋值上一次的韧性 */
set prevValue(value) {
this.enemyInfos[this.enemyId].prevValue = value;
},
// 是否初始化完成
isInit: false,
// 是否初始化了敌人
isInitEnemy: false,
// 背景图片
bgBitmap: ImageManager.reservePicture(params.bgImage),
// 背景图片精灵（进度条
bgSprite: undefined,
// 韧性条的图片
barBitmap: undefined,
// 临时的韧性条的图片
barTempBitmap: ImageManager.reservePicture(params.bgBarImage),
// 韧性条的精灵
barSprite: undefined,
// 文本图层
textSprite: undefined,
// 韧性条的宽度
barWidth: 0,
// 当前帧
frameIndex: 0,
// 最大帧
maxFrame: 20,
// 是否开始动画
isStartAnime: false,
// 动画的进度
progress: 0,
};
// #endregion
// #region 韧性条
class BreakBar {
static destroy() {
config.enemyInfos = {};
config.enemyId = 0;
config.isInit = false;
config.isInitEnemy = false;
}
static initEnemy() {
config.enemyInfos = {};
config.enemyId = 0;
const _members = $gameTroop.members();
for (let i = 0; i < _members.length; i++) {
const _member = _members[i];
const _enemy = $dataEnemies[_member._enemyId];
const _note = _enemy.note;
const _ap = Number(_enemy.meta['haku-ap'] || 0);
config.enemyInfos[_member._enemyId] = {
prevValue: _ap,
enemy: _enemy,
ap: _ap,
map: _ap,
hasAp: _note.includes(params.bossTag) && _ap > 0,
isBreak: false,
};
if (_note.includes(params.bossTag) && _ap > 0) {
config.enemyId = _member._enemyId;
config.visible = true;
}
}
if (!config.enemyId) {
config.enemyId = _members[_members.length - 1]._enemyId;
}
config.isInitEnemy = true;
}
/** 初始化 */
static init(parent) {
config.container = new PIXI.Container();
config.visible = false;
// 等待图片加载完成
config.barTempBitmap.addLoadListener(() => {
config.bgBitmap.addLoadListener(() => {
// 获取韧性条的宽度
config.barWidth = config.barTempBitmap.width;
// 创建背景图精灵
config.bgSprite = new Sprite(config.bgBitmap);
config.bgSprite.x = params.x;
config.bgSprite.y = params.y;
// 创建标签的精灵
config.labelSprite = new Sprite(
new Bitmap(config.bgBitmap.width, Math.max(config.bgBitmap.height, +params.barLabelLineHeight))
);
config.labelSprite.x = params.x + params.labelX;
config.labelSprite.y = params.y + params.labelY;
// 创建文本的精灵
config.textSprite = new Sprite(
new Bitmap(config.bgBitmap.width, Math.max(config.bgBitmap.height, +params.barTextLineHeight))
);
config.textSprite.x = params.x;
config.textSprite.y = params.y;
// 创建韧性条的精灵
config.barBitmap = new Bitmap(config.barWidth, config.barTempBitmap.height);
config.barSprite = new Sprite(config.barBitmap);
config.barSprite.x = params.x + params.barX;
config.barSprite.y = params.y + params.barY;
// 画出当前韧性条（有可能第一次画的时候韧性就不是满的，所以需要计算）
const _apProgress = config.ap / config.map;
config.barBitmap.blt(config.barTempBitmap,
0, 0, Math.floor(_apProgress * config.barBitmap.width), config.barTempBitmap.height,
0, 0, Math.floor(_apProgress * config.barBitmap.width), config.barTempBitmap.height
);
// 画出韧性的标签
config.labelSprite.bitmap.textColor = params.barLabelFontColor;
config.labelSprite.bitmap.fontSize = +params.barLabelFontSize;
config.labelSprite.bitmap.drawText(
params.barLabelText,
0,
0,
config.bgBitmap.width, +params.barLabelLineHeight, params.barLabelAlign
);
// 画出韧性的文本
config.textSprite.bitmap.textColor = params.barTextFontColor;
config.textSprite.bitmap.fontSize = +params.barTextFontSize;
config.textSprite.bitmap.drawText(
`${config.ap}/${config.map}`,
0,
0,
config.bgBitmap.width, +params.barTextLineHeight, params.barTextAlign
);
// 都加到当前的场景中
config.container.addChild(config.bgSprite);
config.container.addChild(config.barSprite);
config.container.addChild(config.labelSprite);
config.container.addChild(config.textSprite);
if (!config.ap) {
config.container.alpha = 0;
}
parent.addChild(config.container);
// 标记初始化完成
config.isInit = true;
});
});
}
/** 切换敌人 */
static changeEnemy(enemyId) {
config.enemyId = enemyId;
}
/** 下一帧 */
static nextFrame() {
config.frameIndex++;
if (config.frameIndex > config.maxFrame) {
config.frameIndex = 0;
config.isStartAnime = false;
}
// 计算当前的显示进度
config.progress = config.frameIndex / config.maxFrame;
}
static update() {
if (config.isInit && config.isStartAnime) {
// 清空韧性条与韧性文本
config.barBitmap.clear();
config.textSprite.bitmap.clear();
config.labelSprite.bitmap.clear();
if (config.visible) {
config.container.alpha = 1;
} else {
config.container.alpha = 0;
}
if (config.visible) {
// 读取当前敌人信息，破防强制进度=0
const curEnemyInfo = config.enemyInfos[config.enemyId];
let progress;
if(curEnemyInfo && curEnemyInfo.isBreak){
progress = 0;
}else{
progress = (config.prevValue - (config.prevValue - config.ap) * config.progress) / config.map;
}
// 画出当前韧性条
config.barBitmap.blt(config.barTempBitmap,
0, 0, Math.floor(progress * config.barBitmap.width), config.barTempBitmap.height,
0, 0, Math.floor(progress * config.barBitmap.width), config.barTempBitmap.height
);
// 画出韧性的标签
config.labelSprite.bitmap.textColor = params.barLabelFontColor;
config.labelSprite.bitmap.fontSize = +params.barLabelFontSize;
config.labelSprite.bitmap.drawText(
params.barLabelText,
0,
0,
config.bgBitmap.width, +params.barLabelLineHeight, params.barLabelAlign
);
// 画出韧性的文本
config.textSprite.bitmap.textColor = params.barTextFontColor;
config.textSprite.bitmap.fontSize = +params.barTextFontSize;
config.textSprite.bitmap.drawText(
`${config.ap}/${config.map}`,
0,
0,
config.bgBitmap.width, +params.barTextLineHeight, params.barTextAlign
);
}
}
}
/** 修改韧性（外部调用） */
static changeAp(ap, target, item, action) {
// 如果该敌人已经破防，直接退出，不再修改韧性
const enemyInfo = config.enemyInfos[target._enemyId];
if(enemyInfo && enemyInfo.isBreak){
return;
}
if (target._permBarrier && target._permBarrier > 0) {
return;
}
// 把当前韧性做一个历史记录
let _ap = ap * (+params.basicDamageRate);
// 添加倍率
// 属性类型倍率
if (params.propConfig.length) {
const prop = params.propConfig.find(i => i.propElementId == item.damage.elementId);
if (prop) {
_ap *= prop.rate / 100;
}
}
// 武器类型倍率
if (params.weaponConfig.length) {
const _actor = $gameActors.actor(action._subjectActorId);
if (_actor) {
const _weapon = _actor.equips().find(i => i && i.wtypeId);
if (_weapon) {
const prop = params.weaponConfig.find(i => i && i.weaponTypeId == _weapon.wtypeId);
if (prop) {
_ap *= prop.rate / 100;
}
}
}
}
// 自身状态倍率
if (params.stateConfig.length) {
const _actor = $gameActors.actor(action._subjectActorId);
if (_actor && _actor._states.length) {
for (let i = 0; i < params.stateConfig.length; i++) {
const item = params.stateConfig[i];
if (_actor._states.includes(item.stateId)) {
_ap *= item.rate / 100;
}
}
}
}
// 敌人状态倍率
if (params.enemyStateConfig.length) {
const _states = target.states();
if (target && _states.length) {
for (let i = 0; i < params.enemyStateConfig.length; i++) {
const item = params.enemyStateConfig[i];
if (_states.find(s => s.id === item.stateId)) {
_ap *= item.rate / 100;
}
}
}
}
if (config.ap + _ap < 0) {
_ap = -config.ap;
} else if (config.ap + _ap > config.map) {
_ap = config.map - config.ap;
}
config.prevValue = config.ap;
// 修改当前韧性
config.ap += Math.floor(_ap);
// 重制当前的帧数为0
config.frameIndex = 0;
// 开始动画
config.isStartAnime = true;
if (config.ap <= 0 && !config.enemyInfos[config.enemyId].isBreak) {
config.enemyInfos[config.enemyId].isBreak = true;
AudioManager.playSe({
name: params.breakSound,
volume: ConfigManager.seVolume,
pitch: 100,
pan: 0
});
// 弹出Break图片
this._result.breaked = true;
} else if (config.ap > 0 && config.enemyInfos[config.enemyId].isBreak) {
config.enemyInfos[config.enemyId].isBreak = false;
this._result.breaked = false;
}
// 添加破防状态
if (config.ap <= 0 && params.breakState && !target._states.includes(params.breakState)) {
const _notBreakState = $dataEnemies[target._enemyId].meta['haku-not-break-state'];
if (_notBreakState) {
target.removeState(+_notBreakState);
}
target.addState(params.breakState);
}
}
}
// #endregion
// #region 修改系统
const BattleManager_endTurn = BattleManager.endTurn;
BattleManager.endTurn = function() {
BattleManager_endTurn.call(this);
Object.values(config.enemyInfos).filter(i => i.hasAp).forEach(enemy => {
// 破防状态下，回合结束不恢复韧性
if(!enemy.isBreak){
HakuBreakBarUtils.setAp(enemy.enemy.id, Math.min(enemy.ap + config.addTurnRecovery(enemy.map), enemy.map));
}
});
config.frameIndex = 0;
config.isStartAnime = true;
}
const Scene_Battle_createSpriteset = Scene_Battle.prototype.createSpriteset;
Scene_Battle.prototype.createSpriteset = function() {
Scene_Battle_createSpriteset.call(this);
if (!config.isInit) {
BreakBar.init(this);
}
if (!config.isInitEnemy) {
BreakBar.initEnemy();
}
}
const Scene_Battle_update = Scene_Battle.prototype.update;
Scene_Battle.prototype.update = function() {
Scene_Battle_update.call(this);
if (config.isInit) {
BreakBar.nextFrame();
BreakBar.update();
}
};
const Scene_Battle_terminate = Scene_Battle.prototype.terminate;
Scene_Battle.prototype.terminate = function() {
Scene_Battle_terminate.call(this);
config.isInit = false;
}
const BattleManager_endBattle = BattleManager.endBattle;
BattleManager.endBattle = function(result) {
BattleManager_endBattle.call(this, result);
BreakBar.destroy();
}
const Game_Action_executeDamage = Game_Action.prototype.executeDamage;
Game_Action.prototype.executeDamage = function (target, value) {
let rate = 1;
if (config.enemyInfos[target._enemyId] && config.enemyInfos[target._enemyId].hasAp) {
const _item = this.item();
const _addAp = _item.meta['haku-ap-add'];
if (_addAp) {
if (target && !target.isActor()) {
const tInfo = config.enemyInfos[target._enemyId];
// 目标破防状态，不能涨韧性条
if (tInfo && !tInfo.isBreak && !target._states.includes(params.breakState)) {
BreakBar.changeEnemy(target._enemyId);
BreakBar.changeAp.call(target, _addAp, target, _item, this);
}
}
} else if (_item.meta['haku-ap-clear']) {
BreakBar.changeEnemy(target._enemyId);
BreakBar.changeAp.call(target, -config.ap, target, _item, this);
} else if (value > 0) {
if (target && !target.isActor()) {
if (Object.keys(config.enemyInfos).includes(target._enemyId.toString())) {
BreakBar.changeEnemy(target._enemyId);
if (config.hasAp) {
if (config.container.alpha === 0) {
config.container.alpha = 1;
}
BreakBar.changeAp.call(target, -value, target, _item, this);
}
}
}
}
}
config.visible = true;
if (target && !target.isActor() && target.hp - value * rate <= 0) {
if (config.enemyId === target._enemyId) {
config.visible = false;
}
}
Game_Action_executeDamage.call(this, target, value * rate);
};
const Game_Enemy_transform = Game_Enemy.prototype.transform;
Game_Enemy.prototype.transform = function(enemyId) {
const _oldEnemyId = this._enemyId;
Game_Enemy_transform.call(this, enemyId);
const _newEnemyId = this._enemyId;
const _enemy = $dataEnemies[_newEnemyId];
const _note = _enemy.note;
if (_note.includes(params.bossTag)) {
const _ap = Number(_enemy.meta['haku-ap'] || 0);
const _oldAp = config.ap;
config.enemyInfos[_newEnemyId] = {
prevValue: _oldAp,
enemy: _enemy,
ap: _oldAp,
map: _ap,
hasAp: _ap > 0,
isBreak: false,
};
delete config.enemyInfos[_oldEnemyId];
BreakBar.changeEnemy(_newEnemyId);
config.frameIndex = 0;
config.isStartAnime = true;
}
}
const Sprite_Damage_setup = Sprite_Damage.prototype.setup;
Sprite_Damage.prototype.setup = function(target) {
Sprite_Damage_setup.call(this, target);
var result = target.result();
if (result.breaked) {
this.createBreak();
}
};
Sprite_Damage.prototype.createBreak = function() {
var w = this.digitWidth();
var h = this.digitHeight();
var sprite = this.createChildSprite();
sprite.setFrame(95, 4 * h, 6 * w, h);
sprite.dy = 0;
};
const Game_Battler_removeState = Game_Battler.prototype.removeState;
Game_Battler.prototype.removeState = function(stateId) {
Game_Battler_removeState.call(this, stateId);
if (stateId == params.breakState && !this.isActor()) {
const enemyInfo = config.enemyInfos[this._enemyId];
if(enemyInfo){
// 破防状态解除，韧性恢复满，解除isBreak标记
enemyInfo.ap = enemyInfo.map;
enemyInfo.isBreak = false;
const _notBreakState = enemyInfo.enemy.meta['haku-not-break-state'];
if (_notBreakState) {
this.addState(+_notBreakState);
}
config.frameIndex = 0;
config.isStartAnime = true;
}
}
};
// #endregion
/** 工具类 */
class HakuBreakBarUtils {
/**
*
* @param {number} enemyId 敌人Id
* @param {number} ap Ap值
*/
static setAp(enemyId, ap) {
const info = config.enemyInfos[enemyId];
if (!info) return;
// 破防状态下不允许外部脚本修改AP
if(info.isBreak) return;
info.ap = ap;
}
}
window.HakuBreakBarUtils = HakuBreakBarUtils;
})();

复制代码

[有事请教] 关于Hakubox_BreakBar韧性条的显示bug