From 4a633a063eb669260172e81054494c0f43ec5755 Mon Sep 17 00:00:00 2001 From: strawberry <2806566736@.qq.com> Date: Wed, 2 Jul 2025 17:42:22 +0800 Subject: [PATCH] =?UTF-8?q?=E7=89=B9=E6=AE=8A=E5=B1=9E=E6=80=A7=E5=85=A8?= =?UTF-8?q?=E9=83=A8=E5=AE=8C=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- _server/table/comment.js | 138 +++--- project/data.js | 1 - project/functions.js | 900 +++++++++++---------------------------- project/plugins.js | 27 +- 4 files changed, 345 insertions(+), 721 deletions(-) diff --git a/_server/table/comment.js b/_server/table/comment.js index 98f7d1a..38208ee 100644 --- a/_server/table/comment.js +++ b/_server/table/comment.js @@ -255,41 +255,107 @@ var comment_c456ea59_6018_45ef_8bcc_211a24c627dc = { "_docs": "特殊属性数值", "_data": "特殊属性的数值\n如：领域/阻激/激光怪的伤害值；光环怪增加生命的比例" }, - "zone": { + "baoshang": { "_leaf": true, "_type": "textarea", - "_docs": "领域伤害", - "_data": "领域怪的伤害值" + "_docs": "暴击伤害", + "_data": "暴击伤害的数值，此项为百分数。如20为20%" }, - "repulse": { + "baoji": { "_leaf": true, "_type": "textarea", - "_docs": "阻击伤害", - "_data": "阻击怪的伤害值" + "_docs": "暴击回合", + "_data": "怪物每进行多少回合进行一次暴击" }, - "laser": { + "duck": { "_leaf": true, "_type": "textarea", - "_docs": "激光伤害", - "_data": "激光怪的伤害值" + "_docs": "闪避回合", + "_data": "怪物每受到多少次普通攻击进行一次闪避" + }, + "absorb": { + "_leaf": true, + "_type": "textarea", + "_docs": "汲取效果", + "_data": "怪物对角色护盾造成破坏时，将窃取破坏数值的一定比例作为自身护盾，此项为百分数。如20为20%" + }, + "gravity": { + "_leaf": true, + "_type": "textarea", + "_docs": "重力效果", + "_data": "怪物操纵角色的重力，每携带一件双手装备速度下降4x%，每携带一件单手装备速度下降2x%，每携带一件其他装备速度下降x%，此项为百分数。如20为20%" + }, + "cold": { + "_leaf": true, + "_type": "textarea", + "_docs": "寒霜回合", + "_data": "怪物前多少次回合附加寒霜，0为每回合" + }, + "coldValue": { + "_leaf": true, + "_type": "textarea", + "_docs": "寒霜效果", + "_data": "每层寒霜下降的速度" + }, + "fire": { + "_leaf": true, + "_type": "textarea", + "_docs": "灼炎效果", + "_data": "每层灼炎熔毁的防御" + }, + "wind": { + "_leaf": true, + "_type": "textarea", + "_docs": "风行效果", + "_data": "每层风行提高的速度" + }, + "light": { + "_leaf": true, + "_type": "textarea", + "_docs": "闪电效果", + "_data": "闪电对护盾伤害提升效果百分比，此项为百分数。如20为20%" + }, + "poison": { + "_leaf": true, + "_type": "textarea", + "_docs": "毒素效果", + "_data": "每层毒素造成的生命流失" + }, + "tear": { + "_leaf": true, + "_type": "textarea", + "_docs": "撕裂效果", + "_data": "怪物的普通攻击附加角色当前已损失生命值的百分比，此项为百分数。如20为20%" + }, + "immolate": { + "_leaf": true, + "_type": "textarea", + "_docs": "献祭伤害", + "_data": "每次献祭造成的伤害" }, "breakArmor": { "_leaf": true, "_type": "textarea", "_docs": "破甲比例", - "_data": "破甲百分比" + "_data": "破甲百分比，此项为百分数。如20为20%" }, - "counterAttack": { + "onceBreakArmor": { "_leaf": true, "_type": "textarea", - "_docs": "反击比例", - "_data": "反击百分比" + "_docs": "首次额外破甲比例", + "_data": "额外破甲百分比，此项为百分数。如20为20%,首次伤害与破甲比例加算" }, "vampire": { "_leaf": true, "_type": "textarea", "_docs": "吸血比例", - "_data": "吸血怪的吸血百分比" + "_data": "吸血怪的吸血百分比,此项为百分数。如20为20%,仅计算破盾后伤害" + }, + "curseValue": { + "_leaf": true, + "_type": "textarea", + "_docs": "诅咒倍率", + "_data": "触发诅咒时魔法伤害提升比例，此项为百分数。如20为20%" }, "hpBuff": { "_leaf": true, @@ -297,6 +363,7 @@ var comment_c456ea59_6018_45ef_8bcc_211a24c627dc = { "_docs": "光环加血", "_data": "光环怪增加生命的比例" }, + "atkBuff": { "_leaf": true, "_type": "textarea", @@ -341,53 +408,14 @@ var comment_c456ea59_6018_45ef_8bcc_211a24c627dc = { "_docs": "不可炸", "_data": "该怪物不可被炸" }, - "n": { - "_leaf": true, - "_type": "textarea", - "_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null", - "_docs": "连击数", - "_data": "多连击的连击数，净化怪的净化倍率" - }, - "purify": { - "_leaf": true, - "_type": "textarea", - "_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null", - "_docs": "净化倍率", - "_data": "净化百分比" - }, - "add": { - "_leaf": true, - "_type": "checkbox", - "_docs": "吸血加到自身", - "_data": "吸血后是否加到自身" - }, + "haloAdd": { "_leaf": true, "_type": "checkbox", "_docs": "光环是否叠加", "_data": "光环是否叠加" }, - "atkValue": { - "_leaf": true, - "_type": "textarea", - "_range": "thiseval==~~thiseval||thiseval==null", - "_docs": "退化扣攻", - "_data": "退化时勇士下降的攻击力点数" - }, - "defValue": { - "_leaf": true, - "_type": "textarea", - "_range": "thiseval==~~thiseval||thiseval==null", - "_docs": "退化扣防", - "_data": "退化时勇士下降的防御力点数" - }, - "damage": { - "_leaf": true, - "_type": "textarea", - "_range": "thiseval==~~thiseval||thiseval==null", - "_docs": "固伤", - "_data": "战前扣血的点数" - }, + "beforeBattle": { "_leaf": true, "_type": "event", diff --git a/project/data.js b/project/data.js index 8e22984..b921d80 100644 --- a/project/data.js +++ b/project/data.js @@ -1557,7 +1557,6 @@ var data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = }, "flags": { "itemDetail": true, - "useBetweenLight": true, "__mdef_buff__": 0, "popmove": true }, diff --git a/project/functions.js b/project/functions.js index 0554389..ad50131 100644 --- a/project/functions.js +++ b/project/functions.js @@ -345,27 +345,15 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = core.status.hero.statistics.battleDamage += damage; core.status.hero.statistics.battle++; - // 计算当前怪物的支援怪物 - var guards = []; - if (x != null && y != null) { - guards = core.getFlag("__guards__" + x + "_" + y, []); - core.removeFlag("__guards__" + x + "_" + y); - } + // 获得金币 - var money = guards.reduce(function (curr, g) { - return curr + core.material.enemys[g[2]].money; - }, core.getEnemyValue(enemy, "money", x, y)); - if (core.hasItem('coin')) money *= 2; // 幸运金币：双倍 - if (core.hasFlag('curse')) money = 0; // 诅咒效果 + var money = core.getEnemyValue(enemy, "money", x, y) core.status.hero.money += money; core.status.hero.statistics.money += money; // 获得经验 - var exp = guards.reduce(function (curr, g) { - return curr + core.material.enemys[g[2]].exp; - }, core.getEnemyValue(enemy, "exp", x, y)); - if (core.hasFlag('curse')) exp = 0; + var exp = core.getEnemyValue(enemy, "exp", x, y); core.status.hero.exp += exp; core.status.hero.statistics.exp += exp; @@ -376,36 +364,6 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = hint += ',' + core.getStatusLabel('exp') + '+' + exp; // hint += "，经验+" + exp; core.drawTip(hint, enemy.id); - // 中毒 - if (core.enemys.hasSpecial(special, 12)) { - core.triggerDebuff('get', 'poison'); - } - // 衰弱 - if (core.enemys.hasSpecial(special, 13)) { - core.triggerDebuff('get', 'weak'); - } - // 诅咒 - if (core.enemys.hasSpecial(special, 14)) { - core.triggerDebuff('get', 'curse'); - } - // 仇恨怪物将仇恨值减半 - if (core.enemys.hasSpecial(special, 17)) { - core.setFlag('hatred', Math.floor(core.getFlag('hatred', 0) / 2)); - } - // 自爆 - if (core.enemys.hasSpecial(special, 19)) { - core.status.hero.statistics.battleDamage += core.status.hero.hp - 1; - core.status.hero.hp = 1; - } - // 退化 - if (core.enemys.hasSpecial(special, 21)) { - core.status.hero.atk -= core.getEnemyValue(enemy, "atkValue", x, y) || 0; - core.status.hero.def -= core.getEnemyValue(enemy, "defValue", x, y) || 0; - if (core.status.hero.atk < 0) core.status.hero.atk = 0; - if (core.status.hero.def < 0) core.status.hero.def = 0; - } - // 增加仇恨值 - core.setFlag('hatred', core.getFlag('hatred', 0) + core.values.hatred); // 战后的技能处理，比如扣除魔力值 if (core.flags.statusBarItems.indexOf('enableSkill') >= 0) { @@ -455,11 +413,9 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = // 因为removeBlock和hideBlock都会刷新状态栏，因此将删除部分移动到这里并保证刷新只执行一次，以提升效率 if (core.getBlock(x, y) != null) { // 检查是否是重生怪物；如果是则仅隐藏不删除 - if (core.hasSpecial(special, 23)) { - core.hideBlock(x, y); - } else { - core.removeBlock(x, y); - } + + core.removeBlock(x, y); + } else { core.updateStatusBar(); } @@ -547,215 +503,34 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = // 第五项为该特殊属性的标记；目前 1 代表是地图类技能（需要进行遍历全图） // 名字和描述可以直接写字符串，也可以写个function将怪物传进去 return [ - [1, "先攻", "怪物首先攻击", "#ffcc33"], //√ - //[2, "魔攻", "怪物无视角色的防御", "#bbb0ff"], - [3, "坚固", "怪物防御不小于角色攻击-1", "#c0b088"], //√ - [ - 6, - function (enemy) { - return (enemy.n || "") + "连击"; - }, - function (enemy) { - return "怪物每回合攻击" + (enemy.n || 4) + "次"; - }, - "#ffee77", - ], //想改成“以XX%、XX%攻击力各攻击一次” - [ - 7, - "破甲", - function (enemy) { - return ( - "怪物无视角色防御的" + - Math.floor( - 100 * (enemy.breakArmor || core.values.breakArmor || 0) - ) + - "%" - ); - }, - "#88c0ff", - ], //√ - [ - 8, - "反击", - function (enemy) { - return ( - "战斗时，怪物每回合附加角色攻击的" + - Math.floor( - 100 * (enemy.counterAttack || core.values.counterAttack || 0) - ) + - "%作为伤害，无视角色防御" - ); - }, - "#ffaa44", - ], - [ - 9, - "净化", - function (enemy) { - return ( - "战斗前，怪物附加角色护盾的" + - (enemy.purify || core.values.purify) + - "倍作为伤害" - ); - }, - "#80eed6", - ], - [10, "模仿", "怪物的攻防和角色攻防相等", "#b0c0dd"], - [ - 11, - "吸血", - function (enemy) { - return ( - "战斗前，怪物首先吸取角色的" + - Math.floor(100 * enemy.vampire || 0) + - "%生命（约" + - Math.floor((enemy.vampire || 0) * core.getStatus("hp")) + - "点）作为伤害" + - (enemy.add ? "，并把伤害数值加到自身生命上" : "") - ); + [1, "先攻", "怪物起始行动条为50%", "#ffcc33"], //√ + [2, "暴击", function (enemy) { return `怪物的首次攻击必定暴击，暴击额外造成${enemy.baoshang}%的伤害；除此以外，怪物每${enemy.baoji}次攻击就将打出一次暴击。` }, "#ffcc33"], + [3, "坚固", "每次至多受到1点物理伤害", "#c0b088"], //√ + [4, "反击", "怪物的首次攻击附加怪物当前已损失生命值的100%作为伤害", "#c0b088"], + [5, "破甲", function (enemy) { return `怪物攻击时无视角色${enemy.breakArmor}%的防御力；首次攻击时，怪物额外无视角色${enemy.onceBreakArmor}%的防御力（加算）` }, "#88c0ff", ], //√ + [6, "吸血", function (enemy) { + return `怪物造成的物理伤害以${enemy.vampire}%回复怪物自身的生命值，不计对护盾造成的破坏`; }, "#dd4448", ], - [ - 12, - "中毒", - "战斗后，角色陷入中毒状态，每一步损失生命" + - core.values.poisonDamage + - "点", - "#99ee88", - ], - [ - 13, - "衰弱", - "战斗后，角色陷入衰弱状态，攻防暂时下降" + - (core.values.weakValue >= 1 ? - core.values.weakValue + "点" : - parseInt(core.values.weakValue * 100) + "%"), - "#f0bbcc", - ], - [ - 14, - "诅咒", - "战斗后，角色陷入诅咒状态，战斗无法获得金币和经验", - "#bbeef0", - ], - [ - 15, - "领域", - function (enemy) { - return ( - "经过怪物周围" + - (enemy.zoneSquare ? "九宫格" : "十字") + - "范围内" + - (enemy.range || 1) + - "格时自动减生命" + - (enemy.zone || 0) + - "点" - ); - }, - "#c677dd", - ], - [16, "夹击", "经过两只相同的怪物中间，角色生命值变成一半", "#bb99ee"], - [ - 17, - "仇恨", - "战斗前，怪物附加之前积累的仇恨值作为伤害；战斗后，释放一半的仇恨值。（每杀死一个怪物获得" + - (core.values.hatred || 0) + - "点仇恨值）", - "#b0b666", - ], - [ - 18, - "阻击", - function (enemy) { - return ( - "经过怪物周围" + - (enemy.zoneSquare ? "九宫格" : "十字") + - "时自动减生命" + - (enemy.repulse || 0) + - "点，同时怪物后退一格" - ); - }, - "#8888e6", - ], - [19, "自爆", "战斗后角色的生命值变成1", "#ff6666"], + [7, "诅咒", function (enemy) { return `当怪物的攻击同时造成了物理伤害和魔法伤害（护盾优先抵挡物理伤害），则魔法伤害提升${enemy.curseValue}%` }, "#bbeef0", ], + [8, "闪避", function (enemy) { return `怪物受到的首次普通攻击将被闪避而无效化；除此以外，怪物每受到${enemy.duck}次普通攻击造成的伤害就将闪避一次。` }, "#99ee88", ], + [9, "寒霜", function (enemy) { return `怪物的${enemy.cold===0?"每次":"前"+enemy.cold+"次"}普通攻击命中角色时，将使角色在该场战斗中的速度下降${enemy.coldValue}点(速度最低为1)` }, "#99ee88", ], + [10, "灼炎", function (enemy) { return `怪物的普通攻击命中角色时，将在该场战斗中熔毁角色的防御${enemy.fire}点` }, "#99ee88", ], + [11, "风行", function (enemy) { return `怪物的基础速度将不低于角色的基础速度；怪物每次攻击命中或闪避攻击时，其速度提高${enemy.wind}点` }, "#99ee88", ], + [12, "撕裂", function (enemy) { return `怪物的普通攻击附加角色当前已损失生命值的${enemy.tear}%作为伤害，不计对护盾造成的破坏` }, "#99ee88", ], + [13, "献祭", function (enemy) { return `怪物身周萦绕着火焰，火焰每次对角色造成${enemy.immolate}点魔法伤害，伤害速度等于怪物的初始生命` }, "#99ee88", ], + [14, "闪电", function (enemy) { return `怪物对角色护盾的破坏效率提升${enemy.light}%。(击破护盾的那次攻击，剩余的伤害也计算闪电加成）` }, "#99ee88", ], + + [15, "警戒", function (enemy) { return ("经过怪物周围" + (enemy.zoneSquare ? "九宫格" : "十字") + "范围内" + (enemy.range || 1) + "格时受到一次仅有20%护盾生效的攻击，扣除护盾后伤害为" + (Math.max(Math.max(enemy.atk - core.getRealStatusOrDefault(void 0, "def"), 0) + Math.floor(enemy.spell * (100 - core.getRealStatusOrDefault(void 0, "mdef")) / 100) - Math.floor(core.getRealStatusOrDefault(void 0, "spell") * core.getRealStatusOrDefault(void 0, "mhp") / 100 * 0.2), 0) || 0) + "点"); }, "#c677dd", ], + [16, "毒素", function (enemy) { return `怪物的普通攻击造成物理伤害时（不计对护盾造成的破坏）将附加一层毒素效果，每层毒素效果将使角色在该场战斗中攻击时流失${enemy.poison}点生命值` }, "#99ee88", ], + + [17, "汲取", function (enemy) { return `怪物对角色护盾造成破坏时，将窃取破坏数值的${enemy.absorb}%作为自身护盾` }, "#bbeef0", ], + [18, "重力", function (enemy) { return `怪物操纵角色的重力，每携带一件双手装备速度下降${4*enemy.gravity}%，每携带一件单手装备速度下降${2*enemy.gravity}%，每携带一件其他装备速度下降${enemy.gravity}%` }, "#bbeef0", ], [20, "无敌", "角色无法打败怪物，除非拥有十字架", "#aaaaaa"], - [ - 21, - "退化", - function (enemy) { - return ( - "战斗后角色永久下降" + - (enemy.atkValue || 0) + - "点攻击和" + - (enemy.defValue || 0) + - "点防御" - ); - }, - ], - [ - 22, - "固伤", - function (enemy) { - return ( - "战斗前，怪物对角色造成" + - (enemy.damage || 0) + - "点固定伤害，未开启负伤时无视角色护盾。" - ); - }, - "#ff9977", - ], - [23, "重生", "怪物被击败后，角色转换楼层则怪物将再次出现", "#a0e0ff"], - [ - 24, - "激光", - function (enemy) { - return "经过怪物同行或同列时自动减生命" + (enemy.laser || 0) + "点"; - }, - "#dda0dd", - ], - [ - 25, - "光环", - function (enemy) { - return ( - (enemy.range != null ? - (enemy.haloSquare ? "该怪物九宫格" : "该怪物十字") + - enemy.haloRange + - "格范围内" : - "同楼层所有") + - "怪物生命提升" + - (enemy.hpBuff || 0) + - "%，攻击提升" + - (enemy.atkBuff || 0) + - "%，防御提升" + - (enemy.defBuff || 0) + - "%，" + - (enemy.haloAdd ? "可叠加" : "不可叠加") - ); - }, - "#e6e099", - 1, - ], - [ - 26, - "支援", - "当周围一圈的怪物受到攻击时将上前支援，并组成小队战斗。", - "#77c0b6", - 1, - ], - [ - 27, - "捕捉", - function (enemy) { - return ( - "当走到怪物周围" + - (enemy.zoneSquare ? "九宫格" : "十字") + - "时会强制进行战斗。" - ); - }, - "#c0ddbb", - ], + + [25, "光环", function (enemy) { return ((enemy.range != null ? (enemy.haloSquare ? "该怪物九宫格" : "该怪物十字") + enemy.haloRange + "格范围内" : "同楼层所有") + "怪物生命提升" + (enemy.hpBuff || 0) + "%，攻击提升" + (enemy.atkBuff || 0) + "%，防御提升" + (enemy.defBuff || 0) + "%，" + (enemy.haloAdd ? "可叠加" : "不可叠加")); }, "#e6e099", 1, ], + [27, "捕捉", function (enemy) { return ("当走到怪物周围" + (enemy.zoneSquare ? "九宫格" : "十字") + "时会强制进行战斗。"); }, "#c0ddbb", ], ]; }, "getEnemyInfo": function (enemy, hero, x, y, floorId) { @@ -788,18 +563,8 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = mon_point = core.getEnemyValue(enemy, "point", x, y, floorId); var mon_barrier = 0, mon_absorb_damage = 0; - // 模仿 - if (core.hasSpecial(mon_special, 10)) { - mon_atk = hero_atk; - mon_def = hero_def; - } - // 坚固 - if (core.hasSpecial(mon_special, 3) && mon_def < hero_atk - 1) { - mon_def = hero_atk - 1; - } - - var guards = []; - // 光环和支援检查 + if (core.hasSpecial(mon_special, 11)) mon_speed = Math.max(mon_speed, hero_speed + 1) + // 光环检查 if (!core.status.checkBlock) core.status.checkBlock = {}; if (core.status.checkBlock.needCache) { @@ -845,21 +610,6 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = usedEnemyIds[enemy.id] = true; } } - // 检查【支援】技能，数字26 - if ( - enemy && - core.hasSpecial(enemy.special, 26) && - // 检查支援条件，坐标存在，距离为1，且不能是自己 - // 其他类型的支援怪，比如十字之类的话.... 看着做是一样的 - x != null && - y != null && - Math.abs(block.x - x) <= 1 && - Math.abs(block.y - y) <= 1 && - !(x == block.x && y == block.y) - ) { - // 记录怪物的x,y，ID - guards.push([block.x, block.y, id]); - } // TODO：如果有其他类型光环怪物在这里仿照添加检查 // 注：新增新的类光环属性（需要遍历全图的）需要在特殊属性定义那里的第五项写1，参见光环和支援的特殊属性定义。 @@ -870,14 +620,14 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = hp_buff: hp_buff, atk_buff: atk_buff, def_buff: def_buff, - guards: guards, + }; } else { // 直接使用缓存数据 hp_buff = cache.hp_buff; atk_buff = cache.atk_buff; def_buff = cache.def_buff; - guards = cache.guards; + } // 增加比例；如果要增加数值可以直接在这里修改 @@ -907,8 +657,7 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = money: Math.floor(mon_money), exp: Math.floor(mon_exp), point: Math.floor(mon_point), - special: mon_special, - guards: guards // 返回支援情况 + special: mon_special }; }, @@ -947,7 +696,7 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = hero_spell = hero?.spell ?? core.status.hero.spell; } // 怪物的各项数据 - // 对坚固模仿等处理扔到了脚本编辑-getEnemyInfo之中 + var enemyInfo = core.enemys.getEnemyInfo(enemy, hero, x, y, floorId); var mon_hp = enemyInfo.hp, mon_atk = enemyInfo.atk, @@ -955,29 +704,31 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = mon_mdef = enemyInfo.mdef, mon_spell = enemyInfo.spell, mon_speed = enemyInfo.speed, - mon_special = enemyInfo.special, - mon_absorb_damage = enemyInfo.absorb, - mon_barrier = enemyInfo.barrier; + mon_special = enemyInfo.special const { lcm, gcd } = core.plugin.utils const equip0 = core.getEquip(0) //---第一部分：静态属性修正--- //此处写入静态影响勇士属性的勇士或怪物技能（静态影响怪物属性的技能于getEnemyInfo中写入） // 技能的处理 - if (core.getFlag("skill", 0) == 1) { - // 开启了技能1：二倍斩 - hero_atk *= 2; // 计算时攻击力翻倍 + + var enemyvalue = core.material.enemys[enemy.id] + + if (core.hasSpecial(mon_special, 18)) { + let a = 0 + for (let i = 0; i <= 4; i++) { + const equip = core.getEquip(i) + if (!equip) continue + const cls = core.material.items[equip].equipCls + if (cls === "双手剑") a += enemyvalue.gravity * 4 + else if (['法杖', '单手剑', '匕首', '盾牌'].includes(cls)) a += enemyvalue.gravity * 2 + else a += enemyvalue.gravity + } + hero_speed = hero_speed * (100 - a) / 100 } - - // 破甲 - if (core.hasSpecial(mon_special, 7)) - hero_def -= Math.floor( - (enemy.breakArmor || core.values.breakArmor) * hero_def - ); - //勇士属性取整 hero_atk = Math.max(0, Math.floor(hero_atk)); hero_def = Math.max(0, Math.floor(hero_def)); - hero_speed = Math.max(0, Math.floor(hero_speed)); + hero_speed = Math.max(1, Math.floor(hero_speed)); hero_spell = Math.max(0, Math.floor(hero_spell)); hero_matk = Math.min(100, Math.max(0, Math.floor(hero_matk))); hero_mdef = Math.min(100, Math.max(0, Math.floor(hero_mdef))); @@ -987,26 +738,6 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = if (core.hasSpecial(mon_special, 20) && !core.hasItem("cross")) return null; // 不可战斗 - // 战前造成的额外伤害（可被护盾抵消） - let init_damage = 0; - - // 吸血 - if (core.hasSpecial(mon_special, 11)) { - let vampire_damage = hero_hp * enemy.vampire; - - // 如果有神圣盾免疫吸血等可以在这里写 - // 也可以用hasItem和hasEquip来判定装备 - // if (core.hasFlag('shield5')) vampire_damage = 0; - - vampire_damage = Math.floor(vampire_damage) || 0; - // 加到自身 - if (enemy.add) - // 如果加到自身 - mon_hp += vampire_damage; - - init_damage += vampire_damage; - } - //——第二部分：变量定义和初始赋值—— let hero_per_damage = Math.max(hero_atk - mon_def, 0), @@ -1017,7 +748,10 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = hero_turn = 0, mon_turn = 0; let equipInfo = [] //回合生效的装备列表 - + if (core.hasSpecial(mon_special, 13)) equipInfo.push({ + id: "献祭", //需注册图标 + speed: mon_hp + }) for (let i = 0; i < 5; i++) { const a = core.plugin.equip[core.getEquip(i)] if (a) equipInfo.push(a) @@ -1046,8 +780,8 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = }) const heroinfo = { hp: hero_hp, atk: hero_atk, def: hero_def, mdef: (!hero?.mdef || hero?.mdef === 100) ? hero_mdef : hero.mdef, spell: hero_spell, mhp: Math.floor(hero_spell * hero_mhp / 100), matk: Math.floor(hero_spell * hero_matk / 100), speed: hero_speed, now: 0, isAttack: false } //勇士属性 - const enemyinfo = { hp: mon_hp, atk: mon_atk, def: mon_def, mdef: mon_mdef, spell: mon_spell, speed: mon_speed, special: mon_special, now: 0, isAttack: false } //怪物属性 - //先攻，先攻为怪物和勇士勇士行动前怪物出第一刀 + const enemyinfo = { hp: mon_hp, atk: mon_atk, def: mon_def, mhp: 0, mdef: mon_mdef, spell: mon_spell, speed: mon_speed, special: mon_special, now: 0, isAttack: false } //怪物属性 + //先攻，先攻为怪物50%行动条 if (core.hasSpecial(mon_special, 1)) { enemyinfo.now = oneTurn / 2 heroinfo.now = 0 @@ -1068,7 +802,7 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = oneTurn *= i const start = [core.clone(heroinfo), core.clone(enemyinfo), core.clone(equipInfo), oneTurn] //记录开始战斗时的属性并转发 //---第三部分：递归开始--- - + let poison = 0 const heroDiffList = [], enemyDiffList = [], heroanimateList = [], @@ -1101,14 +835,32 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = //伤害计算 let per_damage = Math.max(heroinfo.atk - enemyinfo.def, 0) let per_mdamage = Math.max(Math.floor(heroinfo.matk * (100 - enemyinfo.mdef) / 100), 0) + //坚固 + if (core.hasSpecial(mon_special, 3)) per_damage = Math.min(per_damage, 1) + mon_damage = per_damage + per_mdamage + + if (enemyinfo.mhp > 0) { + if (mon_damage > enemyinfo.mhp + (enemy_diff.mhp ?? 0)) { + + mon_damage -= enemyinfo.mhp + (enemy_diff.mhp ?? 0) + enemy_diff.mhp = -enemyinfo.mhp + } else { + enemy_diff.mhp = (enemy_diff.mhp ?? 0) - mon_damage + mon_damage = 0 + } + } //这里记录伤害触发后的属性变化和动画，同时计入diff(不要在此直接修改heroinfo和enemyinfo) let animate = core.plugin.heroanimate[equip0] ?? "jianji2" //这里可通过if更改默认的武器攻击特效 enemy_animate.push(animate) - - enemy_diff.hp = (enemy_diff.hp ?? 0) - mon_damage + damage += poison + hero_diff.hp = (hero_diff.hp ?? 0) - poison + //闪避 + enemy_diff.hp = (enemy_diff.hp ?? 0) - (core.hasSpecial(mon_special, 8) && hero_turn % enemyvalue.duck === 0 ? 0 : mon_damage) + //风行 + if (core.hasSpecial(mon_special, 11) && core.hasSpecial(mon_special, 8) && hero_turn % enemyvalue.duck === 0) enemy_diff.speed = (enemy_diff.def ?? 0) + enemyvalue.wind heroinfo.now -= oneTurn hero_turn++ onattack = true @@ -1122,25 +874,69 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = //伤害计算 let per_damage = Math.max(enemyinfo.atk - heroinfo.def, 0), per_mdamage = Math.floor(enemyinfo.spell * (100 - heroinfo.mdef) / 100); - + //破甲 + if (core.hasSpecial(mon_special, 5)) per_damage = Math.max(enemyinfo.atk - (mon_turn === 0 ? Math.floor(heroinfo.def * (enemyvalue.breakArmor + enemyvalue.onceBreakArmor) / 100) : Math.floor(heroinfo.def * enemyvalue.breakArmor / 100)), 0) //这里记录伤害触发后的属性变化和动画，同时计入diff、damage(不要在此直接修改heroinfo和enemyinfo) - if (core.hasSpecial(mon_special, 6)) { - hero_damage += per_damage * enemy.n + per_mdamage * enemy.n - } else { - hero_damage += per_damage + per_mdamage + //反击 + if (core.hasSpecial(mon_special, 4) && mon_turn === 0) per_damage += Math.max(mon_hp - enemyinfo.hp, 0) + //暴击 + if (core.hasSpecial(mon_special, 2) && mon_turn % enemyvalue.baoji === 0) { + per_damage = Math.floor(per_damage * enemyvalue.baoshang / 100) + per_mdamage = Math.floor(per_mdamage * enemyvalue.baoshang / 100) } + + let animate = core.plugin.enemyanimate[enemy.id] ?? "jianji2" //这里可通过if更改默认的怪物攻击特效 hero_animate.push(animate) //勇士身上绘制sword动画 - if (heroinfo.mhp + (hero_diff.mhp ?? 0) - hero_damage >= 0) { - hero_diff.mhp = (hero_diff.mhp ?? 0) - hero_damage + //闪电 + if (core.hasSpecial(mon_special, 14) && heroinfo.mhp + (hero_diff.mhp ?? 0) > 0) { + per_damage = Math.floor(per_damage * enemyvalue.light / 100) + per_mdamage = Math.floor(per_mdamage * enemyvalue.light / 100) + } + if (heroinfo.mhp + (hero_diff.mhp ?? 0) - per_damage - per_mdamage >= 0) { //完美护盾 + //汲取 + if (core.hasSpecial(mon_special, 17)) enemy_diff.mhp = (enemy_diff.mhp ?? 0) + Math.floor((per_damage + per_mdamage) * enemyvalue.absorb / 100) + hero_diff.mhp = (hero_diff.mhp ?? 0) - per_damage - per_mdamage hero_damage = 0 - hero_diff.hp = (hero_diff.hp ?? 0) - hero_damage - } else { - hero_damage -= heroinfo.mhp + (hero_diff.mhp ?? 0) - hero_diff.mhp = (hero_diff.mhp ?? 0) - heroinfo.mhp - (hero_diff.mhp ?? 0) + } else if (heroinfo.mhp + (hero_diff.mhp ?? 0) - per_damage >= 0) { //护盾击破但只受到魔法伤害 + //汲取 + if (core.hasSpecial(mon_special, 17)) enemy_diff.mhp = (enemy_diff.mhp ?? 0) + Math.floor((heroinfo.mhp + (hero_diff.mhp ?? 0)) * enemyvalue.absorb / 100) + //诅咒 + hero_damage = per_damage + (core.hasSpecial(mon_special, 7) && heroinfo.mhp > 0 ? 2 * per_mdamage : per_mdamage) - heroinfo.mhp + hero_diff.mhp = -heroinfo.mhp + //撕裂 + if (core.hasSpecial(mon_special, 12)) hero_damage = MNath.floor(Math.max(mon_hp - enemyinfo.hp, 0) * enemyvalue.tear / 100) hero_diff.hp = (hero_diff.hp ?? 0) - hero_damage + //灼炎 + if (core.hasSpecial(mon_special, 10)) hero_diff.def = (hero_diff.def ?? 0) - enemyvalue.fire + //风行 + if (core.hasSpecial(mon_special, 11)) enemy_diff.speed = (enemy_diff.def ?? 0) + enemyvalue.wind + + } else { //护盾击破 + if (core.hasSpecial(mon_special, 16)) poison++ + //汲取 + if (core.hasSpecial(mon_special, 17)) enemy_diff.mhp = (enemy_diff.mhp ?? 0) + Math.floor((heroinfo.mhp + (hero_diff.mhp ?? 0)) * enemyvalue.absorb / 100) + const over = per_damage - (hero_diff.mhp ?? 0) + //吸血 + if (core.hasSpecial(mon_special, 6)) hero_diff.hp = (hero_diff.hp ?? 0) + Math.floor(over * enemyvalue.vampire / 100) + //诅咒 + hero_damage = per_damage + (core.hasSpecial(mon_special, 7) && heroinfo.mhp > 0 ? 2 * per_mdamage : per_mdamage) - heroinfo.mhp + + hero_diff.mhp = -heroinfo.mhp + //撕裂 + if (core.hasSpecial(mon_special, 12)) hero_damage = MNath.floor(Math.max(mon_hp - enemyinfo.hp, 0) * enemyvalue.tear / 100) + hero_diff.hp = (hero_diff.hp ?? 0) - hero_damage + //灼炎 + if (core.hasSpecial(mon_special, 10)) hero_diff.def = (hero_diff.def ?? 0) - enemyvalue.fire + //风行 + if (core.hasSpecial(mon_special, 11)) enemy_diff.speed = (enemy_diff.def ?? 0) + enemyvalue.wind + } + //寒霜 + if (core.hasSpecial(mon_special, 9) && enemyvalue.cold === 0 || enemyvalue.cold > mon_turn) { + hero_diff.speed = Math.max(1 - heroinfo.speed, (hero_diff.speed ?? 0) - enemyvalue.coldValue) + } damage += hero_damage @@ -1152,11 +948,21 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = if (v.now >= oneTurn) { let mon_damage = 0 let hero_damage = 0 + + if (v.id === '献祭') { + if (heroinfo.mhp + (hero_diff.mhp ?? 0) - enemyvalue.immolate >= 0) { + hero_diff.mhp = (hero_diff.mhp ?? 0) - enemyvalue.immolate + } else { + hero_damage += enemyvalue.immolate - (hero_diff.mhp ?? 0) + hero_diff.mhp = -heroinfo.mhp + hero_diff.hp = (hero_diff.hp ?? 0) - hero_damage + } + } //这里写生效装备的技能效果，同时对双方属性的修改计入diff(不要在此直接修改heroinfo和enemyinfo) let animate = core.plugin.equipanimate[v.id] ?? "jianji2" //这里可通过if更改默认的道具特效 enemy_animate.push(animate) //怪物身上绘制动画 - + damage += hero_damage v.now -= oneTurn onattack = true } @@ -1187,77 +993,7 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = } - //下面这些还没修改，原有技能除先攻、连击外暂时全部移除，所有技能需要在上方的模拟循环中做修正 - /* - // 每回合的反击伤害；反击是按照勇士的攻击次数来计算回合 - let counterDamage = 0; - if (core.hasSpecial(mon_special, 8)) - counterDamage += Math.floor( - (enemy.counterAttack || core.values.counterAttack) * hero_atk - ); - - - // 净化 - if (core.hasSpecial(mon_special, 9)) - init_damage += Math.floor( - (enemy.purify || core.values.purify) * hero_mdef - ); - //上面这些还没修改 - //勇士护盾计算 - let barrier = Math.floor(hero_spell * hero_mhp / 100); - - - // ------ 支援 ----- // - // 这个递归最好想明白为什么，flag:__extraTurn__是怎么用的 - /*var guards = core.getFlag("__guards__" + x + "_" + y, enemyInfo.guards); - var guard_before_current_enemy = false; // ------ 支援怪是先打(true)还是后打(false)？ - turn += core.getFlag("__extraTurn__", 0); - if (guards.length > 0) { - if (!guard_before_current_enemy) { // --- 先打当前怪物，记录当前回合数 - core.setFlag("__extraTurn__", turn); - } - // 获得那些怪物组成小队战斗 - for (var i = 0; i < guards.length; i++) { - var gx = guards[i][0], - gy = guards[i][1], - gid = guards[i][2]; - // 递归计算支援怪伤害信息，这里不传x,y保证不会重复调用 - // 这里的mdef传0，因为护盾应该只会被计算一次 - var info = core.enemys.getDamageInfo(core.material.enemys[gid], { hp: origin_hero_hp, atk: origin_hero_atk, def: origin_hero_def, mdef: 0 }); - if (info == null) { // 小队中任何一个怪物不可战斗，直接返回null - core.removeFlag("__extraTurn__"); - return null; - } - // 已经进行的回合数 - core.setFlag("__extraTurn__", info.turn); - init_damage += info.damage; - } - if (guard_before_current_enemy) { // --- 先打支援怪物，增加当前回合数 - turn += core.getFlag("__extraTurn__", 0); - } - } - core.removeFlag("__extraTurn__");*/ - // ------ 支援END ------ // - /* - // 最终伤害：初始伤害 + 怪物对勇士造成的伤害 + 反击伤害 - damage += init_damage + hero_turn * counterDamage; - // 再扣去护盾 - damage -= barrier; - - // 检查是否允许负伤 - if (!core.flags.enableNegativeDamage) damage = Math.max(0, damage); - - // 最后处理仇恨和固伤（因为这两个不能被护盾减伤） - if (core.hasSpecial(mon_special, 17)) { - // 仇恨 - damage += core.getFlag("hatred", 0); - } - if (core.hasSpecial(mon_special, 22)) { - // 固伤 - damage += enemy.damage2 || 0; - } - */ return { start: start, mon_hp: Math.floor(mon_hp), @@ -1722,257 +1458,117 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = }, "updateCheckBlock": function (floorId) { - // 领域、夹击、阻击等的伤害值计算 - floorId = floorId || core.status.floorId; - if (!floorId || !core.status.maps) return; + // 领域、夹击、阻击等的伤害值计算 + floorId = floorId || core.status.floorId; + if (!floorId || !core.status.maps) return; - var width = core.floors[floorId].width, - height = core.floors[floorId].height; - var blocks = core.getMapBlocksObj(floorId); + var width = core.floors[floorId].width, + height = core.floors[floorId].height; + var blocks = core.getMapBlocksObj(floorId); - var damage = {}, // 每个点的伤害值 - type = {}, // 每个点的伤害类型 - repulse = {}, // 每个点的阻击怪信息 - ambush = {}; // 每个点的捕捉信息 - var betweenAttackLocs = {}; // 所有可能的夹击点 - var needCache = false; - var canGoDeadZone = core.flags.canGoDeadZone; - core.flags.canGoDeadZone = true; + var damage = {}, // 每个点的伤害值 + type = {}, // 每个点的伤害类型 + repulse = {}, // 每个点的阻击怪信息 + ambush = {}; // 每个点的捕捉信息 + var betweenAttackLocs = {}; // 所有可能的夹击点 + var needCache = false; + var canGoDeadZone = core.flags.canGoDeadZone; + core.flags.canGoDeadZone = true; - // 计算血网和领域、阻击、激光的伤害，计算捕捉信息 - for (var loc in blocks) { - var block = blocks[loc], - x = block.x, - y = block.y, - id = block.event.id, - enemy = core.material.enemys[id]; - if (block.disable) continue; + // 计算血网和领域、阻击、激光的伤害，计算捕捉信息 + for (var loc in blocks) { + var block = blocks[loc], + x = block.x, + y = block.y, + id = block.event.id, + enemy = core.material.enemys[id]; + if (block.disable) continue; - type[loc] = type[loc] || {}; + type[loc] = type[loc] || {}; - // 血网 - // 如需调用当前楼层的ratio可使用 core.status.maps[floorId].ratio - if (id == "lavaNet" && !core.hasItem("amulet")) { - damage[loc] = (damage[loc] || 0) + core.values.lavaDamage; - type[loc][(block.event.name || "血网") + "伤害"] = true; - } + // 血网 + // 如需调用当前楼层的ratio可使用 core.status.maps[floorId].ratio + if (id == "lavaNet" && !core.hasItem("amulet")) { + damage[loc] = (damage[loc] || 0) + core.values.lavaDamage; + type[loc][(block.event.name || "血网") + "伤害"] = true; + } - // 领域 - // 如果要防止领域伤害，可以直接简单的将 flag:no_zone 设为true - if ( - enemy && - core.hasSpecial(enemy.special, 15) && - !core.hasFlag("no_zone") - ) { - // 领域范围，默认为1 - var range = enemy.range || 1; - // 是否是九宫格领域 - var zoneSquare = false; - if (enemy.zoneSquare != null) zoneSquare = enemy.zoneSquare; - // 在范围内进行搜索，增加领域伤害值 - for (var dx = -range; dx <= range; dx++) { - for (var dy = -range; dy <= range; dy++) { - if (dx == 0 && dy == 0) continue; - var nx = x + dx, - ny = y + dy, - currloc = nx + "," + ny; - if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue; - // 如果是十字领域，则还需要满足 |dx|+|dy|<=range - if (!zoneSquare && Math.abs(dx) + Math.abs(dy) > range) continue; - damage[currloc] = (damage[currloc] || 0) + (enemy.zone || 0); - type[currloc] = type[currloc] || {}; - type[currloc]["领域伤害"] = true; - } - } - } + // 警戒 + // 如果要防止警戒伤害，可以直接简单的将 flag:no_zone 设为true + if ( + enemy && + core.hasSpecial(enemy.special, 15) && + !core.hasFlag("no_zone") + ) { + // 警戒范围，默认为1 + var range = enemy.range || 1; + // 是否是九宫格警戒 + var zoneSquare = false; + if (enemy.zoneSquare != null) zoneSquare = enemy.zoneSquare; + // 在范围内进行搜索，增加警戒伤害值 + for (var dx = -range; dx <= range; dx++) { + for (var dy = -range; dy <= range; dy++) { + if (dx == 0 && dy == 0) continue; + var nx = x + dx, + ny = y + dy, + currloc = nx + "," + ny; + if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue; + // 如果是十字警戒，则还需要满足 |dx|+|dy|<=range + if (!zoneSquare && Math.abs(dx) + Math.abs(dy) > range) continue; + damage[currloc] = (damage[currloc] || 0) + (Math.max(Math.max(enemy.atk - core.getRealStatusOrDefault(void 0, "def"), 0) + Math.floor(enemy.spell * (100 - core.getRealStatusOrDefault(void 0, "mdef")) / 100) - Math.floor(core.getRealStatusOrDefault(void 0, "spell") * core.getRealStatusOrDefault(void 0, "mhp") / 100 * 0.2), 0) || 0); + type[currloc] = type[currloc] || {}; + type[currloc]["警戒伤害"] = true; + } + } + } - // 阻击 - // 如果要防止阻击伤害，可以直接简单的将 flag:no_repulse 设为true - if ( - enemy && - core.hasSpecial(enemy.special, 18) && - !core.hasFlag("no_repulse") - ) { - var scan = enemy.zoneSquare ? core.utils.scan2 : core.utils.scan; - for (var dir in scan) { - var nx = x + scan[dir].x, - ny = y + scan[dir].y, - currloc = nx + "," + ny; - if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue; - damage[currloc] = (damage[currloc] || 0) + (enemy.repulse || 0); - type[currloc] = type[currloc] || {}; - type[currloc]["阻击伤害"] = true; - var rdir = core.turnDirection(":back", dir); - // 检查下一个点是否存在事件（从而判定是否移动） - var rnx = x + scan[rdir].x, - rny = y + scan[rdir].y; - if (rnx < 0 || rnx >= width || rny < 0 || rny >= height) continue; - // 如需禁止阻击被推到已隐藏的事件处（如重生怪处），可将这一句的false改为true - if (core.getBlock(rnx, rny, floorId, false) != null) continue; - if (core.utils.scan[rdir] && !core.canMoveHero(x, y, rdir, floorId)) - continue; - repulse[currloc] = (repulse[currloc] || []).concat([ - [x, y, id, rdir], - ]); - } - } - // 激光 - // 如果要防止激光伤害，可以直接简单的将 flag:no_laser 设为true - if ( - enemy && - core.hasSpecial(enemy.special, 24) && - !core.hasFlag("no_laser") - ) { - for (var nx = 0; nx < width; nx++) { - var currloc = nx + "," + y; - if (nx != x) { - damage[currloc] = (damage[currloc] || 0) + (enemy.laser || 0); - type[currloc] = type[currloc] || {}; - type[currloc]["激光伤害"] = true; - } - } - for (var ny = 0; ny < height; ny++) { - var currloc = x + "," + ny; - if (ny != y) { - damage[currloc] = (damage[currloc] || 0) + (enemy.laser || 0); - type[currloc] = type[currloc] || {}; - type[currloc]["激光伤害"] = true; - } - } - } + // 捕捉 + // 如果要防止捕捉效果，可以直接简单的将 flag:no_ambush 设为true + if ( + enemy && + core.enemys.hasSpecial(enemy.special, 27) && + !core.hasFlag("no_ambush") + ) { + var scan = enemy.zoneSquare ? core.utils.scan2 : core.utils.scan; + // 给周围格子加上【捕捉】记号 + for (var dir in scan) { + var nx = x + scan[dir].x, + ny = y + scan[dir].y, + currloc = nx + "," + ny; + if ( + nx < 0 || + nx >= width || + ny < 0 || + ny >= height || + (core.utils.scan[dir] && !core.canMoveHero(x, y, dir, floorId)) + ) + continue; + ambush[currloc] = (ambush[currloc] || []).concat([ + [x, y, id, dir] + ]); + } + } + } - // 捕捉 - // 如果要防止捕捉效果，可以直接简单的将 flag:no_ambush 设为true - if ( - enemy && - core.enemys.hasSpecial(enemy.special, 27) && - !core.hasFlag("no_ambush") - ) { - var scan = enemy.zoneSquare ? core.utils.scan2 : core.utils.scan; - // 给周围格子加上【捕捉】记号 - for (var dir in scan) { - var nx = x + scan[dir].x, - ny = y + scan[dir].y, - currloc = nx + "," + ny; - if ( - nx < 0 || - nx >= width || - ny < 0 || - ny >= height || - (core.utils.scan[dir] && !core.canMoveHero(x, y, dir, floorId)) - ) - continue; - ambush[currloc] = (ambush[currloc] || []).concat([[x, y, id, dir]]); - } - } - - // 夹击；在这里提前计算所有可能的夹击点，具体计算逻辑在下面 - // 如果要防止夹击伤害，可以简单的将 flag:no_betweenAttack 设为true - if ( - enemy && - core.enemys.hasSpecial(enemy.special, 16) && - !core.hasFlag("no_betweenAttack") - ) { - for (var dir in core.utils.scan) { - var nx = x + core.utils.scan[dir].x, - ny = y + core.utils.scan[dir].y, - currloc = nx + "," + ny; - if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue; - betweenAttackLocs[currloc] = true; - } - } - - // 检查地图范围类技能 - var specialFlag = core.getSpecialFlag(enemy); - if (specialFlag & 1) needCache = true; - if (core.status.event.id == "viewMaps") needCache = true; - if ( - (core.status.event.id == "book" || - core.status.event.id == "bool-detail") && - core.status.event.ui - ) - needCache = true; - } - - // 对每个可能的夹击点计算夹击伤害 - for (var loc in betweenAttackLocs) { - var xy = loc.split(","), - x = parseInt(xy[0]), - y = parseInt(xy[1]); - // 夹击怪物的ID - var enemyId1 = null, - enemyId2 = null; - // 检查左右夹击 - var leftBlock = blocks[x - 1 + "," + y], - rightBlock = blocks[x + 1 + "," + y]; - var leftId = core.getFaceDownId(leftBlock), - rightId = core.getFaceDownId(rightBlock); - if ( - leftBlock && - !leftBlock.disable && - rightBlock && - !rightBlock.disable && - leftId == rightId - ) { - if (core.hasSpecial(leftId, 16)) enemyId1 = leftId; - } - // 检查上下夹击 - var topBlock = blocks[x + "," + (y - 1)], - bottomBlock = blocks[x + "," + (y + 1)]; - var topId = core.getFaceDownId(topBlock), - bottomId = core.getFaceDownId(bottomBlock); - if ( - topBlock && - !topBlock.disable && - bottomBlock && - !bottomBlock.disable && - topId == bottomId - ) { - if (core.hasSpecial(topId, 16)) enemyId2 = topId; - } - - if (enemyId1 != null || enemyId2 != null) { - var leftHp = core.status.hero.hp - (damage[loc] || 0); - if (leftHp > 1) { - // 夹击伤害值 - var value = Math.floor(leftHp / 2); - // 是否不超过怪物伤害值 - if (core.flags.betweenAttackMax) { - var enemyDamage1 = core.getDamage(enemyId1, x, y, floorId); - if (enemyDamage1 != null && enemyDamage1 < value) - value = enemyDamage1; - var enemyDamage2 = core.getDamage(enemyId2, x, y, floorId); - if (enemyDamage2 != null && enemyDamage2 < value) - value = enemyDamage2; - } - if (value > 0) { - damage[loc] = (damage[loc] || 0) + value; - type[loc] = type[loc] || {}; - type[loc]["夹击伤害"] = true; - } - } - } - } - - // 取消注释下面这一段可以让护盾抵御阻激夹域伤害 - /* + // 取消注释下面这一段可以让护盾抵御阻激夹域伤害 + /* for (var loc in damage) { damage[loc] = Math.max(0, damage[loc] - core.getRealStatus('mdef')); } */ - core.flags.canGoDeadZone = canGoDeadZone; - core.status.checkBlock = { - damage: damage, - type: type, - repulse: repulse, - ambush: ambush, - needCache: needCache, - cache: {}, // clear cache - }; - }, + core.flags.canGoDeadZone = canGoDeadZone; + core.status.checkBlock = { + damage: damage, + type: type, + repulse: repulse, + ambush: ambush, + needCache: needCache, + cache: {}, // clear cache + }; +}, "moveOneStep": function (callback) { // 勇士每走一步后执行的操作。callback为行走完毕后的回调 // 这个函数执行在“刚走完”的时候，即还没有检查该点的事件和领域伤害等。 @@ -1986,19 +1582,7 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = // 更新跟随者状态，并绘制 core.updateFollowers(); core.drawHero(); - // 检查中毒状态的扣血和死亡 - if (core.hasFlag("poison")) { - core.status.hero.statistics.poisonDamage += core.values.poisonDamage; - core.status.hero.hp -= core.values.poisonDamage; - if (core.status.hero.hp <= 0) { - core.status.hero.hp = 0; - core.updateStatusBar(false, true); - core.events.lose(); - return; - } else { - core.updateStatusBar(false, true); - } - } + // 从v2.7开始，每一步行走不会再刷新状态栏。 // 如果有特殊要求（如每走一步都加buff之类），可手动取消注释下面这一句： diff --git a/project/plugins.js b/project/plugins.js index 393c3c8..138cefa 100644 --- a/project/plugins.js +++ b/project/plugins.js @@ -20194,6 +20194,8 @@ let time=0 while (oneTurn * i / max < 15) { i++ } + heroInfo.turn = 0 + enemyInfo.turn = 0 heroInfo.now *= i enemyInfo.now *= i equipInfo.forEach(v => { v.now *= i }) @@ -20815,11 +20817,13 @@ let time=0 } let nowattacking = false; if (heroInfo.now >= oneTurn && !heroInfo.isAttack) { + heroInfo.turn++ heroInfo.onAttack = false; heroInfo.isAttack = true; nowattacking = true; } if (enemyInfo.now >= oneTurn && !enemyInfo.isAttack) { + enemyInfo.turn++ enemyInfo.onAttack = false; enemyInfo.isAttack = true; nowattacking = true; @@ -20834,9 +20838,14 @@ let time=0 } }); if (!attack && nowattacking) { + let herodamage = enemyDiffList[turn].hp; if (herodamage > 0) herodamage = "+" + herodamage; - let text = herodamage === 0 ? "抵抗" : herodamage; + let text + if (core.hasSpecial(enemyInfo.id, 2) && (enemyInfo.turn - 1) % core.material.enemys[enemyInfo.id].baoji) + text = "暴击" + herodamage + else + text = herodamage === 0 ? "抵抗" : herodamage; Dove.MorePerform.ShowDamagePop.PopDamage( ctx, // 默认画布名称 @@ -20862,7 +20871,10 @@ let time=0 enemyanimateList[turn].forEach((v) => animateonAttack(v, true)); let enemydamage = heroDiffList[turn].hp; if (enemydamage > 0) enemydamage = "+" + enemydamage; - text = enemydamage === 0 ? "抵抗" : enemydamage; + if (core.hasSpecial(enemyInfo.id, 8) && (heroInfo.turn - 1) % core.material.enemys[enemyInfo.id].duck) + text = "闪避" + else + text = enemydamage === 0 ? "抵抗" : enemydamage; Dove.MorePerform.ShowDamagePop.PopDamage( ctx, // 默认画布名称 110, // 英雄位置 x @@ -24420,7 +24432,7 @@ let time=0 centerX += core.bigmap.offsetX; centerY += core.bigmap.offsetY; } - var id = setTimeout(null); + var id = Symbol(); animate.se = animate.se || {}; if (typeof animate.se == 'string') animate.se = { 1: animate.se }; tran.mode(linear()).time(1).absolute() @@ -24458,7 +24470,7 @@ let time=0 animate.se = animate.se || {}; if (typeof animate.se == 'string') animate.se = { 1: animate.se }; - var id = id || setTimeout(null); + var id = id || Symbol(); tran.mode(linear()).time(1).absolute() if (!hero) tran.value[id + name + "x"] = centerX if (!hero) tran.value[id + name + "y"] = centerY @@ -24663,7 +24675,7 @@ let time=0 if (!flags["animate_" + name]) { callback?.() } - if (!id) id = setTimeout(null) + if (!id) id = Symbol() tran.mode(linear()).time(1).absolute() if (!hero) tran.value[id + name + "x"] = x if (!hero) tran.value[id + name + "y"] = y @@ -24680,11 +24692,11 @@ let time=0 loop: loop, reverse: reverse, farme: reverse ? flags["animate_" + name].allFarme : 0, - + callback: callback }; core.plugin.playing.add(data); - callback?.() + return id }; this.animateloop = function (id, loop) { @@ -24738,6 +24750,7 @@ let time=0 } } if ((!one.reverse && one.farme > data.allFarme) || (one.reverse && one.farme < 0)) { + one.callback?.() delete tran.value[one.id + one.name + "x"] delete tran.value[one.id + one.name + "y"] core.plugin.playing.delete(one)