538 lines
16 KiB
TypeScript
538 lines
16 KiB
TypeScript
import { effectDesertData, cardDesertData } from "../data";
|
|
import { createStatusCard } from "../deck/factory";
|
|
import type { PlayerDeck, GameCard } from "../deck/types";
|
|
import type {
|
|
BuffTable,
|
|
CombatEffectEntry,
|
|
CombatState,
|
|
EffectData,
|
|
EffectTarget,
|
|
EffectTiming,
|
|
EnemyState,
|
|
ItemBuff,
|
|
PlayerCombatState,
|
|
} from "./types";
|
|
import {
|
|
drawCardsToHand,
|
|
addFatigueCards,
|
|
discardCard,
|
|
exhaustCard,
|
|
getEffectData,
|
|
discardHand,
|
|
} from "./state";
|
|
|
|
export type DamageResult = {
|
|
damageDealt: number;
|
|
blockedByDefend: number;
|
|
targetDied: boolean;
|
|
};
|
|
|
|
export function applyDamage(
|
|
state: CombatState,
|
|
targetKey: "player" | string,
|
|
amount: number,
|
|
sourceKey?: "player" | string,
|
|
): DamageResult {
|
|
if (amount <= 0) return { damageDealt: 0, blockedByDefend: 0, targetDied: false };
|
|
|
|
let actualDamage = amount;
|
|
let blockedByDefend = 0;
|
|
|
|
if (targetKey === "player") {
|
|
const defendStacks = state.player.buffs["defend"] ?? 0;
|
|
if (defendStacks > 0) {
|
|
blockedByDefend = Math.min(defendStacks, actualDamage);
|
|
actualDamage -= blockedByDefend;
|
|
state.player.buffs["defend"] = defendStacks - blockedByDefend;
|
|
if (state.player.buffs["defend"] === 0) {
|
|
delete state.player.buffs["defend"];
|
|
}
|
|
}
|
|
|
|
const damageReduce = state.player.buffs["damageReduce"] ?? 0;
|
|
if (damageReduce > 0 && actualDamage > 0) {
|
|
actualDamage = Math.max(0, actualDamage - damageReduce);
|
|
}
|
|
|
|
if (actualDamage > 0) {
|
|
state.player.hp = Math.max(0, state.player.hp - actualDamage);
|
|
state.player.damageTakenThisTurn += actualDamage;
|
|
state.player.damagedThisTurn = true;
|
|
}
|
|
|
|
if (blockedByDefend > 0 && defendStacks - blockedByDefend <= 0) {
|
|
for (const enemyId of state.enemyOrder) {
|
|
const enemy = state.enemies[enemyId];
|
|
if (enemy.isAlive && enemy.buffs["defend"] !== undefined) {
|
|
// Not relevant for player, skip
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
damageDealt: actualDamage,
|
|
blockedByDefend,
|
|
targetDied: state.player.hp <= 0,
|
|
};
|
|
}
|
|
|
|
const enemy = state.enemies[targetKey];
|
|
if (!enemy || !enemy.isAlive) {
|
|
return { damageDealt: 0, blockedByDefend: 0, targetDied: false };
|
|
}
|
|
|
|
const defendStacks = enemy.buffs["defend"] ?? 0;
|
|
if (defendStacks > 0) {
|
|
blockedByDefend = Math.min(defendStacks, actualDamage);
|
|
actualDamage -= blockedByDefend;
|
|
enemy.buffs["defend"] = defendStacks - blockedByDefend;
|
|
if (enemy.buffs["defend"] === 0) {
|
|
delete enemy.buffs["defend"];
|
|
}
|
|
|
|
if (defendStacks > 0 && defendStacks - blockedByDefend <= 0) {
|
|
enemy.hadDefendBroken = true;
|
|
}
|
|
}
|
|
|
|
if (actualDamage > 0) {
|
|
enemy.hp = Math.max(0, enemy.hp - actualDamage);
|
|
if (enemy.hp <= 0) {
|
|
enemy.isAlive = false;
|
|
}
|
|
}
|
|
|
|
return {
|
|
damageDealt: actualDamage,
|
|
blockedByDefend,
|
|
targetDied: !enemy.isAlive,
|
|
};
|
|
}
|
|
|
|
export function applyDefend(
|
|
targetBuffs: BuffTable,
|
|
amount: number,
|
|
): void {
|
|
if (amount <= 0) return;
|
|
targetBuffs["defend"] = (targetBuffs["defend"] ?? 0) + amount;
|
|
}
|
|
|
|
export function applyBuff(
|
|
buffs: BuffTable,
|
|
effectId: string,
|
|
timing: EffectTiming,
|
|
stacks: number,
|
|
): void {
|
|
if (stacks <= 0) return;
|
|
buffs[effectId] = (buffs[effectId] ?? 0) + stacks;
|
|
}
|
|
|
|
export function removeBuff(buffs: BuffTable, effectId: string, stacks?: number): number {
|
|
const current = buffs[effectId] ?? 0;
|
|
if (stacks === undefined || stacks >= current) {
|
|
delete buffs[effectId];
|
|
return current;
|
|
}
|
|
buffs[effectId] = current - stacks;
|
|
return stacks;
|
|
}
|
|
|
|
export function updateBuffs(buffs: BuffTable): void {
|
|
const toDelete: string[] = [];
|
|
const toDecrement: string[] = [];
|
|
|
|
for (const [effectId] of Object.entries(buffs)) {
|
|
const effectData = getEffectData(effectId);
|
|
if (!effectData) continue;
|
|
|
|
switch (effectData.timing) {
|
|
case "temporary":
|
|
toDelete.push(effectId);
|
|
break;
|
|
case "lingering":
|
|
toDecrement.push(effectId);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (const id of toDelete) {
|
|
delete buffs[id];
|
|
}
|
|
|
|
for (const id of toDecrement) {
|
|
buffs[id] = (buffs[id] ?? 0) - 1;
|
|
if (buffs[id] <= 0) {
|
|
delete buffs[id];
|
|
}
|
|
}
|
|
}
|
|
|
|
export type ResolveEffectContext = {
|
|
state: CombatState;
|
|
rng: { nextInt: (n: number) => number };
|
|
};
|
|
|
|
export function resolveEffect(
|
|
ctx: ResolveEffectContext,
|
|
target: EffectTarget,
|
|
effect: EffectData,
|
|
stacks: number,
|
|
sourceKey?: "player" | string,
|
|
sourceCardId?: string,
|
|
): void {
|
|
const { state } = ctx;
|
|
const timing = effect.timing;
|
|
|
|
switch (timing) {
|
|
case "instant":
|
|
resolveInstantEffect(ctx, target, effect, stacks, sourceKey, sourceCardId);
|
|
break;
|
|
case "posture":
|
|
applyBuffToTarget(state, target, effect.id, stacks, sourceKey);
|
|
break;
|
|
case "temporary":
|
|
case "lingering":
|
|
case "permanent":
|
|
applyBuffToTarget(state, target, effect.id, stacks, sourceKey);
|
|
break;
|
|
case "card":
|
|
addStatusCardToDiscard(state, effect.id, stacks);
|
|
break;
|
|
case "cardDraw":
|
|
addStatusCardToDrawPile(state, effect.id, stacks);
|
|
break;
|
|
case "cardHand":
|
|
addStatusCardToHand(state, effect.id, stacks);
|
|
break;
|
|
case "item":
|
|
case "itemUntilPlayed":
|
|
applyItemBuff(state, effect.id, timing, stacks, sourceCardId);
|
|
break;
|
|
}
|
|
}
|
|
|
|
function applyBuffToTarget(
|
|
state: CombatState,
|
|
target: EffectTarget,
|
|
effectId: string,
|
|
stacks: number,
|
|
sourceKey?: "player" | string,
|
|
): void {
|
|
if (target === "self") {
|
|
if (sourceKey === "player") {
|
|
applyBuff(state.player.buffs, effectId, getEffectData(effectId)?.timing ?? "permanent", stacks);
|
|
} else if (sourceKey && state.enemies[sourceKey]) {
|
|
applyBuff(state.enemies[sourceKey].buffs, effectId, getEffectData(effectId)?.timing ?? "permanent", stacks);
|
|
}
|
|
} else if (target === "player" || target === "team") {
|
|
applyBuff(state.player.buffs, effectId, getEffectData(effectId)?.timing ?? "permanent", stacks);
|
|
} else if (target === "target" || target === "all" || target === "random") {
|
|
// For attack/defend effects, these are handled by resolveInstantEffect
|
|
}
|
|
}
|
|
|
|
function resolveInstantEffect(
|
|
ctx: ResolveEffectContext,
|
|
target: EffectTarget,
|
|
effect: EffectData,
|
|
stacks: number,
|
|
sourceKey?: "player" | string,
|
|
sourceCardId?: string,
|
|
): void {
|
|
const { state, rng } = ctx;
|
|
|
|
switch (effect.id) {
|
|
case "attack": {
|
|
const damageAmount = stacks;
|
|
if (target === "all") {
|
|
for (const enemyId of state.enemyOrder) {
|
|
const enemy = state.enemies[enemyId];
|
|
if (enemy.isAlive) {
|
|
applyDamage(state, enemyId, damageAmount, sourceKey);
|
|
}
|
|
}
|
|
} else if (target === "random") {
|
|
const aliveEnemies = state.enemyOrder.filter(id => state.enemies[id].isAlive);
|
|
if (aliveEnemies.length > 0) {
|
|
const targetId = aliveEnemies[rng.nextInt(aliveEnemies.length)];
|
|
applyDamage(state, targetId, damageAmount, sourceKey);
|
|
}
|
|
} else if (target === "target") {
|
|
if (sourceKey && sourceKey !== "player" && state.enemies[sourceKey]?.isAlive) {
|
|
applyDamage(state, "player", damageAmount, sourceKey);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "defend": {
|
|
if (target === "self" && sourceKey === "player") {
|
|
applyDefend(state.player.buffs, stacks);
|
|
} else if (target === "self" && sourceKey && state.enemies[sourceKey]) {
|
|
applyDefend(state.enemies[sourceKey].buffs, stacks);
|
|
}
|
|
break;
|
|
}
|
|
case "draw": {
|
|
drawCardsToHand(state.player.deck, stacks);
|
|
break;
|
|
}
|
|
case "gainEnergy": {
|
|
state.player.energy += stacks;
|
|
break;
|
|
}
|
|
case "removeWound": {
|
|
removeWoundCards(state.player.deck, stacks);
|
|
break;
|
|
}
|
|
case "tailSting": {
|
|
applyDamage(state, "player", stacks, sourceKey);
|
|
break;
|
|
}
|
|
case "rollDamage": {
|
|
const rollStacks = sourceKey && sourceKey !== "player"
|
|
? state.enemies[sourceKey]?.buffs["roll"] ?? 0
|
|
: 0;
|
|
if (rollStacks >= 10) {
|
|
const damageFromRoll = Math.floor(rollStacks / 10) * 10;
|
|
applyDamage(state, "player", Math.floor(damageFromRoll / 10), sourceKey);
|
|
removeBuff(state.enemies[sourceKey!].buffs, "roll", damageFromRoll);
|
|
}
|
|
break;
|
|
}
|
|
case "crossbow": {
|
|
break;
|
|
}
|
|
case "discard": {
|
|
break;
|
|
}
|
|
case "summonMummy":
|
|
case "summonSandwormLarva":
|
|
case "reviveMummy": {
|
|
break;
|
|
}
|
|
case "drawChoice":
|
|
case "transformRandom": {
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
function addStatusCardToDiscard(state: CombatState, effectId: string, count: number): void {
|
|
const cardDef = cardDesertData.find(c => c.id === effectId);
|
|
if (!cardDef) return;
|
|
|
|
for (let i = 0; i < count; i++) {
|
|
const cardId = `status-${effectId}-${Date.now()}-${i}`;
|
|
const card = createStatusCard(cardId, cardDef.name, cardDef.desc);
|
|
state.player.deck.cards[card.id] = card;
|
|
state.player.deck.discardPile.push(card.id);
|
|
}
|
|
}
|
|
|
|
function addStatusCardToDrawPile(state: CombatState, effectId: string, count: number): void {
|
|
const cardDef = cardDesertData.find(c => c.id === effectId);
|
|
if (!cardDef) return;
|
|
|
|
for (let i = 0; i < count; i++) {
|
|
const cardId = `status-${effectId}-${Date.now()}-${i}`;
|
|
const card = createStatusCard(cardId, cardDef.name, cardDef.desc);
|
|
state.player.deck.cards[card.id] = card;
|
|
state.player.deck.drawPile.push(card.id);
|
|
}
|
|
}
|
|
|
|
function addStatusCardToHand(state: CombatState, effectId: string, count: number): void {
|
|
const cardDef = cardDesertData.find(c => c.id === effectId);
|
|
if (!cardDef) return;
|
|
|
|
for (let i = 0; i < count; i++) {
|
|
const cardId = `status-${effectId}-${Date.now()}-${i}`;
|
|
const card = createStatusCard(cardId, cardDef.name, cardDef.desc);
|
|
state.player.deck.cards[card.id] = card;
|
|
state.player.deck.hand.push(card.id);
|
|
}
|
|
}
|
|
|
|
function applyItemBuff(
|
|
state: CombatState,
|
|
effectId: string,
|
|
timing: EffectTiming,
|
|
stacks: number,
|
|
sourceCardId?: string,
|
|
): void {
|
|
if (!sourceCardId) return;
|
|
|
|
const card = state.player.deck.cards[sourceCardId];
|
|
if (!card || !card.sourceItemId) return;
|
|
|
|
const itemBuff: ItemBuff = {
|
|
effectId,
|
|
stacks,
|
|
timing,
|
|
sourceItemId: card.sourceItemId,
|
|
targetItemId: card.sourceItemId,
|
|
};
|
|
state.player.itemBuffs.push(itemBuff);
|
|
}
|
|
|
|
function removeWoundCards(deck: PlayerDeck, count: number): void {
|
|
let removed = 0;
|
|
|
|
for (let i = deck.drawPile.length - 1; i >= 0 && removed < count; i--) {
|
|
const card = deck.cards[deck.drawPile[i]];
|
|
if (card && card.itemData === null && card.displayName === "伤口") {
|
|
delete deck.cards[deck.drawPile[i]];
|
|
deck.drawPile.splice(i, 1);
|
|
removed++;
|
|
}
|
|
}
|
|
|
|
for (let i = deck.discardPile.length - 1; i >= 0 && removed < count; i--) {
|
|
const card = deck.cards[deck.discardPile[i]];
|
|
if (card && card.itemData === null && card.displayName === "伤口") {
|
|
delete deck.cards[deck.discardPile[i]];
|
|
deck.discardPile.splice(i, 1);
|
|
removed++;
|
|
}
|
|
}
|
|
}
|
|
|
|
export function resolveCardEffects(
|
|
ctx: ResolveEffectContext,
|
|
cardId: string,
|
|
targetEnemyId?: string,
|
|
): void {
|
|
const { state } = ctx;
|
|
const card = state.player.deck.cards[cardId];
|
|
if (!card || !card.itemData) return;
|
|
|
|
const sourceKey: "player" | string = "player";
|
|
|
|
const effects = card.itemData.onPlay as unknown as CombatEffectEntry[];
|
|
for (const entry of effects) {
|
|
const [target, effect, stacks] = entry;
|
|
|
|
if (target === "target") {
|
|
if (targetEnemyId && state.enemies[targetEnemyId]?.isAlive) {
|
|
if (effect.id === "attack") {
|
|
const actualDamage = getModifiedAttackDamage(state, cardId, stacks);
|
|
applyDamage(state, targetEnemyId, actualDamage, "player");
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
resolveEffect(ctx, target, effect, stacks, sourceKey, cardId);
|
|
}
|
|
}
|
|
|
|
export function getModifiedAttackDamage(
|
|
state: CombatState,
|
|
cardId: string,
|
|
baseDamage: number,
|
|
): number {
|
|
let damage = baseDamage;
|
|
|
|
const attackBuff = state.player.itemBuffs
|
|
.filter((b) => b.effectId === "attackBuff" || b.effectId === "attackBuffUntilPlay")
|
|
.filter((b) => {
|
|
const card = state.player.deck.cards[cardId];
|
|
return card && card.sourceItemId === b.targetItemId;
|
|
})
|
|
.reduce((sum, b) => sum + b.stacks, 0);
|
|
damage += attackBuff;
|
|
|
|
return Math.max(0, damage);
|
|
}
|
|
|
|
export function getModifiedDefendAmount(
|
|
state: CombatState,
|
|
cardId: string,
|
|
baseDefend: number,
|
|
): number {
|
|
let defend = baseDefend;
|
|
|
|
const defendBuff = state.player.itemBuffs
|
|
.filter((b) => b.effectId === "defendBuff" || b.effectId === "defendBuffUntilPlay")
|
|
.filter((b) => {
|
|
const card = state.player.deck.cards[cardId];
|
|
return card && card.sourceItemId === b.targetItemId;
|
|
})
|
|
.reduce((sum, b) => sum + b.stacks, 0);
|
|
defend += defendBuff;
|
|
|
|
return Math.max(0, defend);
|
|
}
|
|
|
|
export function canPlayCard(
|
|
state: CombatState,
|
|
cardId: string,
|
|
): { canPlay: boolean; reason?: string } {
|
|
const card = state.player.deck.cards[cardId];
|
|
if (!card) return { canPlay: false, reason: "卡牌不存在" };
|
|
|
|
if (!card.itemData) return { canPlay: false, reason: "状态牌不可打出" };
|
|
|
|
const handIdx = state.player.deck.hand.indexOf(cardId);
|
|
if (handIdx < 0) return { canPlay: false, reason: "卡牌不在手牌中" };
|
|
|
|
if (card.itemData.costType === "energy") {
|
|
if (state.player.energy < card.itemData.costCount) {
|
|
return { canPlay: false, reason: "能量不足" };
|
|
}
|
|
}
|
|
|
|
return { canPlay: true };
|
|
}
|
|
|
|
export function playCard(
|
|
ctx: ResolveEffectContext,
|
|
cardId: string,
|
|
targetEnemyId?: string,
|
|
): { success: boolean; reason?: string } {
|
|
const { state } = ctx;
|
|
const check = canPlayCard(state, cardId);
|
|
if (!check.canPlay) return { success: false, reason: check.reason };
|
|
|
|
const card = state.player.deck.cards[cardId];
|
|
if (!card || !card.itemData) return { success: false, reason: "卡牌无效" };
|
|
|
|
if (card.itemData.costType === "energy") {
|
|
state.player.energy -= card.itemData.costCount;
|
|
}
|
|
|
|
resolveCardEffects(ctx, cardId, targetEnemyId);
|
|
|
|
if (card.itemData.costType === "uses") {
|
|
exhaustCard(state.player.deck, cardId);
|
|
} else {
|
|
discardCard(state.player.deck, cardId);
|
|
}
|
|
|
|
expireItemBuffsOnCardPlayed(state, cardId);
|
|
|
|
return { success: true };
|
|
}
|
|
|
|
function expireItemBuffsOnCardPlayed(state: CombatState, cardId: string): void {
|
|
const card = state.player.deck.cards[cardId];
|
|
if (!card || !card.sourceItemId) return;
|
|
|
|
state.player.itemBuffs = state.player.itemBuffs.filter((buff) => {
|
|
if (buff.timing === "itemUntilPlayed" && buff.sourceItemId === card.sourceItemId) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
export function areAllEnemiesDead(state: CombatState): boolean {
|
|
return state.enemyOrder.every(id => !state.enemies[id].isAlive);
|
|
}
|
|
|
|
export function isPlayerDead(state: CombatState): boolean {
|
|
return state.player.hp <= 0;
|
|
}
|