hrbattle 0.1.0

package/dist/battle/effectSystem.js

@@ -0,0 +1,175 @@
+const FOREVER = 999999999;
+const SKIP_ROUND_END = new Set([-999, -99999999]);
+export class EffectSystem {
+    eventBus;
+    buffs = new Map();
+    buffConfigs = new Map();
+    constructor(eventBus) {
+        this.eventBus = eventBus;
+    }
+    registerBuffConfigs(configs) {
+        for (const config of configs) {
+            this.buffConfigs.set(config.id, config);
+        }
+    }
+    getBuffs(unitId) {
+        return this.buffs.get(unitId) ?? [];
+    }
+    getBuffConfigs() {
+        return [...this.buffConfigs.values()];
+    }
+    hasBuff(unitId, buffId) {
+        return this.getBuffs(unitId).some((b) => b.id === buffId && b.stacks > 0);
+    }
+    getEffectiveStats(unit) {
+        const buffs = this.getBuffs(unit.id);
+        const stat = { ...unit.stats };
+        for (const buff of buffs) {
+            const stacks = Math.max(1, buff.stacks);
+            const cfg = buff.config;
+            if (cfg.speedRateDelta) {
+                stat.Spd = Math.max(1, Math.floor((stat.Spd * (10000 + cfg.speedRateDelta * stacks)) / 10000));
+            }
+            if (cfg.effectResDelta) {
+                stat.pERes += cfg.effectResDelta * stacks;
+            }
+            if (cfg.energyRecoveryRateDelta) {
+                stat.pER += cfg.energyRecoveryRateDelta * stacks;
+            }
+            if (cfg.attackRateDelta) {
+                stat.Att = Math.max(1, Math.floor((stat.Att * (10000 + cfg.attackRateDelta * stacks)) / 10000));
+            }
+            if (cfg.defenseRateDelta) {
+                stat.Def = Math.max(1, Math.floor((stat.Def * (10000 + cfg.defenseRateDelta * stacks)) / 10000));
+            }
+            if (cfg.critRateDelta) {
+                stat.pCTR += cfg.critRateDelta * stacks;
+            }
+            if (cfg.critDamageDelta) {
+                stat.pCTD += cfg.critDamageDelta * stacks;
+            }
+            if (cfg.healEffectDelta) {
+                stat.pHE += cfg.healEffectDelta * stacks;
+            }
+            if (cfg.effectHitDelta) {
+                stat.pEHR += cfg.effectHitDelta * stacks;
+            }
+            if (cfg.damageRateDelta) {
+                stat.pBSDI += cfg.damageRateDelta * stacks;
+                stat.pESDI += cfg.damageRateDelta * stacks;
+                stat.pFSDI += cfg.damageRateDelta * stacks;
+            }
+            if (cfg.vulnerabilityDelta) {
+                stat.pVulnerability += cfg.vulnerabilityDelta * stacks;
+            }
+            if (cfg.imbalanceRateDelta) {
+                stat.pIM += cfg.imbalanceRateDelta * stacks;
+            }
+        }
+        return stat;
+    }
+    addBuff(owner, sourceId, buffId) {
+        const cfg = this.buffConfigs.get(buffId);
+        if (!cfg) {
+            return;
+        }
+        const list = this.buffs.get(owner.id) ?? [];
+        const existing = list.find((b) => b.id === buffId);
+        if (existing) {
+            if (cfg.maxStacks !== FOREVER) {
+                existing.stacks = Math.min(cfg.maxStacks, existing.stacks + 1);
+            }
+            else {
+                existing.stacks += 1;
+            }
+            if (cfg.durationPerStack !== FOREVER) {
+                existing.remainingRounds = Math.max(existing.remainingRounds, cfg.durationPerStack);
+            }
+        }
+        else {
+            const instance = {
+                id: buffId,
+                ownerId: owner.id,
+                stacks: 1,
+                remainingRounds: cfg.durationPerStack,
+                config: cfg,
+                sourceId
+            };
+            list.push(instance);
+            this.buffs.set(owner.id, list);
+        }
+        if (cfg.stun) {
+            owner.runtime.stunned = true;
+        }
+        this.eventBus.emit({ name: "OnBuffAdd", payload: { ownerId: owner.id, buffId } });
+    }
+    removeBuff(owner, buffId) {
+        const list = this.getBuffs(owner.id);
+        const next = list.filter((b) => b.id !== buffId);
+        this.buffs.set(owner.id, next);
+        this.eventBus.emit({ name: "OnBuffRemove", payload: { ownerId: owner.id, buffId } });
+        this.recomputeStates(owner);
+    }
+    onTurnStart(owner, allUnits) {
+        const dotEvents = [];
+        for (const buff of this.getBuffs(owner.id)) {
+            if (buff.config.dotRatio && buff.stacks > 0) {
+                const dot = Math.floor(owner.stats.Att * buff.config.dotRatio * buff.stacks);
+                if (dot > 0) {
+                    dotEvents.push({
+                        targetId: owner.id,
+                        value: dot,
+                        buffId: buff.id,
+                        element: buff.config.dotElement
+                    });
+                }
+            }
+            if (buff.config.taunt) {
+                this.forceTauntPosition(owner, allUnits);
+            }
+        }
+        this.recomputeStates(owner);
+        return dotEvents;
+    }
+    onTurnEnd(owner, allUnits) {
+        const list = this.getBuffs(owner.id);
+        for (const buff of list) {
+            if (SKIP_ROUND_END.has(buff.config.onRoundEndDelta)) {
+                continue;
+            }
+            if (buff.config.onRoundEndDelta === -1) {
+                buff.stacks = Math.max(0, buff.stacks - 1);
+            }
+            if (buff.remainingRounds !== FOREVER) {
+                buff.remainingRounds = Math.max(0, buff.remainingRounds - 1);
+            }
+        }
+        this.cleanup(owner);
+        this.recomputeStates(owner);
+        this.tryReposition(owner, allUnits);
+    }
+    cleanup(owner) {
+        const list = this.getBuffs(owner.id).filter((b) => b.stacks > 0 && (b.remainingRounds > 0 || b.remainingRounds === FOREVER));
+        this.buffs.set(owner.id, list);
+    }
+    recomputeStates(owner) {
+        owner.runtime.stunned = this.getBuffs(owner.id).some((b) => b.config.stun);
+    }
+    forceTauntPosition(owner, allUnits) {
+        const allies = allUnits.filter((u) => u.teamId === owner.teamId && u.runtime.alive).sort((a, b) => a.position - b.position);
+        allies.forEach((unit, index) => {
+            unit.position = (index + 1);
+        });
+    }
+    tryReposition(owner, allUnits) {
+        if (!owner.runtime.stunned) {
+            return;
+        }
+        const allies = allUnits.filter((u) => u.teamId === owner.teamId && u.runtime.alive).sort((a, b) => a.position - b.position);
+        const withoutOwner = allies.filter((u) => u.id !== owner.id);
+        const merged = [...withoutOwner, owner];
+        merged.forEach((unit, index) => {
+            unit.position = (index + 1);
+        });
+    }
+}

