474 lines
18 KiB
TypeScript
474 lines
18 KiB
TypeScript
/**
|
||
* @file RogueConfig.ts
|
||
* @description 无限关卡刷怪系统（关-回合两级推进）
|
||
*
|
||
* 游戏机制：
|
||
* - 玩家单线无限推进：从第 1 关起无上限，每关 5 回合（一关一局，回合间自动推进）。
|
||
* - 第 1~4 回合普通怪（3 小怪立即全刷），属性逐回合轻量增强（SECTION_RAMP_STEP）。
|
||
* - 第 5 回合单 Boss 登场（无护卫，延迟 1s 刷出），超厚血量（BOSS_HP_MUL）。
|
||
* - Boss 加载时按攻击定位（近战/中程/远程）随机取型，并随机携带大招：
|
||
* 前期 1 个，随关卡解锁扩展至多个（BOSS_ULT_UNLOCK_EVERY / BOSS_ULT_MAX_COUNT）。
|
||
*
|
||
* 设计层次：
|
||
* 1. StageSet - 关卡数值公式（等级/成长/回合增强/Boss 血攻倍率）
|
||
* 2. BossPools - Boss 池（按攻击定位分组，动态从 HeroInfo 提取）
|
||
* 3. BossUltPools - Boss 大招池（按定位分组，引用 SkillSet 6100~6204 群体大招段）
|
||
* 4. StageSpawningEngine - 生成引擎（按回合配置生成怪物列表）
|
||
*
|
||
* 核心公式：
|
||
* 小怪属性 = HeroInfo 基础属性 × MON_START_COEF × (1 + MON_GROW_SLOPE×(lv-1)) × 回合增强
|
||
* Boss 属性 = 同上 × BOSS_HP_MUL（血）/ BOSS_AP_MUL（攻），等级 = 关卡号无限成长
|
||
*/
|
||
|
||
import { HeroInfo, HType, MonType, TriggerGrouped, UltCdLv, UltCdSet } from "../common/config/heroSet";
|
||
import { SkillOverrides, SkillSet } from "../common/config/SkillSet";
|
||
import { FacSet } from "../common/config/GameSet";
|
||
import {
|
||
SectionType, SectionConfig, getSectionConfig, calcMonsterAttrs,
|
||
NORMAL_MON_COUNT, NORMAL_FIRST_SPAWN, BOSS_DELAY,
|
||
MON_START_COEF,
|
||
} from "../common/config/StageSet";
|
||
|
||
// ======================== 1. 战斗常量 ========================
|
||
|
||
/** 单场战斗时长基准（秒）：供清屏速度评价（BattleBannerComp 清屏奖励）等使用 */
|
||
export const WAVE_DURATION = 30;
|
||
|
||
/** 战斗超时（秒）：超过后强制结算整局（残留怪销毁并扣留存分） */
|
||
export const BATTLE_TIMEOUT = 90;
|
||
|
||
// ======================== 2. 怪物 UUID 池 ========================
|
||
|
||
/** 按 MonType 分组的怪物 uuid 池，动态从 HeroInfo 提取，避免硬编码 */
|
||
export const MonList: Record<number, number[]> = {};
|
||
for (const key in HeroInfo) {
|
||
const info = HeroInfo[key];
|
||
if (info.fac === FacSet.MON && info.monType !== undefined) {
|
||
if (!MonList[info.monType]) {
|
||
MonList[info.monType] = [];
|
||
}
|
||
MonList[info.monType].push(info.uuid);
|
||
}
|
||
}
|
||
|
||
// ======================== 2.5 怪物金币掉落配置 ========================
|
||
|
||
/**
|
||
* 怪物金币掉落配置（按 MonType 分类）
|
||
* - base: 普通怪物死亡时掉落的固定金币数
|
||
* - boss: Boss 怪物死亡时掉落的固定金币数（仅对 Boss 类型生效）
|
||
*/
|
||
export const MonsterGoldSet: Record<number, { base: number; boss: number }> = {
|
||
[MonType.Melee]: { base: 1, boss: 0 },
|
||
[MonType.Heavy]: { base: 2, boss: 0 },
|
||
[MonType.Long]: { base: 2, boss: 0 },
|
||
[MonType.Support]: { base: 3, boss: 0 },
|
||
[MonType.Summoner]: { base: 3, boss: 0 },
|
||
[MonType.Assassin]: { base: 3, boss: 0 },
|
||
[MonType.MeleeBoss]: { base: 0, boss: 15 },
|
||
[MonType.LongBoss]: { base: 0, boss: 15 },
|
||
};
|
||
|
||
/**
|
||
* 获取指定怪物类型的金币掉落数量
|
||
* @param monType 怪物类型（MonType）
|
||
* @param isBoss 是否为 Boss
|
||
* @returns 掉落的金币数量（≥0）
|
||
*/
|
||
export function getMonsterGoldDrop(monType: number, isBoss: boolean): number {
|
||
const cfg = MonsterGoldSet[monType];
|
||
if (!cfg) return 0;
|
||
return Math.max(0, Math.floor(isBoss ? cfg.boss : cfg.base));
|
||
}
|
||
|
||
// ======================== 3. Boss 池（按攻击定位分组） ========================
|
||
|
||
/**
|
||
* Boss 池：按攻击定位（近战/中程/远程）分组，动态从 HeroInfo 提取。
|
||
* 加载时随机一个定位 → 从对应池随机 Boss；定位池为空时自动回退（如暂无中程 Boss 配置）。
|
||
*/
|
||
export const BossPools: Record<HType, number[]> = {
|
||
[HType.Melee]: [],
|
||
[HType.Mid]: [],
|
||
[HType.Long]: [],
|
||
};
|
||
for (const key in HeroInfo) {
|
||
const info = HeroInfo[key];
|
||
if (info.fac !== FacSet.MON) continue;
|
||
if (info.monType !== MonType.MeleeBoss && info.monType !== MonType.LongBoss) continue;
|
||
const pool = BossPools[info.type as HType];
|
||
if (pool) pool.push(info.uuid);
|
||
}
|
||
|
||
// ======================== 4. Boss 大招池 ========================
|
||
|
||
/** 每解锁 1 个额外大招收紧的关卡间隔（每 5 关 +1 个大招位） */
|
||
export const BOSS_ULT_UNLOCK_EVERY = 5;
|
||
/** Boss 同时携带大招数量上限 */
|
||
export const BOSS_ULT_MAX_COUNT = 3;
|
||
|
||
/**
|
||
* 获取指定关卡的 Boss 携带大招数量（1 个起步，随关卡解锁扩展）
|
||
* @param stage 关卡号（1~∞）
|
||
* @returns 大招数量（1~BOSS_ULT_MAX_COUNT）
|
||
*/
|
||
export function getBossUltCount(stage: number): number {
|
||
const st = Math.max(1, Math.floor(stage));
|
||
return Math.min(BOSS_ULT_MAX_COUNT, 1 + Math.floor((st - 1) / BOSS_ULT_UNLOCK_EVERY));
|
||
}
|
||
|
||
/** Boss 大招条目（s_uuid 引用 SkillSet 6100~6204 群体大招段，按定位分组） */
|
||
export interface BossUltEntry {
|
||
s_uuid: number;
|
||
name: string;
|
||
/** 抽取权重 */
|
||
weight: number;
|
||
/** 技能参数覆盖（伤害系数等） */
|
||
overrides?: SkillOverrides;
|
||
}
|
||
|
||
/**
|
||
* Boss 大招池（按攻击定位分组）
|
||
* 大招注入 Boss 的 skills 表后由 SCastSystem 按 CD 自动施放（含镜头聚焦 + 技能名横幅）。
|
||
*/
|
||
export const BossUltPools: Record<HType, BossUltEntry[]> = {
|
||
// 近战系：战士群体斩击（6100~6104 段）
|
||
[HType.Melee]: [
|
||
{ s_uuid: 6100, name: "寒冰斩", weight: 10, overrides: { ap: 180 } },
|
||
{ s_uuid: 6101, name: "裂气斩", weight: 10, overrides: { ap: 180 } },
|
||
{ s_uuid: 6102, name: "火焰斩", weight: 10, overrides: { ap: 180 } },
|
||
{ s_uuid: 6103, name: "闪电斩", weight: 8, overrides: { ap: 180 } },
|
||
{ s_uuid: 6104, name: "开天斩", weight: 6, overrides: { ap: 220 } },
|
||
],
|
||
// 中程系：射手箭雨 + 混合法术（6150~6151 / 6203~6204 段）
|
||
[HType.Mid]: [
|
||
{ s_uuid: 6150, name: "万箭齐发", weight: 10, overrides: { ap: 150 } },
|
||
{ s_uuid: 6151, name: "火箭齐发", weight: 10, overrides: { ap: 150 } },
|
||
{ s_uuid: 6203, name: "能量波", weight: 8, overrides: { ap: 150 } },
|
||
{ s_uuid: 6204, name: "雷暴", weight: 8, overrides: { ap: 150 } },
|
||
],
|
||
// 远程系：法师群体法术（6200~6204 段）
|
||
[HType.Long]: [
|
||
{ s_uuid: 6200, name: "火球术", weight: 10, overrides: { ap: 160 } },
|
||
{ s_uuid: 6201, name: "飓风", weight: 10, overrides: { ap: 140 } },
|
||
{ s_uuid: 6202, name: "毒气弹", weight: 8, overrides: { ap: 150 } },
|
||
{ s_uuid: 6203, name: "能量波", weight: 8, overrides: { ap: 150 } },
|
||
{ s_uuid: 6204, name: "雷暴", weight: 8, overrides: { ap: 150 } },
|
||
],
|
||
};
|
||
|
||
// ======================== 5. 配置校验 ========================
|
||
|
||
/**
|
||
* 校验 Boss 池 / Boss 大招池引用一致性
|
||
* 建议在游戏启动时调用一次，便于发现配置错误
|
||
* @returns 错误信息数组，空数组表示校验通过
|
||
*/
|
||
export function validateRogueConfig(): string[] {
|
||
const errors: string[] = [];
|
||
|
||
// 校验至少一个定位有可用 Boss
|
||
const hasBoss = (Object.keys(BossPools) as unknown as HType[]).some(t => BossPools[t].length > 0);
|
||
if (!hasBoss) {
|
||
errors.push("BossPools 中无任何可用 Boss uuid（MeleeBoss/LongBoss 均缺失）");
|
||
}
|
||
|
||
// 校验大招池条目均存在于 SkillSet
|
||
for (const key in BossUltPools) {
|
||
const pool = BossPools[key as unknown as HType];
|
||
const ults = BossUltPools[key as unknown as HType];
|
||
if (!pool || pool.length === 0) continue; // 空定位池跳过（大招池无消费方）
|
||
for (const ult of ults) {
|
||
if (!SkillSet[ult.s_uuid]) {
|
||
errors.push(`BossUltPools[${key}] 大招 ${ult.s_uuid}(${ult.name}) 未在 SkillSet 中定义`);
|
||
}
|
||
}
|
||
}
|
||
|
||
return errors;
|
||
}
|
||
|
||
// ======================== 6. 生成结果接口 ========================
|
||
|
||
/** 生成结果（传递给 MissionMonComp 用于实例化怪物） */
|
||
export interface GeneratedMonster {
|
||
uuid: number;
|
||
type: MonType;
|
||
hp: number;
|
||
ap: number;
|
||
isBoss: boolean;
|
||
/** 是否为精英（对象池复用实体需显式重置的标记位） */
|
||
isElite?: boolean;
|
||
/** 怪物等级（驱动技能等级增量，Mon.load 第 6 参） */
|
||
lv: number;
|
||
spawnIndex: number;
|
||
/** 本怪所属批次（0=首批立即刷，1=后续定时刷） */
|
||
batch: number;
|
||
/** 延迟刷出时间（秒），0 表示立即 */
|
||
delay?: number;
|
||
|
||
/**
|
||
* 怪物技能套装（技能注入通道，与 _testSkills 相同，在 Mon.load() 中写入 HeroAttrsComp）
|
||
* - skill：替换普攻（会清空原技能表）
|
||
* - ults：追加 Boss 大招（保留普攻，多个大招共存，SCastSystem 按 CD 轮转施放）
|
||
* - 其余为触发技能组覆盖
|
||
*/
|
||
skills?: {
|
||
skill?: { s_uuid: number; cd?: number; overrides?: SkillOverrides };
|
||
/** Boss 大招列表（追加注入，不替换普攻） */
|
||
ults?: { s_uuid: number; cd?: number; overrides?: SkillOverrides }[];
|
||
call?: TriggerGrouped;
|
||
atking?: TriggerGrouped;
|
||
atked?: TriggerGrouped;
|
||
dead?: TriggerGrouped;
|
||
fstart?: TriggerGrouped;
|
||
revive?: TriggerGrouped;
|
||
};
|
||
}
|
||
|
||
// ======================== 7. 测试模式配置 ========================
|
||
|
||
export const TestModeConfig = {
|
||
enable: false, // 默认关闭测试模式
|
||
baseHp: 150,
|
||
baseAp: 12,
|
||
monType: MonType.Melee,
|
||
monUuid: 6001,
|
||
spawnCount: 1,
|
||
|
||
skill: undefined as { s_uuid: number; cd?: number; overrides?: SkillOverrides } | undefined,
|
||
/** 测试模式注入的大招列表（追加，不替换普攻） */
|
||
ults: undefined as { s_uuid: number; cd?: number; overrides?: SkillOverrides }[] | undefined,
|
||
atking: undefined as TriggerGrouped | undefined,
|
||
atked: undefined as TriggerGrouped | undefined,
|
||
dead: undefined as TriggerGrouped | undefined,
|
||
fstart: undefined as TriggerGrouped | undefined,
|
||
};
|
||
|
||
// ======================== 8. 生成引擎 ========================
|
||
|
||
/**
|
||
* 无限关卡刷怪生成引擎
|
||
* 按关-回合配置生成怪物列表，属性走 StageSet 数值公式
|
||
*/
|
||
export class StageSpawningEngine {
|
||
|
||
/**
|
||
* 生成指定回合的怪物列表
|
||
* @param chapter 章节号（无限关模式已废弃章节概念，兼容参数恒忽略）
|
||
* @param stage 关卡号（1~∞）
|
||
* @param section 回合号（1~SECTIONS_PER_STAGE）
|
||
* @returns 怪物列表（按刷出顺序排列）
|
||
*/
|
||
generateSectionMonsters(chapter: number, stage: number, section: number): GeneratedMonster[] {
|
||
// 测试模式拦截：完全绕过生成引擎，直接返回硬编码测试怪
|
||
if (TestModeConfig.enable) {
|
||
return this.generateTestWave();
|
||
}
|
||
|
||
const cfg = getSectionConfig(chapter, stage, section);
|
||
if (!cfg) {
|
||
// 配置缺失兜底：生成 3 只 Lv1 近战小怪
|
||
return this.makeFallbackMonsters();
|
||
}
|
||
|
||
return cfg.type === SectionType.Boss
|
||
? this.generateBossSection(cfg, stage)
|
||
: this.generateNormalSection(cfg);
|
||
}
|
||
|
||
/** 重置引擎状态（每局开始时调用，预留） */
|
||
reset(): void {
|
||
}
|
||
|
||
/**
|
||
* 普通回合（1~4）：NORMAL_MON_COUNT 只小怪全部立即刷出（batch=0），
|
||
* 属性乘回合增强系数（cfg.ramp）实现逐回合轻量增强
|
||
*/
|
||
private generateNormalSection(cfg: SectionConfig): GeneratedMonster[] {
|
||
const monsters: GeneratedMonster[] = [];
|
||
const types = cfg.monTypes ?? [MonType.Melee];
|
||
|
||
for (let i = 0; i < NORMAL_MON_COUNT; i++) {
|
||
const type = types[i % types.length];
|
||
const mon = this.makeMonster(type, cfg.monLv, i);
|
||
mon.batch = i < NORMAL_FIRST_SPAWN ? 0 : 1;
|
||
// 回合内轻量增强：第 n 回合 × (1 + SECTION_RAMP_STEP×(n-1))
|
||
mon.hp = Math.max(1, Math.round(mon.hp * cfg.ramp));
|
||
mon.ap = Math.max(1, Math.round(mon.ap * cfg.ramp));
|
||
monsters.push(mon);
|
||
}
|
||
return monsters;
|
||
}
|
||
|
||
/**
|
||
* Boss 回合（5）：单 Boss 登场（无护卫）
|
||
* Boss 延迟 BOSS_DELAY 秒刷出，属性由 makeBoss 按血/攻分离倍率计算（超厚血量）
|
||
*/
|
||
private generateBossSection(cfg: SectionConfig, stage: number): GeneratedMonster[] {
|
||
const boss = this.makeBoss(cfg.monLv, stage, 0);
|
||
boss.batch = 0;
|
||
boss.delay = BOSS_DELAY;
|
||
return [boss];
|
||
}
|
||
|
||
/** 生成普通怪物（属性按 StageSet 公式计算） */
|
||
private makeMonster(type: MonType, monLv: number, spawnIndex: number): GeneratedMonster {
|
||
let uuids = MonList[type];
|
||
if (!uuids || uuids.length === 0) {
|
||
// 兜底 Melee
|
||
uuids = MonList[MonType.Melee] || [6001];
|
||
}
|
||
const uuid = uuids[Math.floor(Math.random() * uuids.length)];
|
||
|
||
const baseInfo = HeroInfo[uuid];
|
||
const baseHp = baseInfo ? baseInfo.hp : 100;
|
||
const baseAp = baseInfo ? baseInfo.ap : 10;
|
||
const attrs = calcMonsterAttrs(baseHp, baseAp, monLv, false);
|
||
|
||
return {
|
||
uuid,
|
||
type,
|
||
hp: attrs.hp,
|
||
ap: attrs.ap,
|
||
isBoss: false,
|
||
lv: monLv,
|
||
spawnIndex,
|
||
batch: 0,
|
||
};
|
||
}
|
||
|
||
/** 配置缺失兜底：3 只 Lv1 近战小怪 */
|
||
private makeFallbackMonsters(): GeneratedMonster[] {
|
||
const monsters: GeneratedMonster[] = [];
|
||
for (let i = 0; i < 3; i++) {
|
||
monsters.push({
|
||
uuid: 6001,
|
||
type: MonType.Melee,
|
||
hp: Math.round(560 * MON_START_COEF),
|
||
ap: Math.round(22 * MON_START_COEF),
|
||
isBoss: false,
|
||
lv: 1,
|
||
spawnIndex: i,
|
||
batch: 0,
|
||
});
|
||
}
|
||
return monsters;
|
||
}
|
||
|
||
/** 测试模式：完全绕过引擎逻辑 */
|
||
private generateTestWave(): GeneratedMonster[] {
|
||
const count = Math.max(1, TestModeConfig.spawnCount || 1);
|
||
const monsters: GeneratedMonster[] = [];
|
||
|
||
for (let i = 0; i < count; i++) {
|
||
monsters.push({
|
||
uuid: TestModeConfig.monUuid,
|
||
type: TestModeConfig.monType,
|
||
hp: TestModeConfig.baseHp,
|
||
ap: TestModeConfig.baseAp,
|
||
isBoss: false,
|
||
lv: 1,
|
||
spawnIndex: i,
|
||
batch: 0,
|
||
skills: {
|
||
skill: TestModeConfig.skill,
|
||
ults: TestModeConfig.ults,
|
||
atking: TestModeConfig.atking,
|
||
atked: TestModeConfig.atked,
|
||
dead: TestModeConfig.dead,
|
||
fstart: TestModeConfig.fstart,
|
||
},
|
||
});
|
||
}
|
||
return monsters;
|
||
}
|
||
|
||
/**
|
||
* 生成 Boss：加载时随机攻击定位 → 从对应池随机 Boss 个体 → 随机携带大招
|
||
* 属性走 calcMonsterAttrs(isBoss=true)：HP × BOSS_HP_MUL（超厚血）/ AP × BOSS_AP_MUL
|
||
*/
|
||
private makeBoss(monLv: number, stage: number, spawnIndex: number): GeneratedMonster {
|
||
const range = this.pickBossRange();
|
||
const uuid = this.pickBossUuid(range);
|
||
|
||
const baseInfo = HeroInfo[uuid];
|
||
const baseHp = baseInfo ? baseInfo.hp : 600;
|
||
const baseAp = baseInfo ? baseInfo.ap : 30;
|
||
const attrs = calcMonsterAttrs(baseHp, baseAp, monLv, true);
|
||
|
||
return {
|
||
uuid,
|
||
type: baseInfo?.monType ?? MonType.MeleeBoss,
|
||
hp: attrs.hp,
|
||
ap: attrs.ap,
|
||
isBoss: true,
|
||
lv: monLv,
|
||
spawnIndex,
|
||
batch: 0,
|
||
skills: {
|
||
ults: this.pickBossUlts(range, stage),
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 随机 Boss 攻击定位（近战/中程/远程）
|
||
* 空池自动回退：中程暂无 Boss 配置时落到远程/近战，后续补配即自动生效
|
||
*/
|
||
private pickBossRange(): HType {
|
||
const all: HType[] = [HType.Melee, HType.Mid, HType.Long];
|
||
const first = all[Math.floor(Math.random() * all.length)];
|
||
if (BossPools[first].length > 0) return first;
|
||
// 回退链：随机定位空池时按剩余定位找非空池
|
||
const fallback = all.find(t => BossPools[t].length > 0);
|
||
return fallback ?? HType.Melee;
|
||
}
|
||
|
||
/** 从指定定位池随机取 Boss uuid（含全局兜底） */
|
||
private pickBossUuid(range: HType): number {
|
||
let uuids = BossPools[range];
|
||
if (!uuids || uuids.length === 0) {
|
||
uuids = MonList[MonType.MeleeBoss] || MonList[MonType.Melee] || [6001];
|
||
}
|
||
return uuids[Math.floor(Math.random() * uuids.length)];
|
||
}
|
||
|
||
/**
|
||
* 按定位抽取 Boss 大招（不重复），数量由关卡进度决定（getBossUltCount）
|
||
* @returns 大招配置列表；池空时返回 undefined
|
||
*/
|
||
private pickBossUlts(range: HType, stage: number): GeneratedMonster["skills"]["ults"] {
|
||
const pool = [...(BossUltPools[range] ?? [])];
|
||
const count = Math.min(getBossUltCount(stage), pool.length);
|
||
if (count <= 0) return undefined;
|
||
|
||
const ults: { s_uuid: number; cd?: number; overrides?: SkillOverrides }[] = [];
|
||
for (let i = 0; i < count; i++) {
|
||
const picked = this.pickWeighted(pool);
|
||
if (!picked) break;
|
||
pool.splice(pool.indexOf(picked), 1);
|
||
// 大招 CD 取英雄同档标准档（8s），与英雄大招节奏对齐
|
||
ults.push({ s_uuid: picked.s_uuid, cd: UltCdSet[UltCdLv.Normal].cd, overrides: picked.overrides });
|
||
}
|
||
return ults.length > 0 ? ults : undefined;
|
||
}
|
||
|
||
/** 通用加权随机抽取 */
|
||
private pickWeighted<T extends { weight: number }>(items: T[]): T | null {
|
||
if (items.length === 0) return null;
|
||
const total = items.reduce((s, it) => s + it.weight, 0);
|
||
if (total <= 0) return items[Math.floor(Math.random() * items.length)];
|
||
let r = Math.random() * total;
|
||
for (const it of items) {
|
||
r -= it.weight;
|
||
if (r <= 0) return it;
|
||
}
|
||
return items[items.length - 1];
|
||
}
|
||
}
|
||
|
||
// ======================== 9. 全局单例 ========================
|
||
|
||
export const spawningEngine = new StageSpawningEngine();
|