Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d0e0792538 | ||
|
|
b005a7ff15 | ||
|
|
12e9ac181f | ||
|
|
0ccb14cecd | ||
|
|
82d80397b6 | ||
|
|
f2da9bce65 | ||
|
|
3fdaf6d218 | ||
|
|
98a55dd3d6 | ||
|
|
dd562ae627 | ||
|
|
c9c09582c1 | ||
|
|
a368dfae48 | ||
|
|
6699cd16ba | ||
|
|
2e552cf17d | ||
|
|
ced1b28cc2 | ||
|
|
e3913f8969 | ||
|
|
8045e3c63f |
@@ -92,10 +92,13 @@ jobs:
|
||||
) as archive:
|
||||
for name in manifest["files"]:
|
||||
archive.write(root / name, folder + name)
|
||||
archive.write(
|
||||
root / "dist/manifest.json",
|
||||
folder + "manifest.json"
|
||||
)
|
||||
for descriptor in manifest.get("modules", {}).values():
|
||||
component = json.loads(
|
||||
(root / descriptor["manifest"]).read_text(encoding="utf-8")
|
||||
)
|
||||
for name in component["files"]:
|
||||
archive.write(root / name, folder + name)
|
||||
archive.write(root / "dist/manifest.json", folder + "manifest.json")
|
||||
'@ | python - $stage $package
|
||||
if ($LASTEXITCODE -ne 0) { throw '打包失败' }
|
||||
|
||||
@@ -135,7 +138,14 @@ jobs:
|
||||
-Body $body
|
||||
|
||||
$assetApi = "$api/$($release.id)/assets"
|
||||
foreach ($file in @($manifestPath, $package)) {
|
||||
$moduleManifests = @(
|
||||
Get-ChildItem (Join-Path $stage 'dist/modules') `
|
||||
-Filter '*.json' -ErrorAction SilentlyContinue
|
||||
)
|
||||
$releaseFiles = @($manifestPath)
|
||||
$releaseFiles += $moduleManifests
|
||||
$releaseFiles += $package
|
||||
foreach ($file in $releaseFiles) {
|
||||
curl.exe --fail --silent --show-error `
|
||||
-H "Authorization: token $env:GITEA_TOKEN" `
|
||||
-F "attachment=@$file" `
|
||||
@@ -151,4 +161,4 @@ jobs:
|
||||
-ContentType 'application/json' `
|
||||
-Body '{"draft":false}' | Out-Null
|
||||
|
||||
Write-Host "发布完成:$tag"
|
||||
Write-Host "发布完成:$tag"
|
||||
|
||||
@@ -90,10 +90,19 @@ jobs:
|
||||
Copy-Item -LiteralPath $manifestPath `
|
||||
-Destination (Join-Path $env:GITHUB_WORKSPACE `
|
||||
'dist/manifest.json') -Force
|
||||
$moduleManifestDir = Join-Path $source 'dist/modules'
|
||||
if (Test-Path $moduleManifestDir) {
|
||||
New-Item -ItemType Directory -Force `
|
||||
(Join-Path $env:GITHUB_WORKSPACE 'dist/modules') | Out-Null
|
||||
Copy-Item -Path (Join-Path $moduleManifestDir '*.json') `
|
||||
-Destination (Join-Path $env:GITHUB_WORKSPACE 'dist/modules') `
|
||||
-Force
|
||||
}
|
||||
git config user.name 'github-actions[bot]'
|
||||
git config user.email `
|
||||
'41898282+github-actions[bot]@users.noreply.github.com'
|
||||
git add dist/manifest.json
|
||||
git add dist/modules
|
||||
if ($LASTEXITCODE -ne 0) { throw '暂存清单失败' }
|
||||
git commit -m "Prepare manifest for $tag"
|
||||
if ($LASTEXITCODE -ne 0) { throw '提交清单失败' }
|
||||
@@ -143,10 +152,13 @@ jobs:
|
||||
) as archive:
|
||||
for name in manifest["files"]:
|
||||
archive.write(root / name, folder + name)
|
||||
archive.write(
|
||||
root / "dist/manifest.json",
|
||||
folder + "manifest.json"
|
||||
)
|
||||
for descriptor in manifest.get("modules", {}).values():
|
||||
component = json.loads(
|
||||
(root / descriptor["manifest"]).read_text(encoding="utf-8")
|
||||
)
|
||||
for name in component["files"]:
|
||||
archive.write(root / name, folder + name)
|
||||
archive.write(root / "dist/manifest.json", folder + "manifest.json")
|
||||
'@ | python - $stage $package
|
||||
if ($LASTEXITCODE -ne 0) { throw '打包失败' }
|
||||
|
||||
|
||||
@@ -1,3 +1,18 @@
|
||||
log.txt
|
||||
findings.md
|
||||
progress.md
|
||||
task_plan.md
|
||||
|
||||
dist/manifest.json
|
||||
|
||||
tools/__pycache__/
|
||||
tools/*.mjs
|
||||
|
||||
/mengsan/.planning/
|
||||
/mengsan/verification
|
||||
/mengsan/assets/sts2/
|
||||
|
||||
/Slay the Spire 2
|
||||
|
||||
*.mjs
|
||||
*.cjs
|
||||
@@ -5,7 +5,7 @@ import initShuYingMenu from "./menu.js";
|
||||
|
||||
export const type = "extension";
|
||||
export let shuYing = new Object();
|
||||
const shuYingLocalVersion = "2.0.1.1";
|
||||
const shuYingLocalVersion = "2.0.1.1-rc.1";
|
||||
|
||||
shuYing.name = "术樱包";
|
||||
shuYing.editable = false;
|
||||
@@ -49,12 +49,10 @@ shuYing.initFunction = () => {
|
||||
};
|
||||
|
||||
shuYing.getOnlineVersionText = () => `最新版本:${lib.config.shuYing_online_version || "检测中..."}`;
|
||||
shuYing.updateOnlineVersionMenu = (version) => {
|
||||
if (!version) return;
|
||||
shuYing.updateOnlineVersionMenu = (version, status = "检测中...") => {
|
||||
if (version) game.saveConfig("shuYing_online_version", version);
|
||||
|
||||
game.saveConfig("shuYing_online_version", version);
|
||||
|
||||
const text = `最新版本:${version}`;
|
||||
const text = `最新版本:${version || status}`;
|
||||
if (lib.extensionMenu.extension_术樱包?.online_version) {
|
||||
lib.extensionMenu.extension_术樱包.online_version.name = text;
|
||||
}
|
||||
@@ -113,8 +111,11 @@ shuYing.mergeCharacterPack = function (target, source, sourceName = "附加模
|
||||
};
|
||||
|
||||
shuYing.getVersion = (callback) => {
|
||||
const requestId = (shuYing.versionRequestId || 0) + 1;
|
||||
shuYing.versionRequestId = requestId;
|
||||
return updater.getOnlineVersion()
|
||||
.then(version => {
|
||||
if (requestId != shuYing.versionRequestId) return null;
|
||||
shuYing.updateOnlineVersionMenu(version?.online_version);
|
||||
if (typeof callback == "function") {
|
||||
callback(version);
|
||||
@@ -122,7 +123,9 @@ shuYing.getVersion = (callback) => {
|
||||
return version;
|
||||
})
|
||||
.catch(error => {
|
||||
if (requestId != shuYing.versionRequestId) return null;
|
||||
console.error("术樱包获取在线版本失败:", error);
|
||||
shuYing.updateOnlineVersionMenu(null, "获取失败");
|
||||
return null;
|
||||
});
|
||||
}
|
||||
@@ -247,10 +250,23 @@ shuYing.precontent = async () => {
|
||||
shuYing.initCSS();
|
||||
shuYing.initFunction();
|
||||
shuYing.initConfig();
|
||||
// const initMengsan = await shuYing.loadModule("./mengsan/mode.js", "梦三模式", true);
|
||||
// if (typeof initMengsan == "function") {
|
||||
// await initMengsan();
|
||||
// }
|
||||
const mengsanState = lib.config.shuYing_mengsan_installed_version;
|
||||
let hasMengsan = !!mengsanState && mengsanState != "disabled";
|
||||
if (!mengsanState && typeof game.checkFile != "function") {
|
||||
hasMengsan = true;
|
||||
}
|
||||
else if (!mengsanState && typeof game.checkFile == "function") {
|
||||
hasMengsan = await new Promise(resolve => {
|
||||
game.checkFile("extension/术樱包/mengsan/register.js",
|
||||
result => resolve(result == 1), () => resolve(false));
|
||||
});
|
||||
}
|
||||
if (hasMengsan) {
|
||||
const registerMengsan = await shuYing.loadModule(
|
||||
"./mengsan/register.js", "梦三模式", true
|
||||
);
|
||||
if (typeof registerMengsan == "function") registerMengsan();
|
||||
}
|
||||
initShuYingMenu({ lib, game, ui, shuYing, updater });
|
||||
shuYing.getVersion();
|
||||
await shuYing.initCharacter();
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
# 梦三模式目录
|
||||
|
||||
`register.js` 是扩展加载入口,`mode.js` 负责组装模式、注册技能并连接各领域模块,`config.js` 提供模式配置。发布器和外部扩展应继续从 `register.js` 加载,避免依赖内部文件路径。
|
||||
|
||||
| 目录 | 职责 |
|
||||
| --- | --- |
|
||||
| `battle/` | 战斗会话、回合、结算、费用与通用战斗效果 |
|
||||
| `monsters/` | 怪物阶级、牌堆默认值和各怪物意图选择 |
|
||||
| `cards/` | 卡牌定义、词缀、生成和个人牌堆 |
|
||||
| `relics/` | 遗物(道具)定义、持有规则、战斗触发及资源待补清单 |
|
||||
| `bonds/` | NPC 羁绊、助战选择、成长与意图配置、默认牌库及濒死状态 |
|
||||
| `progression/` | 征程状态、存档、剧情选择和奖励逻辑 |
|
||||
| `content/` | 章节、遭遇、剧本、角色与内容注册表 |
|
||||
| `ui/` | 地图、对话、意图、奖励、图鉴及样式 |
|
||||
| `ui/hand/` | 梦三必需手牌 UI 子扩展:真实卡牌原位排列、覆盖层及生命周期 |
|
||||
| `assets/intent/` | 意图图标 |
|
||||
| `assets/cards/` | 梦三专属卡面 |
|
||||
| `assets/portraits/` | 角色立绘 |
|
||||
| `docs/` | 战斗和关卡配置说明 |
|
||||
|
||||
新增功能优先放入所属领域;界面代码放在 `ui/`,怪物行动逻辑放在 `monsters/`。跨领域引用使用相对路径,避免新增一个涵盖所有功能的扁平 `runtime/` 目录。模块资源文件随 `tools/generate_manifest.py` 自动收录,发布入口仍为 `mengsan/register.js`。
|
||||
|
||||
手牌 UI 子扩展没有单独关闭开关;实现边界、日志位置和验证结果见
|
||||
[手牌 UI 子扩展说明](docs/ui-hand-subextension.md)。
|
||||
|
||||
梦三【杀】消耗 1 费用,基础伤害为 6;其他锦囊的基础伤害仍为 4。
|
||||
【重杀】(`mengsan_zhongsha`)是普通战斗奖励池中的通用基本牌:
|
||||
消耗 2 费用,对攻击范围内的一名其他角色直接造成 8 点伤害,
|
||||
然后给予存活目标 2 层易伤,每回合使用次数不限。
|
||||
易伤沿用既有规则:受到攻击伤害增加 50%(向上取整),
|
||||
目标每个自身回合结束减少 1 层;本次新施加的易伤不放大本次伤害。
|
||||
|
||||
强化规则集中在 `cards/upgrades.js`,未配置的牌不可强化。
|
||||
【杀】最多强化一次,伤害由 6 变为 9;【重杀】最多强化一次,
|
||||
伤害由 8 变为 10,易伤由 2 层变为 3 层,费用均不变。
|
||||
随机强化只选尚未满级、可强化且没有“永恒”词缀的牌。
|
||||
没有候选牌时禁用休息节点的磨砺,并从随机奖励中排除强化。
|
||||
旧存档不重写:历史超限等级按当前上限结算,未配置牌的历史等级不生效。
|
||||
@@ -0,0 +1,41 @@
|
||||
# 梦三卡牌立绘规范
|
||||
|
||||
用户于 2026-10-02 指定以截图 `C:\Users\Diuse\Downloads\Ai\49.png` 中“防御”为同系列基准。
|
||||
|
||||
- 后续新增及转换的梦三卡牌使用约 5:7 的完整竖幅立绘;手牌常规尺寸 112×156,窄屏 82×114。禁止直接使用横向拆包图作为运行时卡面,也不要拉伸横图。
|
||||
- 画风:泛黄宣纸、黑褐水墨、飞白与淡赭色、中国古代人物或兵器;根据卡牌效果独立安排竖幅构图。拆包图只作题材参考,不修改拆包原件。
|
||||
- 立绘不绘制名称、费用、花色、强化角标或边框。左上花色点数、左侧中段费用、右下名称由游戏原生节点和梦三样式叠加;左侧信息栏和右下名称需留空间。
|
||||
- 卡牌定义使用 `fullimage: true` 与明确的 `image` 路径,不使用横图 `fullskin`。新增卡名须加入 `ui/hand/style.css` 的本地完整卡面选择器;长牌名同时加入长名称窄屏规则。保持 `cover`,不使用 `100% 100%` 拉伸。
|
||||
- 费用和强化角标继续使用现有 `data-*` 与伪元素,避免向卡牌子节点写入额外文字而触发十周年 UI 扫描。
|
||||
- 不改变卡牌费用、效果、强化、奖励与存档数据;不修改全局标准/军争牌或十周年 UI。
|
||||
- 接入后检查完整立绘、花色/费用/名称、扇形叠牌、悬停放大和窄屏。文件检查、隔离行为测试及预览不代表实机验收。
|
||||
|
||||
现有本地卡面检查:愤怒、飞剑回旋镖、剑柄打击、全身撞击、熔融之拳及晕眩统一竖幅;防御与重杀原有竖幅保留。
|
||||
|
||||
## 卡牌描述(2026-10-02)
|
||||
|
||||
后续卡牌只描述当前费用与当前效果,不写是否可升级/强化、次数或上限,也不写升级前后对比或升级后变化。普通牌显示普通数值,已强化的牌直接显示其当前数值。此规范同步适用于悬停介绍、静态翻译、奖励摘要、牌库详情及磨砺选择说明;保留强化机制、操作按钮和紧凑 +X 角标。
|
||||
|
||||
闪电霹雳已按本规范接入竖幅水墨立绘。
|
||||
|
||||
双重打击:对应拆包 twin_strike.png 的双道斩击主题,使用同规格竖幅水墨立绘。1费,两次独立伤害;描述只显示当前牌数值。
|
||||
|
||||
铁斩波:对应拆包 iron_wave.png 的钢刃与防护波主题;竖幅水墨立绘。1费,先获得格挡再攻击,沿用护甲、脆弱、力量与易伤规则;描述只显示当前牌数值。
|
||||
|
||||
头槌:对应拆包 headbutt.png 的额头撞击主题;竖幅水墨立绘。1费,先攻击再选择一张个人弃牌置于个人抽牌堆顶部。移动原实体牌,保留ID、花色、强化与词缀,不新增永久牌。
|
||||
|
||||
突破:对应拆包 breakthrough.png 的突破包围与群体横扫主题;5:7竖幅宣纸水墨立绘。1费,先通过原生 loseHp 失去1点生命,再对所有存活敌方造成9点伤害。失去生命不抵扣格挡;等待正常濒死/救援结算,若角色死亡或战斗结束则停止攻击。描述只显示当前牌费用与效果。
|
||||
|
||||
预备打击:对应 setup_strike.png 的挥拳与蓄势主题;5:7竖幅宣纸水墨立绘。1费,先造成7点伤害,再在当前完整回合内获得2点临时力量。按网页主表而非未正式发布的更新历史实现;描述只显示当前效果。临时力量可叠加,独立于永久力量,当前完整回合结束/死亡/战斗退出时清理。
|
||||
|
||||
完美打击:对应 perfected_strike.png 的精准挥刀主题;全幅5:7竖幅宣纸水墨立绘。2费,基础6点伤害,本场战斗每张当前名称含“打击”的牌增加2点伤害。统计手牌、个人抽牌堆、个人弃牌堆、消耗牌及本人打出区的真实牌,去重并包含此牌自身;生成/复制/变形即时生效,不读取永久牌组、不统计公共或敌方牌。描述只显示当前牌费用与效果。
|
||||
|
||||
余烬:对应 cinder.png 的灼热弯刀与燃尽主题;5:7完整竖幅宣纸水墨立绘。2费,先造成18点伤害,再从当时自己的剩余手牌中随机消耗一张。遵循网页0.101.0后的手牌规则,不消耗抽牌堆顶部。通过原生失牌事件移入私有消耗区,不进入弃牌堆/洗牌,不更改永久牌组;没有手牌时仍造成伤害。描述只显示当前费用与效果。
|
||||
|
||||
放血:对应 bloodletting.png 的气血换取力量主题;完整5:7竖幅宣纸水墨立绘。0费,先通过原生 loseHp 失去3点生命,再获得2点当前费用,不增加费用上限。等待濒死救援;死亡、战斗结束或切换后不再获得费用。属于技能牌,缠身不额外增加攻击费用;描述只显示当前费用与效果。
|
||||
|
||||
坚毅:对应 true_grit.png 的顶住巨岩、防御与坚忍主题;完整5:7竖幅宣纸水墨立绘。1费,先获得7点格挡,再从当时自己的剩余手牌中随机消耗一张;当前选择模式通过原生选牌事件选择自己的手牌。移动原实体牌到私有消耗区,保留ID、花色、当前状态和词缀,不改永久牌组;无手牌时仍获得格挡。等待格挡事件,防止战斗结束、换场、死亡及陈旧选牌继续失牌;沿用脆弱的格挡衰减。描述只显示当前费用与效果。
|
||||
|
||||
破灭:对应 HAVOC/havoc.png 的宽刃旋斩与黑披风主题;完整5:7竖幅宣纸水墨立绘。普通1费,当前另一状态0费;免费使用自己的抽牌堆顶部实体牌,再仅消耗该原牌。费用豁免绑定原生选择/使用父链和实体身份,不改卡牌费用或词缀,愤怒生成的副本正常进入自己的弃牌堆,不跟随原牌消耗(对应Wiki0.104.0修复)。原生可用性和目标规则保持有效,无法使用的堆顶牌仍消耗;目标由原生使用流程选择。空抽牌堆不洗牌、不触发抽牌不足失败。保留当前数值、ID、花色、词缀和永久牌组,防止换场/死亡期间陈旧使用。描述只显示当前费用和效果。
|
||||
|
||||
耸肩无视:对应 SHRUG_IT_OFF/shrug_it_off.png 的耸肩摊手、厚重肩甲弹开攻击主题;完整5:7竖幅宣纸水墨立绘。1费,先通过原生 changeHujia 获得8点格挡,再通过原生 draw 抽1张牌;当前牌直接显示其实际格挡值。沿用脆弱对格挡的衰减与个人牌堆抽牌/洗牌/不足失败流程;等待格挡完全结算,战斗结束、死亡、换场或个人牌堆被替换后不再抽牌,不触碰公共和其他角色牌堆,不修改永久牌组;无消耗关键词。描述只显示当前费用与效果。
|
||||
|
After Width: | Height: | Size: 3.1 MiB |
|
After Width: | Height: | Size: 3.4 MiB |
|
After Width: | Height: | Size: 3.4 MiB |
|
After Width: | Height: | Size: 3.1 MiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 3.0 MiB |
|
After Width: | Height: | Size: 3.1 MiB |
|
After Width: | Height: | Size: 3.5 MiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 381 KiB |
|
After Width: | Height: | Size: 3.2 MiB |
|
After Width: | Height: | Size: 3.3 MiB |
|
After Width: | Height: | Size: 3.3 MiB |
|
After Width: | Height: | Size: 3.4 MiB |
|
After Width: | Height: | Size: 3.3 MiB |
|
After Width: | Height: | Size: 3.4 MiB |
|
After Width: | Height: | Size: 3.3 MiB |
|
After Width: | Height: | Size: 2.5 MiB |
|
After Width: | Height: | Size: 9.3 KiB |
|
After Width: | Height: | Size: 11 KiB |
|
After Width: | Height: | Size: 12 KiB |
|
After Width: | Height: | Size: 12 KiB |
|
After Width: | Height: | Size: 14 KiB |
|
After Width: | Height: | Size: 5.4 KiB |
|
After Width: | Height: | Size: 8.0 KiB |
|
After Width: | Height: | Size: 7.5 KiB |
|
After Width: | Height: | Size: 15 KiB |
|
After Width: | Height: | Size: 9.3 KiB |
|
After Width: | Height: | Size: 7.3 KiB |
|
After Width: | Height: | Size: 4.9 KiB |
|
After Width: | Height: | Size: 8.8 KiB |
|
After Width: | Height: | Size: 9.8 KiB |
|
After Width: | Height: | Size: 13 KiB |
|
After Width: | Height: | Size: 10 KiB |
|
After Width: | Height: | Size: 6.3 KiB |
|
After Width: | Height: | Size: 2.8 MiB |
|
After Width: | Height: | Size: 161 KiB |
|
After Width: | Height: | Size: 2.6 MiB |
|
After Width: | Height: | Size: 116 KiB |
|
After Width: | Height: | Size: 2.5 MiB |
|
After Width: | Height: | Size: 7.8 KiB |
|
After Width: | Height: | Size: 2.2 MiB |
|
After Width: | Height: | Size: 16 KiB |
|
After Width: | Height: | Size: 1.9 MiB |
|
After Width: | Height: | Size: 2.2 MiB |
|
After Width: | Height: | Size: 2.2 MiB |
|
After Width: | Height: | Size: 12 KiB |
|
After Width: | Height: | Size: 2.3 MiB |
|
After Width: | Height: | Size: 9.7 KiB |
|
After Width: | Height: | Size: 2.1 MiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 2.2 MiB |
|
After Width: | Height: | Size: 22 KiB |
|
After Width: | Height: | Size: 2.0 MiB |
|
After Width: | Height: | Size: 8.9 KiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 9.1 KiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 8.7 KiB |
|
After Width: | Height: | Size: 2.7 MiB |
|
After Width: | Height: | Size: 190 KiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 2.6 MiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 2.5 MiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 2.1 MiB |
|
After Width: | Height: | Size: 29 KiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 34 KiB |
|
After Width: | Height: | Size: 2.2 MiB |
|
After Width: | Height: | Size: 56 KiB |
|
After Width: | Height: | Size: 2.8 MiB |
|
After Width: | Height: | Size: 2.3 MiB |
|
After Width: | Height: | Size: 36 KiB |
|
After Width: | Height: | Size: 2.0 MiB |
|
After Width: | Height: | Size: 12 KiB |
|
After Width: | Height: | Size: 2.4 MiB |
|
After Width: | Height: | Size: 24 KiB |
|
After Width: | Height: | Size: 2.7 MiB |
|
After Width: | Height: | Size: 8.8 KiB |
@@ -0,0 +1,181 @@
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
const camps = new Set(["ally", "enemy", "neutral"]);
|
||||
export const campPresets = Object.freeze({ ally: { enabled: true }, enemy: { enabled: true }, neutral: { enabled: false } });
|
||||
const events = new Set(["battleStart", "roundStart", "turnStart", "turnEnd", "state"]);
|
||||
const checks = new Set(["hp", "hand", "alive", "linked", "turnedOver", "camp"]);
|
||||
const numeric = value => Number.isInteger(value) && value >= 0 && value <= 99;
|
||||
const assert = (condition, message) => { if (!condition) throw new Error("梦三关卡配置:" + message); };
|
||||
|
||||
export function validateBattlePlan(plan) {
|
||||
assert(plan && Array.isArray(plan.units) && Array.isArray(plan.rules), "units/rules 必须为数组");
|
||||
assert(plan.units.length > 0 && plan.units.length <= 7 && plan.rules.length <= 32, "初始单位或规则数量越界");
|
||||
const ids = new Set(["player"]), ruleIds = new Set();
|
||||
const unit = spec => {
|
||||
assert(spec && typeof spec.id === "string" && /^[\w.-]+$/.test(spec.id) && !ids.has(spec.id), "单位 ID 无效或重复");
|
||||
ids.add(spec.id);
|
||||
assert(ids.size <= 8, "单场累计最多 8 个席位(含主角及后续援军)");
|
||||
assert(typeof spec.character === "string" && spec.character.length > 0 && camps.has(spec.camp), "武将或阵营无效");
|
||||
assert(spec.camp !== "neutral", "中立预设尚未启用");
|
||||
assert(spec.tier == null || ["normal", "elite", "boss"].includes(spec.tier), "怪物阶级无效");
|
||||
assert(spec.deck == null || (Array.isArray(spec.deck) && spec.deck.length > 0 && spec.deck.every(entry =>
|
||||
typeof entry === "string" && Boolean(entry) || entry && typeof entry.name === "string" && Boolean(entry.name) &&
|
||||
(entry.suit == null || ["spade", "heart", "club", "diamond"].includes(entry.suit)) &&
|
||||
(entry.number == null || Number.isInteger(entry.number) && entry.number >= 1 && entry.number <= 13))), "怪物专属牌堆无效");
|
||||
for (const key of ["hand", "hp", "maxHp"]) if (spec[key] != null) assert(numeric(spec[key]), key + " 越界");
|
||||
if (spec.hp != null) assert(spec.hp > 0, "初始体力必须大于 0");
|
||||
if (spec.maxHp != null) assert(spec.maxHp > 0 && (spec.hp == null || spec.hp <= spec.maxHp), "初始体力上限无效");
|
||||
assert(spec.inheritSkills == null || typeof spec.inheritSkills === "boolean", "inheritSkills 必须为布尔值");
|
||||
assert(spec.after == null || typeof spec.after === "string", "after 必须是单位 ID");
|
||||
assert(spec.equipment == null || (Array.isArray(spec.equipment) && spec.equipment.length <= 5), "equipment 无效");
|
||||
for (const card of spec.equipment || []) {
|
||||
assert(card && typeof card.name === "string" && card.name.length > 0, "初始装备名称无效");
|
||||
assert(["spade", "heart", "club", "diamond"].includes(card.suit), "初始装备花色无效");
|
||||
assert(Number.isInteger(card.number) && card.number >= 1 && card.number <= 13, "初始装备点数无效");
|
||||
}
|
||||
assert(spec.skills == null || (Array.isArray(spec.skills) && spec.skills.every(s => typeof s === "string")), "skills 无效");
|
||||
};
|
||||
plan.units.forEach(unit);
|
||||
for (const rule of plan.rules) {
|
||||
assert(rule && typeof rule.id === "string" && !ruleIds.has(rule.id), "规则 ID 重复或无效"); ruleIds.add(rule.id);
|
||||
assert(rule.when && events.has(rule.when.event || "state"), "触发时机无效");
|
||||
assert(rule.blocksVictory == null || typeof rule.blocksVictory === "boolean", "blocksVictory 必须为布尔值");
|
||||
assert(rule.when.round == null || (numeric(rule.when.round) && rule.when.round > 0), "轮数无效");
|
||||
assert(rule.when.actorTurns == null || (rule.when.event === "turnEnd" && rule.when.actor && numeric(rule.when.actorTurns) && rule.when.actorTurns > 0), "actorTurns 仅用于指定角色的回合结束");
|
||||
assert(rule.when.turn == null || (numeric(rule.when.turn) && rule.when.turn > 0), "回合数无效");
|
||||
assert(Array.isArray(rule.effects) && rule.effects.length > 0 && rule.effects.length <= 16, "效果列表无效");
|
||||
for (const effect of rule.effects) {
|
||||
assert(["spawn", "draw", "recover", "maxHp", "skill", "camp", "dialogue", "discardEquipment"].includes(effect.type), "未知效果");
|
||||
if (effect.type === "spawn") unit(effect.unit);
|
||||
else if (effect.type === "dialogue") {
|
||||
assert(Array.isArray(effect.lines) && effect.lines.every(line => line && ["character", "narrator", "sound", "choice"].includes(line.type) && typeof line.text === "string" && line.text.trim() && (line.type !== "character" || typeof line.character === "string") && (line.type !== "choice" || (/^story\.[\w.]+$/.test(line.flag || "") && Array.isArray(line.choices) && line.choices.length >= 1 && (line.defaultChoice == null || line.choices.some(choice => choice.id === line.defaultChoice))))), "dialogue 台词无效");
|
||||
}
|
||||
else {
|
||||
assert(typeof effect.target === "string", "效果缺少目标 ID");
|
||||
if (["draw", "recover", "maxHp"].includes(effect.type)) assert(numeric(effect.amount) && effect.amount > 0, "效果数值无效");
|
||||
if (effect.type === "discardEquipment") assert(typeof effect.name === "string" && effect.name.length > 0, "弃置装备名称无效");
|
||||
if (effect.type === "skill") assert(typeof effect.skill === "string" && effect.skill.length > 0, "技能 ID 无效");
|
||||
if (effect.type === "camp") assert(["ally", "enemy"].includes(effect.camp) && effect.target !== "player", "阵营无效或试图改变主角阵营");
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const rule of plan.rules) {
|
||||
assert(rule.when.actor == null || ids.has(rule.when.actor), "行动角色 ID 无效");
|
||||
assert(rule.when.all == null || (Array.isArray(rule.when.all) && rule.when.all.length <= 16), "条件列表无效");
|
||||
for (const condition of rule.when.all || []) {
|
||||
assert(ids.has(condition.unit) && checks.has(condition.field), "条件单位或字段无效");
|
||||
if (["hp", "hand"].includes(condition.field)) assert(["eq", "gte", "lte"].includes(condition.op) && numeric(condition.value), "数值比较无效");
|
||||
else if (condition.field === "camp") assert(camps.has(condition.value), "阵营条件无效");
|
||||
else assert(typeof condition.value === "boolean", "状态条件必须为布尔值");
|
||||
}
|
||||
for (const effect of rule.effects) if (!["spawn", "dialogue"].includes(effect.type)) assert(ids.has(effect.target), "效果目标不存在");
|
||||
}
|
||||
for (const spec of [...plan.units, ...plan.rules.flatMap(r => r.effects.filter(e => e.type === "spawn").map(e => e.unit))]) {
|
||||
assert(spec.after == null || (ids.has(spec.after) && spec.after !== spec.id), "after 席位目标无效");
|
||||
}
|
||||
return plan;
|
||||
}
|
||||
|
||||
export function grantSupport(run, rewardId, spec) {
|
||||
const supports = run.player.supports ||= [];
|
||||
const battles = spec.battles ?? -1;
|
||||
assert(battles === -1 || (Number.isInteger(battles) && battles > 0 && battles <= 99), "支援持续场数无效");
|
||||
// One support per source; repeated permanent items do not clone the same helper.
|
||||
const existing = supports.find(s => s.rewardId === rewardId);
|
||||
if (existing) { existing.battles = existing.battles === -1 || battles === -1 ? -1 : Math.min(99, existing.battles + battles); return; }
|
||||
const number = (run.supportSequence || 0) + 1;
|
||||
run.supportSequence = number;
|
||||
supports.push({ id: `support_${number}`, rewardId, category: spec.category || "item", unit: copy(spec.unit), battles });
|
||||
}
|
||||
|
||||
export function buildBattlePlan(encounter, run, bondUnit = null) {
|
||||
const plan = copy(encounter.battlePlan || {
|
||||
units: [{ id: "enemy_1", character: encounter.enemy, camp: "enemy", tier: encounter.tier || "normal", hand: 4 }], rules: [],
|
||||
});
|
||||
plan.rules ||= [];
|
||||
// Consumed only in the battle's run snapshot; the existing settlement commits it atomically.
|
||||
for (const support of run.player.supports || []) {
|
||||
if (support.battles === 0) continue;
|
||||
assert(support.battles === -1 || (Number.isInteger(support.battles) && support.battles > 0), "支援持续场数无效");
|
||||
plan.units.push({ ...copy(support.unit), id: support.id });
|
||||
}
|
||||
if (bondUnit) plan.units.unshift(copy(bondUnit));
|
||||
validateBattlePlan(plan);
|
||||
return plan;
|
||||
}
|
||||
|
||||
export function consumeSupports(run) {
|
||||
run.player.supports = (run.player.supports || []).map(s => ({ ...s, battles: s.battles > 0 ? s.battles - 1 : s.battles })).filter(s => s.battles !== 0);
|
||||
}
|
||||
|
||||
export function createBattleDirector(plan, adapters) {
|
||||
validateBattlePlan(plan);
|
||||
const units = new Map(), fired = new Set(), completedTurns = new Map(), seenPhases = new WeakSet();
|
||||
let round = 0, turn = 0, actor = null, ready = false, running = false, disposed = false;
|
||||
const compare = (actual, op, value) => op === "gte" ? actual >= value : op === "lte" ? actual <= value : actual === value;
|
||||
function matches(when, event) {
|
||||
if ((when.event || "state") !== event) return false;
|
||||
if (when.round != null && round < when.round) return false;
|
||||
if (when.turn != null && turn < when.turn) return false;
|
||||
if (when.actorTurns != null && (completedTurns.get(actor) || 0) < when.actorTurns) return false;
|
||||
if (when.actor != null && units.get(when.actor) !== actor) return false;
|
||||
return (when.all || []).every(condition => {
|
||||
const player = units.get(condition.unit);
|
||||
if (!player) return false;
|
||||
const state = adapters.state(player);
|
||||
return compare(state[condition.field], condition.op || "eq", condition.value);
|
||||
});
|
||||
}
|
||||
async function evaluate(event = "state") {
|
||||
if (!ready || disposed || running) return;
|
||||
running = true;
|
||||
try {
|
||||
// Every rule runs once per battle; marking before effects prevents recursive triggers.
|
||||
for (let pass = 0; pass <= plan.rules.length; pass++) {
|
||||
let changed = false;
|
||||
for (const rule of plan.rules) {
|
||||
if (disposed || !adapters.active()) return;
|
||||
if (fired.has(rule.id) || !matches(rule.when, event)) continue;
|
||||
fired.add(rule.id); changed = true;
|
||||
for (const effect of rule.effects) {
|
||||
if (disposed || !adapters.active()) return;
|
||||
if (effect.type === "dialogue") await adapters.dialogue(effect.lines);
|
||||
else if (effect.type === "spawn") {
|
||||
const anchor = effect.unit.after == null ? null : units.get(effect.unit.after);
|
||||
if (effect.unit.after != null && !anchor) throw new Error("支援席位目标尚未登场:" + effect.unit.after);
|
||||
units.set(effect.unit.id, await adapters.spawn(effect.unit, anchor));
|
||||
}
|
||||
else {
|
||||
const target = units.get(effect.target);
|
||||
if (target && adapters.state(target).alive) await adapters.effect(target, effect);
|
||||
}
|
||||
}
|
||||
adapters.log(rule.name || rule.id);
|
||||
}
|
||||
if (!changed) break;
|
||||
}
|
||||
} finally { running = false; }
|
||||
}
|
||||
return {
|
||||
bind(id, player) { if (units.has(id)) throw new Error("Duplicate battle unit: " + id); units.set(id, player); },
|
||||
async start() { ready = true; await evaluate("battleStart"); await evaluate("state"); },
|
||||
async beforeTurn(player) {
|
||||
turn++; actor = player;
|
||||
if (player === units.get("player")) { round++; await evaluate("roundStart"); }
|
||||
await evaluate("turnStart"); await evaluate("state");
|
||||
},
|
||||
async afterTurn(player, phase) {
|
||||
if (!ready || disposed || !adapters.active()) return;
|
||||
if (phase && seenPhases.has(phase)) return;
|
||||
if (phase) seenPhases.add(phase);
|
||||
actor = player;
|
||||
completedTurns.set(player, (completedTurns.get(player) || 0) + 1);
|
||||
await evaluate("turnEnd"); await evaluate("state");
|
||||
},
|
||||
evaluate,
|
||||
get ready() { return ready; },
|
||||
get busy() { return running; },
|
||||
get pendingEnemies() { return plan.rules.some(rule => rule.blocksVictory && !fired.has(rule.id) && rule.effects.some(e => (e.type === "spawn" && e.unit.camp === "enemy") || (e.type === "camp" && e.camp === "enemy"))); },
|
||||
get defeatedEnemies() { return [...units.values()].filter(p => { const s = adapters.state(p); return s.camp === "enemy" && !s.alive; }).length; },
|
||||
dispose() { disposed = true; units.clear(); },
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
// Candidate external coordinator. Finish callbacks return a boolean, NEVER a drain promise.
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
export function createBattleFlow({settlement, chooseReward, chooseDefeat, showMap, showEnding, quiesce, releaseSkills = async () => {}, presentVictory = async () => {}}) {
|
||||
let state = "map", active = null, work = null, job = null, error = null;
|
||||
async function drive() {
|
||||
try {
|
||||
state = "draining";
|
||||
await active.session.drain();
|
||||
// Allow mode-start/parent frames and foreign pauses to unwind; never resume them.
|
||||
await quiesce();
|
||||
if (!job.pending) job.pending = await settlement.prepare(job.input);
|
||||
if (job.pending.outcome === "victory" && !job.victoryPresented) {
|
||||
await presentVictory(copy(job.pending));
|
||||
job.victoryPresented = true;
|
||||
}
|
||||
// Also reopen a legacy chosen defeat: it never had a recovery choice.
|
||||
if (job.pending.state !== "chosen" ||
|
||||
(job.pending.outcome === "defeat" && !job.pending.failureAction)) {
|
||||
state = "choosing";
|
||||
if (!job.hasChoice) {
|
||||
job.choiceId = job.pending.outcome === "defeat" ? await chooseDefeat()
|
||||
: await chooseReward(copy(job.pending.choices), {
|
||||
boss: job.pending.boss,
|
||||
fixedRewards: copy(job.pending.fixedRewards || []),
|
||||
rewardPackage: copy(job.pending.rewardPackage || null),
|
||||
});
|
||||
if (job.pending.outcome !== "defeat" && !job.pending.rewardPackage &&
|
||||
job.choiceId !== null &&
|
||||
!job.pending.choices.some(c => c.id === job.choiceId && c.kind !== "gold")) throw new Error("Invalid reward selection");
|
||||
job.hasChoice = true;
|
||||
}
|
||||
job.pending = await settlement.choose(job.input.run.runId, job.pending.id, job.choiceId);
|
||||
}
|
||||
if (!job.committed) {
|
||||
state = "committing";
|
||||
job.committed = await settlement.commit(job.input.run.runId, job.pending.id);
|
||||
}
|
||||
if (!job.skillsReleased) {
|
||||
state = "releasingSkills";
|
||||
await releaseSkills();
|
||||
job.skillsReleased = true;
|
||||
await quiesce();
|
||||
}
|
||||
state = "cleaning";
|
||||
await active.session.dispose(); // Failed cleanup retry does NOT replay a committed reward.
|
||||
await quiesce();
|
||||
if (!job.delivered) {
|
||||
state = "presenting";
|
||||
if (job.committed.route === "map") {
|
||||
const mapRun = copy(job.committed.run);
|
||||
job.nextNode = await showMap(mapRun);
|
||||
job.committed.run = mapRun;
|
||||
}
|
||||
else if (!["retry", "new"].includes(job.committed.route)) {
|
||||
await showEnding(job.committed.route, copy(job.committed.run));
|
||||
}
|
||||
job.delivered = true;
|
||||
}
|
||||
state = job.committed.route === "map" ? "map" : "ended";
|
||||
return {...copy(job.committed), nextNode:copy(job.nextNode ?? null)};
|
||||
} catch (cause) {
|
||||
error = cause; state = "retryable"; throw cause;
|
||||
}
|
||||
}
|
||||
function launch() {
|
||||
error = null; state = "draining";
|
||||
work = Promise.resolve().then(drive);
|
||||
// The engine callback is fire-and-forget; keep failure observable without unhandled rejection.
|
||||
work.catch(() => {});
|
||||
}
|
||||
return Object.freeze({
|
||||
get state() { return state; },
|
||||
get error() { return error; },
|
||||
async enterBattle({session, run, node, encounter, start}) {
|
||||
if (state !== "map") throw new Error("Map handoff not ready");
|
||||
if (run.battleFlow?.pending) throw new Error("Resume pending settlement before battle");
|
||||
const saved = settlement.readRun();
|
||||
if (!saved || saved.runId !== run.runId || saved.revision !== run.revision) throw new Error("Stale battle input");
|
||||
state = "starting";
|
||||
try {
|
||||
await quiesce();
|
||||
active = {session, run, retryRun:copy(run), node:copy(node), encounter:copy(encounter)};job = null;work = null;
|
||||
// start MUST schedule only; it must not await the battle root's completion.
|
||||
state = "battle"; start();
|
||||
} catch (cause) { state = "blocked"; error = cause; throw cause; }
|
||||
},
|
||||
requestFinish({session, hp, outcome = "victory", defeatedEnemies = 1}) {
|
||||
if (state !== "battle" || session !== active.session) return false;
|
||||
if (!["victory", "defeat"].includes(outcome)) throw new Error("Unknown outcome");
|
||||
if (!Number.isInteger(defeatedEnemies) || defeatedEnemies < 0) throw new Error("Invalid defeated enemy count");
|
||||
job = {input:{run:copy(active.run),retryRun:copy(active.retryRun),node:copy(active.node),encounter:{...copy(active.encounter),defeatedEnemies},hp,outcome}};
|
||||
state = "stopping";
|
||||
active.session.requestStop();
|
||||
launch();
|
||||
return true; // No game.pause/resume: stop loop, let current body unwind, then open rewards.
|
||||
},
|
||||
resumePending({session}) {
|
||||
if (state !== "map") throw new Error("Cannot resume during another operation");
|
||||
const run = settlement.readRun(), item = run?.battleFlow?.pending;
|
||||
if (!item) throw new Error("No durable pending settlement");
|
||||
active = {session};
|
||||
job = {input:{run}, pending:copy(item)};
|
||||
state = "stopping"; session.requestStop(); launch(); return work;
|
||||
},
|
||||
retry() {
|
||||
if (state !== "retryable") throw new Error("No failed settlement to retry");
|
||||
launch(); return work;
|
||||
},
|
||||
wait() { if (!work) throw new Error("No settlement requested"); return work; },
|
||||
});
|
||||
}
|
||||
|
||||
// Run outside engine events. No busy poll, no global queue clearing, no pause ownership guessing.
|
||||
export async function quiesceEngine({eventManager, pauseManager}, nextTask = () => new Promise(resolve => setTimeout(resolve, 0))) {
|
||||
await nextTask();
|
||||
await pauseManager.waitPause();
|
||||
if (eventManager.eventStack.length || eventManager.tempEvent) throw new Error("Engine event stack is not idle");
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
// Track only the turn created by this battle's cooperative loop.
|
||||
const battleTurns = new WeakMap();
|
||||
const turnStages = new Set(["phase", "phaseZhunbei", "phaseJudge", "phaseDraw", "phaseUse", "phaseDiscard", "phaseJieshu"]);
|
||||
|
||||
export function stopBattleTurn(session, eventManager) {
|
||||
const turn = battleTurns.get(session);
|
||||
if (!turn) return;
|
||||
const belongsToTurn = event => {
|
||||
const seen = new Set();
|
||||
while (event && !seen.has(event)) {
|
||||
if (event === turn) return true;
|
||||
seen.add(event);
|
||||
event = event.parent;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
// Finish phase controllers, not the card/damage/death events currently resolving.
|
||||
// Those events must unwind before the session can safely dispose players.
|
||||
for (const event of eventManager.eventStack.slice().reverse()) {
|
||||
if (turnStages.has(event.name) && belongsToTurn(event)) event.finish();
|
||||
}
|
||||
turn.finish();
|
||||
}
|
||||
|
||||
// Candidate derived from local engine phaseLoop; no global replacement.
|
||||
export async function runPhaseLoop(event, player, session, { game, lib, _status, get, beforeTurn = async () => {} }) {
|
||||
let num = 1;
|
||||
let current = player;
|
||||
while (session.active && !event.finished && current.getSeatNum() === 0) {
|
||||
current.setSeatNum(num);
|
||||
current = current.next;
|
||||
num++;
|
||||
}
|
||||
while (session.active && !event.finished) {
|
||||
if (game.players.includes(event.player)) {
|
||||
await beforeTurn(event.player);
|
||||
if (!session.active || event.finished) return;
|
||||
lib.onphase.forEach((i) => i());
|
||||
if (!session.active || event.finished) return;
|
||||
const phase = event.player.phase();
|
||||
battleTurns.set(session, phase);
|
||||
try {
|
||||
event.next.remove(phase);
|
||||
let isRoundEnd = false;
|
||||
if (lib.onround.every((i) => i(phase, event.player))) {
|
||||
isRoundEnd = _status.roundSkipped;
|
||||
if (_status.isRoundFilter) {
|
||||
isRoundEnd = _status.isRoundFilter(phase, event.player);
|
||||
} else if (_status.seatNumSettled) {
|
||||
const seatNum = event.player.getSeatNum();
|
||||
if (seatNum != 0) {
|
||||
if (get.itemtype(_status.lastPhasedPlayer) != "player" || seatNum < _status.lastPhasedPlayer.getSeatNum()) {
|
||||
isRoundEnd = true;
|
||||
}
|
||||
}
|
||||
} else if (event.player == _status.roundStart) {
|
||||
isRoundEnd = true;
|
||||
}
|
||||
if (isRoundEnd && _status.globalHistory.some((i) => i.isRound)) {
|
||||
game.log();
|
||||
await event.trigger("roundEnd");
|
||||
}
|
||||
}
|
||||
if (!session.active || event.finished) { phase.finish(); return; }
|
||||
event.next.push(phase);
|
||||
await phase;
|
||||
} finally {
|
||||
if (battleTurns.get(session) === phase) battleTurns.delete(session);
|
||||
}
|
||||
}
|
||||
if (!session.active || event.finished) return;
|
||||
await event.trigger("phaseOver");
|
||||
if (!session.active || event.finished) return;
|
||||
const findNext = (current2) => {
|
||||
const players = game.players.slice(0).concat(game.dead).sort((a, b) => parseInt(a.dataset.position) - parseInt(b.dataset.position));
|
||||
const position = parseInt(current2.dataset.position);
|
||||
for (const player2 of players) {
|
||||
if (parseInt(player2.dataset.position) > position) {
|
||||
return player2;
|
||||
}
|
||||
}
|
||||
return players[0];
|
||||
};
|
||||
event.player = findNext(event.player);
|
||||
if (!event.player) return;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
// Exclusive battle resources. Never clear arbitrary global queues or arbitrary timers.
|
||||
export function createBattleResources(session, {game, ui, _status}) {
|
||||
const cards = new Set(), nodes = new Map(), fields = [];
|
||||
const containers = () => [ui.arena, ui.control, ui.sidebar, ui.cardPile, ui.discardPile, ui.ordering, ui.special].filter(Boolean);
|
||||
const children = () => new Map(containers().map(parent => [parent, new Set(parent.childNodes)]));
|
||||
const before = children();
|
||||
const uiKeys = ["me","handcards1Container","handcards2Container","handcards1","handcards2"];
|
||||
const uiBefore = new Map(uiKeys.map(key => [key,Object.getOwnPropertyDescriptor(ui,key)]));
|
||||
function field(object, key, value) {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(object, key);
|
||||
object[key] = value;
|
||||
fields.push({object,key,value,descriptor});
|
||||
return value;
|
||||
}
|
||||
// Install before root.start so global history cannot retain the finished battle tree.
|
||||
field(_status, "globalHistory", [{cardMove:[],custom:[],useCard:[],changeHp:[],everything:[]}]);
|
||||
field(_status, "cardtag", Object.fromEntries(Object.keys(_status.cardtag || {}).map(key => [key,[]])));
|
||||
const counters = {phaseNumber:game.phaseNumber, roundNumber:game.roundNumber};
|
||||
game.phaseNumber = 0; game.roundNumber = 0;
|
||||
session.ownResource({}, () => {
|
||||
for (const card of cards) card.remove();
|
||||
for (const [node,parent] of nodes) if (node.parentNode === parent) node.remove();
|
||||
for (const {object,key,value,descriptor} of fields.reverse()) {
|
||||
if (object[key] !== value) continue; // A replacement owned by another subsystem survives.
|
||||
if (descriptor) Object.defineProperty(object,key,descriptor); else delete object[key];
|
||||
}
|
||||
game.phaseNumber = counters.phaseNumber; game.roundNumber = counters.roundNumber;
|
||||
});
|
||||
return Object.freeze({
|
||||
field,
|
||||
card(card) { cards.add(card); return card; },
|
||||
capturePreparedArena() {
|
||||
for (const key of uiKeys) {
|
||||
const descriptor = uiBefore.get(key);
|
||||
if (ui[key] !== descriptor?.value) fields.push({object:ui,key,value:ui[key],descriptor});
|
||||
}
|
||||
// Call synchronously after prepareArena, with onfree already drained.
|
||||
for (const parent of containers()) {
|
||||
const prior = before.get(parent) || new Set();
|
||||
for (const node of parent.childNodes) if (!prior.has(node)) {
|
||||
if ([ui.cardPile,ui.discardPile,ui.ordering,ui.special].includes(parent)) cards.add(node);
|
||||
else nodes.set(node,parent);
|
||||
}
|
||||
}
|
||||
},
|
||||
bindPlayers(players) {
|
||||
const owned = new Set(players);
|
||||
session.ownResource({}, () => {
|
||||
for (const key of ["currentPhase","lastPhasedPlayer","roundStart"]) {
|
||||
if (owned.has(_status[key])) delete _status[key];
|
||||
}
|
||||
});
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
// Candidate only. No engine globals, event prototype patches, or save writes.
|
||||
const owners = new WeakMap();
|
||||
|
||||
export function createBattleSession(id) {
|
||||
if (typeof id !== "string" || !id.trim()) throw new TypeError("Session ID required");
|
||||
const token = Object.freeze({ id });
|
||||
let state = "running", disposePromise = null;
|
||||
const pending = new Set(), events = new Set(), resources = new Map(), errors = [];
|
||||
const waiters = new Set();
|
||||
const notify = () => { for (const wake of waiters) wake(); waiters.clear(); };
|
||||
const ensureRunning = () => { if (state !== "running") throw new Error("Session is stopping"); };
|
||||
const claim = object => {
|
||||
if (!object || (typeof object !== "object" && typeof object !== "function")) throw new TypeError("Object required");
|
||||
const owner = owners.get(object);
|
||||
if (owner && owner !== token) throw new Error("Foreign session resource");
|
||||
owners.set(object, token);
|
||||
};
|
||||
// Observe a native completion promise; never assimilate GameEvent.then(), which can start queues.
|
||||
const observe = promise => {
|
||||
if (!(promise instanceof Promise)) throw new TypeError("Native completion Promise required");
|
||||
pending.add(promise);
|
||||
promise.then(() => { pending.delete(promise); notify(); }, error => {
|
||||
errors.push(error); pending.delete(promise); notify();
|
||||
});
|
||||
return promise;
|
||||
};
|
||||
const api = {
|
||||
id,
|
||||
get state() { return state; },
|
||||
get active() { return state === "running"; },
|
||||
get pendingCount() { return pending.size; },
|
||||
guard(callback) {
|
||||
if (typeof callback !== "function") throw new TypeError("Callback required");
|
||||
return (...args) => state === "running" ? callback(...args) : undefined;
|
||||
},
|
||||
runTask(factory) {
|
||||
ensureRunning();
|
||||
if (typeof factory !== "function") throw new TypeError("Task factory required");
|
||||
// Reserve before invoking user code so a stop request inside it cannot race drain().
|
||||
return observe(Promise.resolve().then(() => state === "running" ? factory(api) : undefined));
|
||||
},
|
||||
ownEvent(event, completion) {
|
||||
ensureRunning();
|
||||
if (typeof event?.finish !== "function" || !(completion instanceof Promise)) throw new TypeError("Event and native completion required");
|
||||
claim(event);
|
||||
if (events.has(event)) throw new Error("Event already registered");
|
||||
events.add(event); observe(completion);
|
||||
return event;
|
||||
},
|
||||
ownResource(resource, release) {
|
||||
ensureRunning();
|
||||
if (typeof release !== "function") throw new TypeError("Release function required");
|
||||
claim(resource);
|
||||
if (resources.has(resource)) throw new Error("Resource already registered");
|
||||
resources.set(resource, release);
|
||||
return resource;
|
||||
},
|
||||
requestStop() {
|
||||
if (state !== "running") return false;
|
||||
state = "stopping";
|
||||
// Only explicitly registered events. Do not erase global next/after or guess ownership.
|
||||
for (const event of events) {
|
||||
try { event.finish(); } catch (error) { errors.push(error); }
|
||||
}
|
||||
notify();
|
||||
return true;
|
||||
},
|
||||
async drain() {
|
||||
if (state === "running") throw new Error("requestStop required before drain");
|
||||
// Must be awaited by an external coordinator, not from a task tracked by this session.
|
||||
while (pending.size) await new Promise(resolve => waiters.add(resolve));
|
||||
if (errors.length) throw new AggregateError(errors, "Battle tasks failed; cleanup blocked");
|
||||
if (state === "stopping") state = "drained";
|
||||
},
|
||||
dispose() {
|
||||
if (state === "disposed") return Promise.resolve();
|
||||
if (disposePromise) return disposePromise;
|
||||
if (state !== "drained") return Promise.reject(new Error("Drain must complete before disposal"));
|
||||
state = "disposing";
|
||||
disposePromise = (async () => {
|
||||
// Reverse acquisition order; stop at first failure to preserve dependent resources.
|
||||
for (const [resource, release] of [...resources].reverse()) {
|
||||
await release(resource);
|
||||
resources.delete(resource); owners.delete(resource);
|
||||
}
|
||||
for (const event of events) owners.delete(event);
|
||||
events.clear(); state = "disposed";
|
||||
})().catch(error => { state = "drained"; throw error; }).finally(() => { disposePromise = null; });
|
||||
return disposePromise;
|
||||
},
|
||||
};
|
||||
return Object.freeze(api);
|
||||
}
|
||||
|
||||
// A reused ID must never cause old-session cleanup to delete the new player's entry.
|
||||
export function ownPlayerIndex(session, player, playerMap) {
|
||||
const id = player.playerid;
|
||||
if (!id || playerMap[id] !== player) throw new Error("Player must be registered first");
|
||||
return session.ownResource(player, () => { if (playerMap[id] === player) delete playerMap[id]; });
|
||||
}
|
||||
|
||||
// Engine pause booleans are not ownership tokens. Accept a lease from a coordinator instead.
|
||||
export function ownPauseLease(session, lease) {
|
||||
if (typeof lease?.release !== "function") throw new TypeError("Pause lease required");
|
||||
return session.ownResource(lease, () => lease.release());
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
// Candidate settlement adapter. Dependencies are the current mode/state reward functions.
|
||||
import { applyBattleEndRelics } from "../relics/battle.js";
|
||||
import { settleBondBattle } from "../bonds/state.js";
|
||||
import { prepareRewardPackage, applyRewardPackage }
|
||||
from "../progression/reward-package.js";
|
||||
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
const idFor = (run, node) => JSON.stringify([run.runId, run.actIndex, node.id]);
|
||||
export function createBattleSettlement({
|
||||
store, config, getRandomRewardChoices, applyReward, completeNode,
|
||||
enterNextAct, createRun, now = Date.now, logRewardPackage = () => {},
|
||||
}) {
|
||||
const readRun = () => store.read()[config.saveKey];
|
||||
function current(storage, runId) {
|
||||
const run = storage[config.saveKey];
|
||||
if (!run || run.runId !== runId) throw new Error("Stale run: settlement refused");
|
||||
run.battleFlow ||= { receipts: [], pending: null };
|
||||
return run;
|
||||
}
|
||||
function pending(storage, runId, id) {
|
||||
const run = current(storage, runId), item = run.battleFlow.pending;
|
||||
if (!item || item.id !== id) throw new Error("Settlement checkpoint mismatch");
|
||||
return {run, item};
|
||||
}
|
||||
return Object.freeze({
|
||||
readRun,
|
||||
// Persist fixed candidates before opening choice UI. No mutation of the live run.
|
||||
async prepare({run: snapshot, retryRun, node, encounter, hp, outcome = "victory"}) {
|
||||
if (!["victory", "defeat"].includes(outcome)) throw new Error("Unknown battle outcome");
|
||||
if (outcome === "victory" && (!Number.isFinite(hp) || (!encounter.rewardPackage && (!Number.isSafeInteger(encounter.gold) || encounter.gold < 0)))) throw new Error("Invalid battle result");
|
||||
const id = idFor(snapshot, node);
|
||||
return store.update(storage => {
|
||||
const run = current(storage, snapshot.runId);
|
||||
if (run.battleFlow.receipts.includes(id)) throw new Error("Battle already settled");
|
||||
if (run.battleFlow.pending) {
|
||||
if (run.battleFlow.pending.id !== id) throw new Error("Another settlement is pending");
|
||||
return run.battleFlow.pending;
|
||||
}
|
||||
if (run.actIndex !== snapshot.actIndex || run.revision !== snapshot.revision ||
|
||||
run.map?.nodes.find(n => n.id === node.id)?.completed !== false) {
|
||||
throw new Error("Stale node or revision");
|
||||
}
|
||||
// Battle may have changed RNG/card state since the last checkpoint.
|
||||
const base = copy(snapshot); delete base.battleFlow;
|
||||
const bondGrowth = settleBondBattle(base, node);
|
||||
if (outcome === "victory") {
|
||||
base.player.hp = Math.max(1, Math.min(hp, base.player.maxHp ?? hp));
|
||||
base.statistics.defeatedEnemies += encounter.defeatedEnemies ?? 1;
|
||||
}
|
||||
const relicRecovery = hp > 0
|
||||
? applyBattleEndRelics(base, outcome) : 0;
|
||||
const rewards = outcome === "victory" && !encounter.skipRandomReward ? getRandomRewardChoices(base, encounter.rewardPool).filter(c => c.name) : [];
|
||||
// Persist guaranteed gold alongside loot; award it once in the chosen result.
|
||||
const choices = outcome === "victory" && !encounter.rewardPackage
|
||||
? [{id:"mengsan.reward.gold.shuying", kind:"gold", name:"金币", amount:encounter.gold}, ...rewards] : [];
|
||||
const rewardPackage = outcome === "victory" && encounter.rewardPackage
|
||||
? prepareRewardPackage(base, encounter.rewardPackage,
|
||||
getRandomRewardChoices) : null;
|
||||
run.battleFlow.pending = {id, state:"awaitingChoice", nodeId:node.id, base, choices:copy(choices), fixedRewards:copy(encounter.fixedRewards || []), victoryDialogue:copy(encounter.victoryDialogue || []), boss:!!encounter.boss, outcome, relicRecovery, bondGrowth};
|
||||
run.battleFlow.pending.rewardPackage = copy(rewardPackage);
|
||||
if (outcome === "victory" && !rewardPackage) {
|
||||
run.battleFlow.pending.rewardMode = "one-or-skip";
|
||||
}
|
||||
if (outcome === "defeat") {
|
||||
const beforeBattle = retryRun || run;
|
||||
if (beforeBattle.runId !== run.runId ||
|
||||
beforeBattle.actIndex !== run.actIndex ||
|
||||
beforeBattle.revision !== run.revision) throw new Error("Stale retry checkpoint");
|
||||
run.battleFlow.pending.retryRun = copy(beforeBattle);
|
||||
run.battleFlow.pending.retryRun.battleFlow = {
|
||||
receipts:copy(run.battleFlow.receipts), pending:null,
|
||||
};
|
||||
run.battleFlow.pending.retryNode = copy(node);
|
||||
run.battleFlow.pending.retryEncounter = copy(encounter);
|
||||
}
|
||||
return run.battleFlow.pending;
|
||||
});
|
||||
},
|
||||
async choose(runId, id, choiceId) {
|
||||
return store.update(storage => {
|
||||
const {run, item} = pending(storage, runId, id);
|
||||
if (item.outcome === "defeat") {
|
||||
const action = typeof choiceId === "string" ? choiceId : choiceId?.action;
|
||||
if (!["retry", "new"].includes(action)) throw new Error("Invalid defeat action");
|
||||
if (item.failureAction) {
|
||||
if (item.failureAction !== action ||
|
||||
(action === "new" && item.choiceId.character !== choiceId.character)) {
|
||||
throw new Error("Defeat choice already locked");
|
||||
}
|
||||
return item;
|
||||
}
|
||||
if (action === "new") {
|
||||
if (!config.characters.includes(choiceId.character) || typeof createRun !== "function") {
|
||||
throw new Error("Invalid new journey character");
|
||||
}
|
||||
// Generate once in the chosen checkpoint; a commit retry must not reroll it.
|
||||
item.nextRun = createRun(choiceId.character);
|
||||
if (!item.nextRun || item.nextRun.status !== "running" || item.nextRun.runId === runId) {
|
||||
throw new Error("Invalid new journey");
|
||||
}
|
||||
item.result = copy(item.base);
|
||||
item.result.status = "failed";
|
||||
} else {
|
||||
// Old pending saves have no retryRun: retain their last successful save.
|
||||
item.result = copy(item.retryRun || run);
|
||||
item.result.status = "running";
|
||||
item.result.battleFlow = {receipts:copy(run.battleFlow.receipts), pending:null};
|
||||
item.retryNode ||= copy(run.map?.nodes.find(node => node.id === item.nodeId));
|
||||
if (!item.retryNode || item.retryNode.completed) throw new Error("Missing retry battle node");
|
||||
}
|
||||
item.state = "chosen"; item.choiceId = copy(choiceId);
|
||||
item.failureAction = action; item.route = action; item.completedAt = now();
|
||||
return item;
|
||||
}
|
||||
if (item.state === "chosen") {
|
||||
const sameChoice = item.rewardPackage
|
||||
? item.choiceId?.cardId === choiceId?.cardId &&
|
||||
item.choiceId?.relicId === choiceId?.relicId
|
||||
: item.choiceId === choiceId;
|
||||
if (!sameChoice) throw new Error("Choice already locked");
|
||||
return item;
|
||||
}
|
||||
const result = copy(item.base);
|
||||
let route = "defeat";
|
||||
if (item.outcome === "victory") {
|
||||
if (item.rewardPackage) {
|
||||
applyRewardPackage(result, item.rewardPackage, choiceId,
|
||||
applyReward);
|
||||
}
|
||||
if (!item.rewardPackage) {
|
||||
const reward = item.choices.find(c => c.id === choiceId && c.kind !== "gold");
|
||||
if (choiceId !== null && !reward) {
|
||||
throw new Error("Choose one pending reward or skip");
|
||||
}
|
||||
// This result is persisted before commit; retries never credit gold twice.
|
||||
for (const gold of item.choices.filter(c => c.kind === "gold")) {
|
||||
if (!Number.isSafeInteger(gold.amount) || gold.amount < 0) throw new Error("Invalid pending gold reward");
|
||||
result.player.gold += gold.amount;
|
||||
result.statistics.goldEarned += gold.amount;
|
||||
}
|
||||
if (reward) {
|
||||
applyReward(result, reward.effectId || reward.id);
|
||||
}
|
||||
for (const rewardId of item.fixedRewards || []) applyReward(result, rewardId);
|
||||
} else {
|
||||
for (const rewardId of item.fixedRewards || []) applyReward(result, rewardId);
|
||||
}
|
||||
if (!completeNode(result, item.nodeId)) throw new Error("Node completion failed");
|
||||
route = item.boss && !enterNextAct(result) ? "victory" : "map";
|
||||
} else result.status = "failed";
|
||||
// Save the exact result (including random card ID/target) before final commit.
|
||||
item.state = "chosen"; item.choiceId = choiceId; item.result = result;
|
||||
item.route = route; item.completedAt = now();
|
||||
if (item.rewardPackage && item.outcome === "victory") {
|
||||
logRewardPackage(item.rewardPackage, choiceId);
|
||||
}
|
||||
return item;
|
||||
});
|
||||
},
|
||||
async commit(runId, id) {
|
||||
return store.update(storage => {
|
||||
const saved = storage[config.saveKey];
|
||||
const prior = storage[config.profileKey]?.completedRuns?.find(r => r.runId === runId && r.settlementId === id);
|
||||
if (!saved && prior) return {route:prior.outcome, run:null, duplicate:true};
|
||||
if (saved?.runId === runId && saved.battleFlow?.receipts?.includes(id)) return {route:"map", run:saved, duplicate:true};
|
||||
const {run, item} = pending(storage, runId, id);
|
||||
if (item.state !== "chosen") throw new Error("Durable chosen result required");
|
||||
const result = copy(item.result);
|
||||
if (item.route === "retry") {
|
||||
// A failed attempt does not complete this node or add its victory receipt.
|
||||
result.battleFlow = {receipts:copy(run.battleFlow.receipts), pending:null,
|
||||
retry:{node:copy(item.retryNode), encounter:copy(item.retryEncounter || null)}};
|
||||
storage[config.saveKey] = result;
|
||||
return {route:"retry", run:result, retryNode:copy(item.retryNode),
|
||||
retryEncounter:copy(item.retryEncounter || null), duplicate:false};
|
||||
}
|
||||
result.battleFlow = {receipts:[...run.battleFlow.receipts, id], pending:null};
|
||||
if (item.route === "map") storage[config.saveKey] = result;
|
||||
else {
|
||||
const profile = storage[config.profileKey] ||= {wins:0, completedRuns:[]};
|
||||
profile.completedRuns ||= [];
|
||||
if (!profile.completedRuns.some(r => r.runId === runId)) {
|
||||
if (item.route === "victory") profile.wins = (profile.wins || 0) + 1;
|
||||
profile.completedRuns.push({runId, settlementId:id, outcome:item.route === "new" ? "defeat" : item.route, character:result.player.character,
|
||||
completedNodes:result.statistics.completedNodes, goldEarned:result.statistics.goldEarned, completedAt:item.completedAt});
|
||||
}
|
||||
if (item.route === "new") storage[config.saveKey] = copy(item.nextRun);
|
||||
else delete storage[config.saveKey]; // Same transaction as profile; never a second clear write.
|
||||
}
|
||||
return {route:item.route, run:item.route === "new" ? copy(item.nextRun) : result, duplicate:false};
|
||||
});
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
// 梦三独有的出牌经济,不修改 noname 的全局牌定义。
|
||||
import { isAttackCard } from "../monsters/vine-tangled.js";
|
||||
import { _status } from "../../../../noname.js";
|
||||
import { cardUpgradeLevel, cardUpgradeRule } from "../cards/upgrades.js";
|
||||
export const PLAYER_ENERGY = 3;
|
||||
export const PLAYER_HAND_LIMIT = 3;
|
||||
export const SHA_DAMAGE = 6;
|
||||
export const TRICK_DAMAGE = 4;
|
||||
|
||||
const COSTS = Object.freeze({ sha: 1, mengsan_zhongsha: 2, mengsan_fangyu: 1, mengsan_fennu: 0,
|
||||
mengsan_feijianhuixuanbiao: 1, mengsan_jianbingdaji: 1, mengsan_quanshenzhuangji: 1, mengsan_rongrongzhiquan: 1, mengsan_shandianpili: 1, mengsan_shuangchongdaji: 1, mengsan_tiezhanbo: 1, mengsan_touchui: 1, mengsan_tupo: 1, mengsan_yubeidaji: 1, mengsan_wanmeidaji: 2, mengsan_yujin: 2, mengsan_fangxue: 0, mengsan_jianyi: 1, mengsan_pomie: 1, mengsan_songjianwushi: 1,
|
||||
tao: 1, jiu: 1, shan: 0, wuxie: 0,
|
||||
juedou: 2, nanman: 2, wanjian: 2, taoyuan: 2 });
|
||||
|
||||
export const cardCost = (card, player = null) => {
|
||||
const rule = cardUpgradeLevel(card) ? cardUpgradeRule(card.name) : null;
|
||||
const base = rule?.cost ?? COSTS[card?.name] ?? 1;
|
||||
return base + (player?.storage?.mengsanTangled_shuying > 0 && isAttackCard(card) ? 1 : 0);
|
||||
};
|
||||
|
||||
export const isActiveCardUse = (event, player) => {
|
||||
if (!event || !player) return false;
|
||||
const seen = new Set();
|
||||
let inPhaseUse = false;
|
||||
for (let current = event; current && !seen.has(current); current = current.parent) {
|
||||
seen.add(current);
|
||||
if (current.name === "dying" || current.name === "respond" || current.name === "chooseToRespond") return false;
|
||||
if (current.name === "chooseToUse" && (current.respondTo || String(current.type || "").startsWith("respond"))) return false;
|
||||
if (current.name === "phaseUse" && current.player === player) inPhaseUse = true;
|
||||
}
|
||||
// 某些扩展创建的主动 useCard 事件不保留 phaseUse 父链。
|
||||
return inPhaseUse || (event.name === "useCard" && event.player === player &&
|
||||
_status.currentPhase === player);
|
||||
};
|
||||
|
||||
// 仅授权破灭的这一条原生选择/使用父链及同一张实体牌;副本和其他使用不免费。
|
||||
const freeUses = new WeakMap();
|
||||
export function authorizeFreeCardUse(player, card, choice, valid) {
|
||||
const entries = freeUses.get(player) || new Set();
|
||||
freeUses.set(player, entries);
|
||||
const entry = { card, choice, valid }; entries.add(entry);
|
||||
return () => { entries.delete(entry); if (!entries.size) freeUses.delete(player); };
|
||||
}
|
||||
function isFreeCardUse(player, card, event) {
|
||||
for (const entry of freeUses.get(player) || []) {
|
||||
if (!entry.valid() || card?.name !== entry.card.name ||
|
||||
!(card === entry.card || card?.cards?.includes(entry.card))) continue;
|
||||
const seen = new Set();
|
||||
for (let current = event; current && !seen.has(current); current = current.parent) {
|
||||
seen.add(current);
|
||||
if (current.name === "useCard" && (current.player !== player ||
|
||||
current.cards?.length !== 1 || current.cards[0] !== entry.card)) break;
|
||||
if (current === entry.choice) return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
export const canPayCard = (player, card, event = _status.event) =>
|
||||
isFreeCardUse(player, card, event) || (player?.storage?.mengsanEnergy_shuying ?? Infinity) >= cardCost(card, player);
|
||||
|
||||
export const payCard = (player, card, event = _status.event) => {
|
||||
if (isFreeCardUse(player, card, event)) return true;
|
||||
if (!canPayCard(player, card, event)) return false;
|
||||
player.storage.mengsanEnergy_shuying -= cardCost(card, player);
|
||||
return true;
|
||||
};
|
||||
@@ -0,0 +1,38 @@
|
||||
import {
|
||||
attackHitCount,
|
||||
outgoingAttackDamage,
|
||||
} from "./intent-damage.js";
|
||||
|
||||
const pendingDeathBlows = new WeakSet();
|
||||
|
||||
export function isDeathBlowIntent(intent) {
|
||||
return intent?.intentType === "death_blow";
|
||||
}
|
||||
|
||||
export function hasPendingDeathBlow(source) {
|
||||
return pendingDeathBlows.has(source);
|
||||
}
|
||||
|
||||
export async function beginDeathBlow(source, target, intent) {
|
||||
if (!isDeathBlowIntent(intent)) {
|
||||
throw new TypeError("濒死一击需要 death_blow 意图类型");
|
||||
}
|
||||
if (attackHitCount(intent) !== 1) {
|
||||
throw new RangeError("濒死一击只能造成一次伤害");
|
||||
}
|
||||
const damage = outgoingAttackDamage(intent, source);
|
||||
if (!source?.isAlive() || !target?.isAlive()) return false;
|
||||
|
||||
const hit = target.damage(damage, source);
|
||||
hit.mengsanAttack_shuying = true;
|
||||
await hit;
|
||||
if (source.isAlive()) pendingDeathBlows.add(source);
|
||||
return true;
|
||||
}
|
||||
|
||||
export async function finishDeathBlow(source) {
|
||||
if (!hasPendingDeathBlow(source)) return false;
|
||||
pendingDeathBlows.delete(source);
|
||||
if (source.isAlive()) await source.die();
|
||||
return true;
|
||||
}
|
||||