package/dist/battle/eventBus.d.ts

@@ -0,0 +1,8 @@
+import type { BattleEvent, BattleEventName } from "./types";
+type EventHandler<T> = (payload: T) => void;
+export declare class BattleEventBus {
+    private handlers;
+    on<T>(name: BattleEventName, handler: EventHandler<T>, priority?: number): () => void;
+    emit<T>(event: BattleEvent<T>): void;
+}
+export {};

package/dist/battle/eventBus.js

@@ -0,0 +1,20 @@
+export class BattleEventBus {
+    handlers = new Map();
+    on(name, handler, priority = 0) {
+        const list = this.handlers.get(name) ?? [];
+        const record = { priority, handler: handler };
+        list.push(record);
+        list.sort((a, b) => b.priority - a.priority);
+        this.handlers.set(name, list);
+        return () => {
+            const current = this.handlers.get(name) ?? [];
+            this.handlers.set(name, current.filter((item) => item !== record));
+        };
+    }
+    emit(event) {
+        const list = this.handlers.get(event.name) ?? [];
+        for (const item of list) {
+            item.handler(event.payload);
+        }
+    }
+}

package/dist/battle/formula.d.ts

@@ -0,0 +1,19 @@
+import type { ElementType, SkillType, UnitModel } from "./types";
+import { SeedRng } from "./random";
+export interface DamageResult {
+    finalDam: number;
+    baseDam: number;
+    critDam: number;
+    isCritical: boolean;
+    isRepression: -1 | 0 | 1;
+}
+export declare function repression(attackerElement: ElementType, defenderElement: ElementType): -1 | 0 | 1;
+export declare function calcDamage(attacker: UnitModel, defender: UnitModel, dam: number, type: SkillType, elem: ElementType, rng: SeedRng): DamageResult;
+export interface HealShieldResult {
+    finalValue: number;
+    baseValue: number;
+    critValue: number;
+    isCritical: boolean;
+}
+export declare function calcHealOrShield(caster: UnitModel, target: UnitModel, value: number, rng: SeedRng): HealShieldResult;
+export declare function calcEffectProbability(baseProb: number, isFixedProb: boolean, attacker: UnitModel, defender: UnitModel, rng: SeedRng): boolean;

package/dist/battle/formula.js

