344 lines
20 KiB
JavaScript
344 lines
20 KiB
JavaScript
// ui/gameLogic/bonds.js — bond counts, members, harmony, 本局禁用. Re-exported from ../gameLogic.js.
|
|
|
|
import { int, isObj } from './shared.js';
|
|
import { diyPicks } from './diy.js';
|
|
import { t } from '../../../../shared/i18n.js';
|
|
|
|
|
|
// ---- bonds -------------------------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Sort bonds for the strip: active first, then layers desc, count desc, tier desc, core first, id; the mode-off bonds
|
|
* (`off`: the server's entries for the bonds this mode never activates that the player has members of —
|
|
* server/match/bondsMeta.js offBondCounts) after all the others.
|
|
* @template {{bondId:string, active?:boolean, layers?:number, count?:number, tier?:number, off?:boolean}} B
|
|
* @param {B[]} bonds
|
|
* @param {(id:string)=>any} [getBond]
|
|
* @returns {B[]}
|
|
*/
|
|
export function sortBonds(bonds, getBond = () => null) {
|
|
const list = (Array.isArray(bonds) ? bonds : []).filter((b) => isObj(b) && typeof b.bondId === 'string');
|
|
const n = (v) => (Number.isFinite(v) ? v : 0);
|
|
return [...list].sort((a, b) => (
|
|
(a.off ? 1 : 0) - (b.off ? 1 : 0)
|
|
|| (b.active ? 1 : 0) - (a.active ? 1 : 0)
|
|
|| n(b.layers) - n(a.layers)
|
|
|| n(b.count) - n(a.count)
|
|
|| n(b.tier) - n(a.tier)
|
|
|| (getBond(b.bondId)?.isCore ? 1 : 0) - (getBond(a.bondId)?.isCore ? 1 : 0)
|
|
|| (a.bondId < b.bondId ? -1 : a.bondId > b.bondId ? 1 : 0)
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Tier reached for a member count against ascending thresholds (downward bonds: active while count ≤ max).
|
|
* @param {number} count
|
|
* @param {number[]} thresholds
|
|
* @param {number|null} [maxCount]
|
|
*/
|
|
export function bondTier(count, thresholds, maxCount = null) {
|
|
const c = Number.isFinite(count) ? count : 0;
|
|
if (Number.isFinite(maxCount) && c > maxCount) return 0;
|
|
let t = 0;
|
|
for (const th of Array.isArray(thresholds) ? thresholds : []) if (c >= th) t += 1;
|
|
return t;
|
|
}
|
|
|
|
/** Next threshold above the count, or null when maxed. */
|
|
export function nextThreshold(count, thresholds) {
|
|
for (const th of Array.isArray(thresholds) ? thresholds : []) if (count < th) return th;
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Bonds granted by 变形同构体: an item with `canGiveBond` worn together with an item that has a `giveBondId` makes the
|
|
* wearer a member of that other item's bond (band 变形者集群 "与特定装备一同装备时装备者将视为特定盟约成员"; the item's
|
|
* talent, character_table trap_1073_acarm073, lists the 14 pairings). The same rule as the server's count
|
|
* (server/match/bondsMeta.js pieceBonds) and the battle's (server/sim/content/support unitBonds).
|
|
* @param {Array<string|{id:string}>|null|undefined} items the carried items (ids or { id } pieces)
|
|
* @param {(id:string)=>any} [getItem] items.json lookup
|
|
* @returns {string[]}
|
|
*/
|
|
export function grantedBonds(items, getItem = () => null) {
|
|
const list = Array.isArray(items) ? items : [];
|
|
if (list.length < 2) return [];
|
|
const recs = list.map((it) => getItem(typeof it === 'string' ? it : it?.id)).filter(isObj);
|
|
if (!recs.some((r) => r.canGiveBond)) return [];
|
|
const out = [];
|
|
for (const r of recs) if (!r.canGiveBond && typeof r.giveBondId === 'string' && r.giveBondId && !out.includes(r.giveBondId)) out.push(r.giveBondId);
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* A chess piece's bonds: its record's + those its 变形同构体 pairing grants (grantedBonds) — the detail card's chips.
|
|
* @param {any} chess chess.json record @param {Array<string|{id:string}>|null|undefined} items @param {(id:string)=>any} [getItem]
|
|
* @returns {string[]}
|
|
*/
|
|
export function pieceBondIds(chess, items, getItem = () => null) {
|
|
const out = (Array.isArray(chess?.bonds) ? chess.bonds : []).filter((b) => typeof b === 'string');
|
|
for (const b of grantedBonds(items, getItem)) if (!out.includes(b)) out.push(b);
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* The 变形同构体 pairings — the list its 天赋栏 shows (the item text: "具体对应关系可在模拟中查看本装备天赋栏"; character_table
|
|
* trap_1073_acarm073 "“炎国短刀”→【炎】盟约 …", 14 bonds; GitHub issue #1: without it the item read as doing nothing).
|
|
* Built from the same `giveBondId` the server counts with (server/match/bondsMeta.js pieceBonds, grantedBonds here): every
|
|
* bond an item grants, in bonds.json order, with the items that grant it (one entry per item family — the normal and 进阶
|
|
* copies share a name —, by tier, then data order). `off`: the mode never activates the bond (modeOffBonds: 本局禁用 — 标准
|
|
* leaves 5 of the 14 off). `worn`: the wearer's items (`carried`, the card shows the 变形同构体 on an operator) pair it with
|
|
* one of the bond's items — the pairing in effect on that operator (that item `worn` too).
|
|
* @param {Iterable<any>} itemRecs items.json records (data.list('items'))
|
|
* @param {Iterable<any>} bondRecs bonds.json records in data order (data.list('bonds'))
|
|
* @param {{ off?: Set<string>|null, carried?: Array<string|{id:string}>|null }} [opts]
|
|
* @returns {Array<{ bondId: string, name: string, off: boolean, worn: boolean, items: Array<{ id: string, name: string, worn: boolean }> }>}
|
|
*/
|
|
export function morphPairings(itemRecs, bondRecs, { off = null, carried = null } = {}) {
|
|
const recs = [...(itemRecs || [])].filter(isObj);
|
|
const byId = new Map(recs.map((r) => [r.id, r]));
|
|
const getItem = (id) => byId.get(id) || null;
|
|
const worn = new Set(grantedBonds(carried, getItem));
|
|
const carriedIds = new Set((Array.isArray(carried) ? carried : []).map((it) => (typeof it === 'string' ? it : it?.id)).filter((x) => typeof x === 'string'));
|
|
const famOf = (r) => (typeof r.baseId === 'string' && r.baseId ? r.baseId : r.id);
|
|
/** bondId → family id → { id, name, tier, order, ids } */
|
|
const groups = new Map();
|
|
recs.forEach((r, order) => {
|
|
if (r.canGiveBond || typeof r.giveBondId !== 'string' || !r.giveBondId) return;
|
|
let g = groups.get(r.giveBondId);
|
|
if (!g) groups.set(r.giveBondId, (g = new Map()));
|
|
const fam = famOf(r);
|
|
const e = g.get(fam);
|
|
if (e) { e.ids.push(r.id); return; }
|
|
g.set(fam, { id: fam, name: typeof r.name === 'string' && r.name ? r.name : fam, tier: int(r.tier, 99), order, ids: [r.id] });
|
|
});
|
|
const out = [];
|
|
for (const b of bondRecs || []) {
|
|
const g = isObj(b) ? groups.get(b.bondId) : null;
|
|
if (!g) continue;
|
|
const bondWorn = worn.has(b.bondId);
|
|
const items = [...g.values()].sort((x, y) => (x.tier - y.tier) || (x.order - y.order))
|
|
.map((e) => ({ id: e.id, name: e.name, worn: bondWorn && e.ids.some((id) => carriedIds.has(id)) }));
|
|
out.push({ bondId: b.bondId, name: typeof b.name === 'string' && b.name ? b.name : b.bondId, off: !!(off && typeof off.has === 'function' && off.has(b.bondId)), worn: bondWorn, items });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Bond id of 调和 (bonds.json maniShip, "激活时使场上核心盟约的激活人数+1") — server/match/bondsMeta.js HARMONY_BOND; a test
|
|
* pins the two. Only to name the 调和 operators: whether a bond's count holds the +1 is the server's word (the view
|
|
* entry's `harmony`, DESIGN §21.26).
|
|
*/
|
|
export const HARMONY_BOND = 'maniShip';
|
|
|
|
/**
|
|
* The 调和 operators on a board, distinct (normal and elite copies of one operator once): who activates the +1 a bond
|
|
* entry's `harmony` reports (the bond popup's 调和 row names them — 缪尔赛思, the Pith strategy's 盟约·辅助干员).
|
|
* @param {any} priv m.private — or a teammate's field operators (ui/watchBonds.js ownerBoard)
|
|
* @param {(id:string)=>any} [getChess]
|
|
* @returns {Array<{ id: string, name: string }>} base chess ids
|
|
*/
|
|
export function harmonyMembers(priv, getChess = () => null) {
|
|
const out = [];
|
|
const seen = new Set();
|
|
for (const p of Array.isArray(priv?.board) ? priv.board : []) {
|
|
if (p?.kind !== 'chess') continue;
|
|
const c = getChess(p.id);
|
|
if (!Array.isArray(c?.bonds) || !c.bonds.includes(HARMONY_BOND)) continue;
|
|
const base = c.baseId || (typeof p.id === 'string' ? p.id.replace(/_b$/, '_a') : p.id);
|
|
if (seen.has(base)) continue;
|
|
seen.add(base);
|
|
out.push({ id: base, name: getChess(base)?.name || c.name || base });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Member rows of a bond popup: every visible member with owned / on-board / in-hand / banned state, plus the player's
|
|
* operators that are members through 变形同构体 (grantedBonds; `granted: true` and `items`: the item ids of the copy that
|
|
* wears the pair — the card the row opens shows them; one row per operator — normal and elite copies are one member,
|
|
* like the count's distinct members), so "成员 x/y" agrees with the count the server reports (在场; memberHeadCount).
|
|
* 0.2.0 自选编队: the 自选 pieces of the bond (a DIY slot filled with an operator, whose bonds come from its factions — the
|
|
* own pieces through `getChess` (gameLogic/diy.js diyGetter), a teammate's through `pieceRecord` (its UnitInfo `diy`
|
|
* pick) are rows too (`diy: true`, the operator's name and record `rec`: its normal form, one row per slot like a
|
|
* member's; `pick`: a teammate's piece's pick — the card the row opens composes the operator from it). Since 0.2.1
|
|
* (the owner's report of 2026-10-07 「自选编队的干员在局内对应盟约展开的名单里没有显示出来」) every 自选 pick of the
|
|
* player (m.private.diy: the V and VI slots) is a row of each bond its operator carries, owned or not — an unowned one
|
|
* (not bought, or not in the shop yet: the slot's 调度中心 level) dimmed like an unowned member, one whose bonds are all
|
|
* off this match (m.private.diyBanned: no stock, it never shows in the shop) `banned` like a banned member. A
|
|
* teammate's board carries no picks (m.public sends none): their 自选 pieces on the field only.
|
|
* `inHand`: in the 整备区 (hand), not the 5 temporary slots — what BOARD_AND_DECK bonds (投资人 远见 奇迹) count.
|
|
* @param {any} bond bonds.json record
|
|
* @param {any} priv m.private (hand/board/temp, the 自选 picks `diy` / `diyBanned`) — or a teammate's field operators
|
|
* (ui/watchBonds.js ownerBoard)
|
|
* @param {Set<string>|string[]} [banned] banned base chess ids
|
|
* @param {(id:string)=>any} [getChess]
|
|
* @param {(id:string)=>any} [getItem] items.json lookup (the 变形同构体 pairings)
|
|
* @param {((p: any) => any)|null} [pieceRecord] the record of one of the pieces (default: getChess(p.id))
|
|
*/
|
|
export function bondMembers(bond, priv, banned = [], getChess = () => null, getItem = () => null, pieceRecord = null) {
|
|
const bannedSet = banned instanceof Set ? banned : new Set(Array.isArray(banned) ? banned : []);
|
|
const members = Array.isArray(bond?.visibleMembers) && bond.visibleMembers.length ? bond.visibleMembers : (Array.isArray(bond?.members) ? bond.members : []);
|
|
const baseOf = (id) => getChess(id)?.baseId || (typeof id === 'string' ? id.replace(/_b$/, '_a') : id);
|
|
const onBoard = new Set();
|
|
const owned = new Set();
|
|
const inHand = new Set();
|
|
const memberSet = new Set(members);
|
|
/** base id → { on: on the board?, hand: in the hand?, items: the wearer's item ids } — operators of the player that join this bond through 变形同构体 */
|
|
const granted = new Map();
|
|
const grants = (p) => typeof bond?.bondId === 'string' && grantedBonds(p.items, getItem).includes(bond.bondId);
|
|
const recOf = (p) => (pieceRecord ? pieceRecord(p) : getChess(p.id));
|
|
/** a composed 自选 record whose operator carries this bond */
|
|
const diyOfBond = (rec) => isObj(rec) && typeof rec.diyFor === 'string' && Array.isArray(rec.bonds) && rec.bonds.includes(bond?.bondId);
|
|
/** slot base id → { on, hand, owned, rec, pick } — the player's 自选 pieces and picks whose operator carries this bond */
|
|
const diy = new Map();
|
|
const diyOf = (p, on, hand) => {
|
|
const rec = recOf(p);
|
|
if (!diyOfBond(rec)) return false;
|
|
const g = diy.get(rec.diyFor);
|
|
if (g) { g.on = g.on || on; g.hand = g.hand || hand; return true; }
|
|
// the row draws the normal form, as a member row its base chess (an elite copy is the same member)
|
|
const pick = isObj(p.diy) && typeof p.diy.charId === 'string' ? p.diy : null;
|
|
const normal = rec.isGolden ? recOf(pick ? { kind: 'chess', id: rec.diyFor, diy: pick } : { kind: 'chess', id: rec.diyFor }) : rec;
|
|
diy.set(rec.diyFor, { on, hand, owned: true, rec: diyOfBond(normal) && normal.diyFor === rec.diyFor ? normal : rec, pick });
|
|
return true;
|
|
};
|
|
const itemIds = (p) => p.items.map((it) => (typeof it === 'string' ? it : it?.id)).filter((x) => typeof x === 'string');
|
|
for (const p of Array.isArray(priv?.board) ? priv.board : []) {
|
|
if (p?.kind !== 'chess') continue;
|
|
const base = baseOf(p.id);
|
|
onBoard.add(base); owned.add(base);
|
|
if (diyOf(p, true, false)) continue;
|
|
if (!memberSet.has(base) && !granted.has(base) && grants(p)) granted.set(base, { on: true, hand: false, items: itemIds(p) });
|
|
}
|
|
for (const [list, hand] of [[priv?.hand, true], [priv?.temp, false]]) {
|
|
for (const p of Array.isArray(list) ? list : []) {
|
|
if (p?.kind !== 'chess') continue;
|
|
const base = baseOf(p.id);
|
|
owned.add(base);
|
|
if (hand) inHand.add(base);
|
|
if (diyOf(p, false, hand)) continue;
|
|
if (memberSet.has(base) || !grants(p)) continue;
|
|
const g = granted.get(base);
|
|
if (!g) granted.set(base, { on: false, hand, items: itemIds(p) });
|
|
else if (hand) g.hand = true;
|
|
}
|
|
}
|
|
// the player's picks not owned (the slot's record through the own getter: gameLogic/diy.js diyGetter) — rows like an
|
|
// unowned member's (counted by neither 在场 nor the 成员 header)
|
|
for (const slotId of Object.keys(diyPicks(priv))) {
|
|
if (diy.has(slotId)) continue;
|
|
const rec = recOf({ kind: 'chess', id: slotId });
|
|
if (diyOfBond(rec) && rec.diyFor === slotId) diy.set(slotId, { on: false, hand: false, owned: false, rec, pick: null });
|
|
}
|
|
const diyBanned = new Set(Array.isArray(priv?.diyBanned) ? priv.diyBanned : []);
|
|
const rows = members.map((id) => {
|
|
const c = getChess(id);
|
|
return { id, tier: c?.tier ?? 0, name: c?.name ?? id, onBoard: onBoard.has(id), owned: owned.has(id), inHand: inHand.has(id), banned: bannedSet.has(id) };
|
|
});
|
|
for (const [id, g] of granted) {
|
|
const c = getChess(id);
|
|
rows.push({ id, tier: c?.tier ?? 0, name: c?.name ?? id, onBoard: g.on, owned: true, inHand: g.hand, banned: false, granted: true, items: g.items });
|
|
}
|
|
for (const [id, g] of diy) {
|
|
rows.push({ id, tier: g.rec.tier ?? 0, name: g.rec.name ?? id, onBoard: g.on, owned: g.owned, inHand: g.hand, banned: bannedSet.has(id) || diyBanned.has(id), diy: true, rec: g.rec, ...(g.pick ? { pick: g.pick } : {}) });
|
|
}
|
|
return rows.sort((a, b) => (b.onBoard - a.onBoard) || (b.owned - a.owned) || (a.tier - b.tier) || (a.id < b.id ? -1 : 1));
|
|
}
|
|
|
|
/**
|
|
* The member count of a bond popup's 成员 header: the rows on the board — and, for a bond that counts the hand
|
|
* (`countsHand`: BOARD_AND_DECK — 投资人 远见 奇迹; the server's 在场 says （含整备区）), those in the hand too (the 5
|
|
* temporary slots never count), so the header agrees with 在场 (community report 「投资人等在休整区就能生效的盟约不生效」:
|
|
* the header said 0/n with the members in the hand while 在场 said 3/3).
|
|
* @param {Array<{ onBoard?: boolean, inHand?: boolean }>} rows bondMembers rows @param {boolean} [countsHand]
|
|
* @returns {number}
|
|
*/
|
|
export function memberHeadCount(rows, countsHand = false) {
|
|
let n = 0;
|
|
for (const r of Array.isArray(rows) ? rows : []) if (r && (r.onBoard || (countsHand && r.inHand))) n++;
|
|
return n;
|
|
}
|
|
|
|
/**
|
|
* Banned-member count per bond (briefing / info drawer red badge).
|
|
* @param {any[]} bonds bonds.json records
|
|
* @param {string[]} bannedChess
|
|
* @returns {Map<string, number>}
|
|
*/
|
|
export function bannedPerBond(bonds, bannedChess) {
|
|
const banned = new Set(Array.isArray(bannedChess) ? bannedChess : []);
|
|
const out = new Map();
|
|
for (const b of Array.isArray(bonds) ? bonds : []) {
|
|
if (!isObj(b)) continue;
|
|
const members = Array.isArray(b.visibleMembers) ? b.visibleMembers : [];
|
|
out.set(b.bondId, members.filter((id) => banned.has(id)).length);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* The two kinds of greyed bonds of a match (research 01 A2, 06 addendum D):
|
|
* drawn — the per-match drawn set D (m.public drawnDisabledBonds): only operators whose EVERY bond is in D leave
|
|
* the pool, so these bonds stay activatable (multi-bond members, 变形同构体, 调和) — "部分盟约所含干员阵容不完整";
|
|
* off — the mode's static inactive list (FUNNY): never activates this match — "本局禁用".
|
|
* Older payloads without drawnDisabledBonds: disabledBonds minus the static list.
|
|
* @param {any} pub m.public
|
|
* @param {string[]} [staticInactive] config.modes[modeId].inactiveBondIds
|
|
* @returns {{ drawn: Set<string>, off: Set<string> }}
|
|
*/
|
|
export function disabledBondSets(pub, staticInactive = []) {
|
|
const off = new Set(Array.isArray(staticInactive) ? staticInactive : []);
|
|
const src = Array.isArray(pub?.drawnDisabledBonds) ? pub.drawnDisabledBonds : Array.isArray(pub?.disabledBonds) ? pub.disabledBonds : [];
|
|
const drawn = new Set(src.filter((b) => typeof b === 'string' && !off.has(b)));
|
|
return { drawn, off };
|
|
}
|
|
|
|
/**
|
|
* Briefing tooltip of a bond disc.
|
|
* @param {string} name
|
|
* @param {'off'|'drawn'|null} state from disabledBondSets
|
|
* @param {number} bannedN banned operators of the bond
|
|
*/
|
|
export function briefingBondTip(name, state, bannedN = 0) {
|
|
if (state === 'off') return t('{name}：本局禁用（该盟约不会激活）', { name });
|
|
if (state === 'drawn' || bannedN > 0) return bannedN ? t('{name}：部分盟约所含干员阵容不完整（{bannedN} 名干员无法出现）', { name, bannedN }) : t('{name}：部分盟约所含干员阵容不完整', { name });
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* The bonds a mode never activates (config.json modes[modeId].inactiveBondIds = the official modeDataDict
|
|
* inactiveBondIdList: 标准模拟 leaves 拉特兰 阿戈尔 卡西米尔 灵巧 奥术 奇迹 投资人 突袭 独行 绝技 off). Operators that also carry an
|
|
* enabled bond stay in the pool (server pool.js drawDisabledBonds) — 标准's 深靛 洛洛 阿罗玛 夕 圣聆初雪 still show 奥术 — and
|
|
* the server left such a bond out of m.private.bonds, so without a mark a card read "奥术 0/2 未激活" with three 奥术
|
|
* operators deployed (player report after 0.1.0: "奥术盟约不生效"). The shop / reward cards, the detail card's bond chips
|
|
* and the bond popup mark these 本局禁用 (briefingBondTip 'off'); since 0.1.3 the server also lists such a bond the player
|
|
* has members of (`off: true`, server/match/bondsMeta.js offBondCounts) and the strip shows it as a grey 本局禁用 disc.
|
|
* @param {any} mode config.json modes[modeId] (data.js getMode), or null
|
|
* @returns {Set<string>}
|
|
*/
|
|
export function modeOffBonds(mode) {
|
|
const list = isObj(mode) && Array.isArray(mode.inactiveBondIds) ? mode.inactiveBondIds : [];
|
|
return new Set(list.filter((b) => typeof b === 'string'));
|
|
}
|
|
|
|
/**
|
|
* The bonds a strategy is built around that this mode switches off: bands.json `bondIds` (shared/bandBonds.js at build
|
|
* time — the field the server's bot reads too, GameData.bandBondIds) ∩ `off` (modeOffBonds). 标准: 潘格尼尼 → 拉特兰,
|
|
* 克莱门莎 → 阿戈尔, 玛恩纳 → 卡西米尔; the strategy draft marks such a band 本局禁用 (still selectable, DESIGN §21.26).
|
|
* @param {any} band bands.json record @param {Set<string>|null} off
|
|
* @returns {string[]}
|
|
*/
|
|
export function bandOffBonds(band, off) {
|
|
if (!(off instanceof Set) || !off.size || !Array.isArray(band?.bondIds)) return [];
|
|
return band.bondIds.filter((b) => typeof b === 'string' && off.has(b));
|
|
}
|
|
|
|
/**
|
|
* The strategy draft's note for such a band: "本局禁用【拉特兰】盟约，此策略效果可能无法发挥".
|
|
* @param {string[]} names the switched-off bonds' names
|
|
*/
|
|
export function bandOffLine(names) {
|
|
const list = (Array.isArray(names) ? names : []).filter((n) => typeof n === 'string' && n);
|
|
return list.length ? t('本局禁用{names}盟约，此策略效果可能无法发挥', { names: list.map((n) => t('【{name}】', { name: n })).join('') }) : '';
|
|
}
|