@@ -0,0 +1,92 @@
+const DEF_PARTICLE = 300;
+const elementFieldMap = {
+    fire: { inc: "pFDI", red: "pFDI_Def" },
+    thunder: { inc: "pTDI", red: "pTDI_Def" },
+    water: { inc: "pWDI", red: "pWDI_Def" },
+    rock: { inc: "pRDI", red: "pRDI_Def" },
+    wind: { inc: "pADI", red: "pADI_Def" },
+    light: { inc: "pLDI", red: "pLDI_Def" },
+    dark: { inc: "pDDI", red: "pDDI_Def" }
+};
+const repressMap = {
+    water: "fire",
+    fire: "wind",
+    wind: "rock",
+    rock: "thunder",
+    thunder: "water"
+};
+function floorDiv(a, b) {
+    return Math.floor(a / b);
+}
+function clampPercent(v) {
+    return Math.min(10000, Math.max(0, Math.floor(v)));
+}
+export function repression(attackerElement, defenderElement) {
+    if (repressMap[attackerElement] === defenderElement) {
+        return 1;
+    }
+    if (repressMap[defenderElement] === attackerElement) {
+        return -1;
+    }
+    return 0;
+}
+function skillDamageRatio(attacker, type) {
+    if (type === "basic") {
+        return 10000 + attacker.stats.pBSDI;
+    }
+    if (type === "core") {
+        return 10000 + attacker.stats.pESDI;
+    }
+    return 10000 + attacker.stats.pFSDI;
+}
+export function calcDamage(attacker, defender, dam, type, elem, rng) {
+    let bDam = floorDiv(dam * DEF_PARTICLE, DEF_PARTICLE + defender.stats.Def);
+    bDam = floorDiv(bDam * skillDamageRatio(attacker, type), 10000);
+    const elementFields = elementFieldMap[elem];
+    const inc = 10000 + attacker.stats[elementFields.inc];
+    const red = 10000 + defender.stats[elementFields.red];
+    bDam = floorDiv(bDam * inc, red);
+    const rep = repression(attacker.element, defender.element);
+    if (rep === 1) {
+        bDam = floorDiv(bDam * 11500, 10000);
+    }
+    if (rep === -1) {
+        bDam = floorDiv(bDam * 8500, 10000);
+    }
+    const critProb = clampPercent(attacker.stats.pCTR - defender.stats.pCTR_Def);
+    const isCritical = Math.floor(rng.next() * 10000) < critProb;
+    const crtRatio = clampPercent(attacker.stats.pCTD - defender.stats.pCTD_Def - 10000);
+    const critDam = isCritical ? Math.max(0, floorDiv(bDam * crtRatio, 10000)) : 0;
+    const rawFinal = bDam + critDam;
+    const vulnRatio = 10000 + defender.stats.pVulnerability;
+    const finalDam = floorDiv(rawFinal * vulnRatio, 10000);
+    return {
+        finalDam,
+        baseDam: bDam,
+        critDam,
+        isCritical,
+        isRepression: rep
+    };
+}
+export function calcHealOrShield(caster, target, value, rng) {
+    const baseValue = floorDiv(value * (10000 + caster.stats.pHE), 10000);
+    const critProb = clampPercent(caster.stats.pCTR - target.stats.pCTR_Def);
+    const isCritical = Math.floor(rng.next() * 10000) < critProb;
+    const crtRatio = clampPercent(caster.stats.pCTD - target.stats.pCTD_Def - 10000);
+    const critValue = isCritical ? Math.max(0, floorDiv(baseValue * crtRatio, 10000)) : 0;
+    return {
+        finalValue: baseValue + critValue,
+        baseValue,
+        critValue,
+        isCritical
+    };
+}
+export function calcEffectProbability(baseProb, isFixedProb, attacker, defender, rng) {
+    let prob = baseProb;
+    if (!isFixedProb) {
+        prob = floorDiv(prob * (10000 + attacker.stats.pEHR), 10000 + defender.stats.pERes);
+    }
+    prob = clampPercent(prob);
+    const rand = Math.floor(rng.next() * 10000);
+    return rand < prob;
+}

package/dist/battle/logger.d.ts

@@ -0,0 +1,28 @@
+import type { BattleActionLog, BattleSnapshot, ElementType, UnitId, UnitModel, UnitStats } from "./types";
+export declare class BattleLogger {
+    readonly actionLogs: BattleActionLog[];
+    readonly snapshots: BattleSnapshot[];
+    readonly errors: Array<{
+        turn: number;
+        message: string;
+        detail?: unknown;
+    }>;
+    private pendingDotDamages;
+    private pendingImbalanceBreaks;
+    private pendingImbalanceChanges;
+    logAction(log: BattleActionLog): void;
+    /** 记录DOT伤害，用于在下一个快照中展示 */
+    logDotDamage(targetId: UnitId, value: number, buffId: string, element?: ElementType): void;
+    /** 记录失衡破击事件 */
+    logImbalanceBreak(targetId: UnitId, attackerId: UnitId, element: ElementType): void;
+    /** 记录失衡值变化来源 */
+    logImbalanceChange(targetId: UnitId, delta: number, reason: "turn_start_clear" | "skill_effect", sourceActorId?: UnitId, sourceSkillId?: string): void;
+    logSnapshot(turn: number, phase: BattleSnapshot["phase"], units: UnitModel[], resolveEffectiveStats: (unit: UnitModel) => UnitStats, resolveBuffs: (unit: UnitModel) => Array<{
+        id: string;
+        name: string;
+        stacks: number;
+        remainingRounds: number;
+        sourceId: string;
+    }>, resolveImbalanceMax: (unit: UnitModel) => number): void;
+    logError(turn: number, message: string, detail?: unknown): void;
+}

package/dist/battle/logger.js

@@ -0,0 +1,66 @@
+export class BattleLogger {
+    actionLogs = [];
+    snapshots = [];
+    errors = [];
+    pendingDotDamages = [];
+    pendingImbalanceBreaks = [];
+    pendingImbalanceChanges = [];
+    logAction(log) {
+        this.actionLogs.push(log);
+    }
+    /** 记录DOT伤害，用于在下一个快照中展示 */
+    logDotDamage(targetId, value, buffId, element) {
+        this.pendingDotDamages.push({ targetId, value, buffId, element });
+    }
+    /** 记录失衡破击事件 */
+    logImbalanceBreak(targetId, attackerId, element) {
+        this.pendingImbalanceBreaks.push({ targetId, attackerId, element });
+    }
+    /** 记录失衡值变化来源 */
+    logImbalanceChange(targetId, delta, reason, sourceActorId, sourceSkillId) {
+        if (delta === 0) {
+            return;
+        }
+        this.pendingImbalanceChanges.push({ targetId, delta, reason, sourceActorId, sourceSkillId });
+    }
+    logSnapshot(turn, phase, units, resolveEffectiveStats, resolveBuffs, resolveImbalanceMax) {
+        const snapshot = {
+            turn,
+            phase,
+            units: units.map((u) => {
+                const effective = resolveEffectiveStats(u);
+                return {
+                    id: u.id,
+                    hp: u.runtime.Hp,
+                    shield: u.runtime.Shield,
+                    ap: u.runtime.AP,
+                    energy: u.runtime.Energy,
+                    alive: u.runtime.alive,
+                    position: u.position,
+                    effectiveAllStats: { ...effective },
+                    buffs: resolveBuffs(u),
+                    imbalance: u.runtime.Imbalance,
+                    imbalanceMax: resolveImbalanceMax(u)
+                };
+            })
+        };
+        // 如果有待处理的DOT伤害，记录到快照中并清空
+        if (this.pendingDotDamages.length > 0) {
+            snapshot.dotDamages = [...this.pendingDotDamages];
+            this.pendingDotDamages = [];
+        }
+        // 如果有待处理的失衡破击事件，记录到快照中并清空
+        if (this.pendingImbalanceBreaks.length > 0) {
+            snapshot.imbalanceBreaks = [...this.pendingImbalanceBreaks];
+            this.pendingImbalanceBreaks = [];
+        }
+        if (this.pendingImbalanceChanges.length > 0) {
+            snapshot.imbalanceChanges = [...this.pendingImbalanceChanges];
+            this.pendingImbalanceChanges = [];
+        }
+        this.snapshots.push(snapshot);
+    }
+    logError(turn, message, detail) {
+        this.errors.push({ turn, message, detail });
+    }
+}

package/dist/battle/random.d.ts

@@ -0,0 +1,6 @@
+export declare class SeedRng {
+    private state;
+    constructor(seed: number);
+    next(): number;
+    nextInt(maxExclusive: number): number;
+}

package/dist/battle/random.js

@@ -0,0 +1,16 @@
+export class SeedRng {
+    state;
+    constructor(seed) {
+        this.state = seed >>> 0;
+    }
+    next() {
+        this.state = (1664525 * this.state + 1013904223) >>> 0;
+        return this.state / 0x100000000;
+    }
+    nextInt(maxExclusive) {
+        if (maxExclusive <= 0) {
+            return 0;
+        }
+        return Math.floor(this.next() * maxExclusive);
+    }
+}

package/dist/battle/script/designedScripts.d.ts

@@ -0,0 +1,2 @@
+import type { ISkillScript } from "../types";
+export declare const designedScripts: Record<string, ISkillScript>;