pan/heros
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(怪物系统): 重构怪物生成逻辑并添加多种怪物类型

Browse Source 
重构怪物生成系统，使用MonType枚举替代原有布尔标记
添加6种怪物类型配置和属性计算规则
修改关卡配置生成逻辑，支持精英/Boss波次
新增多种怪物配置并调整原有怪物属性
This commit is contained in:
panw
2025-10-29 16:41:08 +08:00
parent 68b9c1924b
commit 9dc1126dfe
4 changed files with 161 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
assets/script/game/map/MissionMonComp.ts
View File

@@ -6,11 +6,9 @@ import { MonSet } from "../common/config/heroSet";
import { smc } from "../common/SingletonModuleComp";
import { GameEvent } from "../common/config/GameEvent";
// 导入肉鸽配置
import {
MonsterType,
EventType,
} from "./RogueConfig";
import { MonType, EventType, getStageMonConfigs} from "./RogueConfig";
import { MonModelComp } from "../hero/MonModelComp";
import { BuffConf } from "../common/config/SkillSet";
const { ccclass, property } = _decorator;
@@ -19,12 +17,12 @@ const { ccclass, property } = _decorator;
@ecs.register('MissionMonComp', false)
export class MissionMonCompComp extends CCComp {
// 添加刷怪队列 - 使用新的RogueConfig格式
private monsterQueue: Array<{
private MonQueue: Array<{
uuid: number,
position: number,
type: MonsterType,
type: MonType
level: number,
strengthMultiplier: number
buffs: BuffConf[]
}> = [];
private isSpawning: boolean = false;// 是否正在生成怪物
private spawnInterval: number = 0.1; // 每个怪物生成间隔时间
@@ -58,12 +56,12 @@ export class MissionMonCompComp extends CCComp {
// 处理随机事件
if (this.currentEvent && !this.eventProcessed) {
this.processRandomEvent();
this.eventProcessed = true;
}
// 处理刷怪队列
if (this.monsterQueue.length > 0 && !this.isSpawning) {
if (this.MonQueue.length > 0 && !this.isSpawning) {
this.spawnTimer += dt;
// 检查是否需要暂停（每召唤5次后暂停5秒）
@@ -100,64 +98,31 @@ export class MissionMonCompComp extends CCComp {
this.spawnTimer = 0;
this.eventProcessed = false;
const currentStage = smc.data.mission;
const cStage = smc.data.mission;
// 使用新的肉鸽关卡配置
let level=smc.vmdata.mission_data.level
const stageType = getStageType(currentStage,level);
// 检查是否为事件关卡
if (stageType === "event") {
this.currentEvent = getRandomEvent();
} else {
this.currentEvent = null;
}
const monsterConfigs = getStageMonsterConfigs(currentStage,level);
// console.log(`[MissionMonComp]:第${currentStage}关 - ${stageType}类型，怪物数量: ${monsterConfigs.length}`);
this.generateMonstersFromStageConfig(monsterConfigs);
const monsConf = getStageMonConfigs(cStage);
// console.log(`[MissionMonComp]:第${cStage}关 - ${stageType}类型，怪物数量: ${monsConf.length}`);
this.generateMonsters(monsConf);
}
// 处理随机事件
private processRandomEvent() {
if (!this.currentEvent) return;
switch (this.currentEvent) {
case EventType.TREASURE:
// 发送获得奖励事件
smc.vmdata.mission_data.gold += 50; // 增加50金币
// 可以触发UI提示
// oops.message.dispatchEvent("event_treasure");
break;
case EventType.TRAP:
// 对玩家造成伤害
// 这里可以实现对玩家英雄造成伤害的逻辑
// oops.message.dispatchEvent("event_trap");
break;
case EventType.BUFF:
// 给玩家增加临时增益效果
// oops.message.dispatchEvent("event_buff");
break;
case EventType.DEBUFF:
// 给玩家增加临时减益效果
// oops.message.dispatchEvent("event_debuff");
break;
}
}
// 根据新的关卡配置生成怪物
private generateMonstersFromStageConfig(monsterConfigs: any[]) {
const currentStage = smc.data.mission;
private generateMonsters(monsConf: any[]) {
const cStage = smc.data.mission;
// 设置怪物总数
// console.log("[MissionMonComp] generateMonstersFromStageConfig",monsterConfigs)
if (!monsterConfigs || monsterConfigs.length === 0) {
console.warn(`[MissionMonComp]:关卡${currentStage}配置中没有怪物信息`);
// console.log("[MissionMonComp] generateMonsters",monsConf)
if (!monsConf || monsConf.length === 0) {
console.warn(`[MissionMonComp]:关卡${cStage}配置中没有怪物信息`);
return;
}
// 为每个怪物配置生成怪物
monsterConfigs.forEach((monsterConfig: any, index: number) => {
const { uuid, type, strengthMultiplier } = monsterConfig;
monsConf.forEach((mon: any, index: number) => {
const { uuid, type,level, buffs } = mon;
// 位置循环使用 (0-4)
const position = index % 5;
@@ -166,70 +131,68 @@ export class MissionMonCompComp extends CCComp {
uuid,
position,
type,
1, // 默认等级1
strengthMultiplier // 强度倍率
level, // 默认等级1
buffs // 强度倍率
);
});
// console.log(`[MissionMonComp]:关卡${currentStage}将生成 ${monsterConfigs.length} 只怪物`);
// console.log(`[MissionMonComp]:关卡${cStage}将生成 ${monsConf.length} 只怪物`);
}
// 添加到关卡刷怪队列 - 使用新的配置格式
private addToStageSpawnQueue(
uuid: number,
position: number,
type: MonsterType,
type: MonType,
level: number = 1,
strengthMultiplier: number = 1.0
buffs: BuffConf[] = []
) {
this.monsterQueue.push({
this.MonQueue.push({
uuid: uuid,
position: position,
type: type,
level: level,
strengthMultiplier: strengthMultiplier
buffs: buffs
});
}
// 从队列中生成下一个怪物 - 使用新的配置格式
private spawnNextMonster() {
if (this.monsterQueue.length === 0) return;
if (this.MonQueue.length === 0) return;
const monsterData = this.monsterQueue.shift();
const monsterData = this.MonQueue.shift();
if (monsterData) {
const isBoss = monsterData.type === MonsterType.BOSS;
this.addMonster(
monsterData.uuid,
monsterData.position,
isBoss,
false,
monsterData.type,
monsterData.level,
monsterData.strengthMultiplier
monsterData.buffs
);
// 增加召唤计数
this.spawnCount++;
// console.log(`[MissionMonComp]: 召唤第${this.spawnCount}只${monsterData.type}怪物，剩余队列: ${this.monsterQueue.length}`);
// console.log(`[MissionMonComp]: 召唤第${this.spawnCount}只${monsterData.type}怪物，剩余队列: ${this.MonQueue.length}`);
}
}
private addMonster(
uuid: number = 1001,
i: number = 0,
is_boss: boolean = false,
is_call: boolean = false,
monType: MonType = MonType.NORMAL,
lv: number = 1,
strengthMultiplier: number = 1.0
buffs: BuffConf[] = []
) {
let mon = ecs.getEntity<Monster>(Monster);
let scale = -1;
let pos: Vec3 = v3(MonSet[i].pos);
// 生成怪物
mon.load(pos,scale,uuid,is_boss,is_call,strengthMultiplier);
mon.load(pos,scale,uuid,lv,monType,buffs);
}
/** 视图对象通过 ecs.Entity.remove(ModuleViewComp) 删除组件是触发组件处理自定义释放逻辑 */
reset() {
// this.node.destroy();

157
assets/script/game/map/RogueConfig.ts
View File

@@ -11,54 +11,28 @@
* @date 2025-10-19
*/
import { isModuleNamespaceObject } from "util/types";
import { getMonList, HeroInfo } from "../common/config/heroSet";
import { NATIVE } from "cc/env";
import { BuffConf } from "../common/config/SkillSet";
// 精英怪物配置表
export const EliteMons = [ 5201, 5202, 5203,
// 可以添加更多精英怪物UUID
];
export const EliteMons = [ 5201, 5202, 5203, 5213 ];
// Boss怪物配置表
export const BossMons = [ 5201, 5202,
// 可以添加更多Boss怪物UUID
];
export enum IMons{
ORC=1,
NATIVE=2,
ELF=3,
}
export const BossMons = [ 5201, 5202, ];
export enum IMons{ ORC=1, HUMAN=2, ELF=3,}
export const Mons={
[IMons.ORC]:[5201,5202],
[IMons.NATIVE]:[5201,5202],
[IMons.HUMAN]:[5201,5202],
[IMons.ELF]:[5201,5202]
}
/**
* 怪物类型枚举
*/
export enum MonType {
NORMAL = 0, // 普通怪物
ELITE = 1, // 精英怪物
BOSS = 2 // Boss怪物
}
export enum MonType { NORMAL = 0, ELITE = 1, BOSS = 2 }
export const EliteStage =[5,10,15,20,25]
export const BossStage=[30,40,50,60,70,80,90,100]
/**
* 关卡类型枚举
*/
export const EliteStage:any =(wave:number) => {
if(wave%5 == 0) return true
return false
}
export const BossStage:any =(wave:number) => {
if(wave%10 == 0) return true
return false
}
/**
* 随机事件类型枚举
*/
export enum EventType {
TREASURE = 1, // 额外奖励
TRAP =2, // 陷阱伤害
@@ -71,6 +45,7 @@ export enum EventType {
*/
export const StageRule = {
MonsNum: 5, // 关卡中默认怪物数量
LimitMonNum: 10, // 30关以后是极限模式，怪物数量
/** 额外怪物出现概率（在固定5个怪物基础上，有概率多刷1个） */
extraMonsterRate: 0.3, // 30%概率出现第6个怪物
/** 事件怪物出现概率（5个怪物中有1个替换为事件怪） */
@@ -89,58 +64,56 @@ interface IMonsConfig {
/** 怪物等级 */
level: number; // 怪物等级
/** 是否为精英怪物 */
isElite?: boolean; // 是否为精英怪物
/** 是否为Boss怪物 */
isBoss?: boolean; // 是否为Boss怪物
monType:MonType;
}
export enum MonAttrSet{
HP_MAX=1.1,
AP=1.05,
MP=1.1,
DEF=1.05,
MDEF=1.05,
MAP=1.05,
export const MonAttrSet={
[MonType.NORMAL]:{ HP_MAX:1.1, AP:1.05, MP:1.1, DEF:1.05, MDEF:1.05, MAP:1.05,},
[MonType.ELITE]: { HP_MAX:2, AP:1.1, MP:1.1, DEF:1.1, MDEF:1.1, MAP:1.1,},
[MonType.BOSS]: { HP_MAX:5, AP:2, MP:5, DEF:2, MDEF:2, MAP:2,},
}
export const getMonAttr=(lv:number,uuid:number)=>{
export const MonBuffSet={
}
export const getMonAttr=(lv:number,uuid:number,MonType:MonType)=>{
let mon=HeroInfo[uuid]
let hp=mon.hp*lv*MonAttrSet.HP_MAX
let mp=mon.mp*lv*MonAttrSet.MP
let ap=mon.ap*lv*MonAttrSet.AP
let map=mon.map*lv*MonAttrSet.MAP
let def=mon.def*lv*MonAttrSet.DEF
let mdef=mon.mdef*lv*MonAttrSet.MDEF
let hp=mon.hp*lv*MonAttrSet[MonType].HP_MAX
let mp=mon.mp*lv*MonAttrSet[MonType].MP
let ap=mon.ap*lv*MonAttrSet[MonType].AP
let map=mon.map*lv*MonAttrSet[MonType].MAP
let def=mon.def*lv*MonAttrSet[MonType].DEF
let mdef=mon.mdef*lv*MonAttrSet[MonType].MDEF
return {hp:hp,mp:mp,ap:ap,map:map,def:def,mdef:mdef}
}
/**
* 根据波次生成怪物配置
* @param wave 当前波次
* @param stage 当前波次
* @returns IMonsConfig数组
*/
export function getStageMonsterConfigs(wave: number): IMonsConfig[] {
export function getStageMonConfigs(stage: number): IMonsConfig[] {
const monsterConfigs: IMonsConfig[] = [];
// 确定基础怪物数量
let baseMonsterCount = StageRule.MonsNum;
// 判断是否为Boss波次
const isBossWave = BossStage(wave);
const isBossStage = BossStage.includes(stage);
// 判断是否为精英波次
const isEliteWave = EliteStage(wave);
const isEliteStage = EliteStage.includes(stage);
// 如果是Boss波次，增加一个Boss怪物
if (isBossWave) {
if (isBossStage) {
// 从Boss怪物列表中随机选择一个
const bossUUID = BossMons[Math.floor(Math.random() * BossMons.length)] || 5201;
monsterConfigs.push({
uuid: bossUUID,
buff: [],
level: wave, // Boss等级等于波次
isBoss: true
level: stage, // Boss等级等于波次
monType: MonType.BOSS
});
// Boss波次减少普通怪物数量
@@ -148,16 +121,16 @@ export function getStageMonsterConfigs(wave: number): IMonsConfig[] {
}
// 如果是精英波次，增加精英怪物
if (isEliteWave) {
if (isEliteStage) {
// 添加1-2个精英怪物
const eliteCount = isBossWave ? 1 : Math.floor(Math.random() * 2) + 1;
const eliteCount = isBossStage ? 1 : Math.floor(Math.random() * 2) + 1;
for (let i = 0; i < eliteCount; i++) {
const eliteUUID = EliteMons[Math.floor(Math.random() * EliteMons.length)] || 5201;
monsterConfigs.push({
uuid: eliteUUID,
buff: [],
level: wave, // 精英等级等于波次
isElite: true
level: stage, // 精英等级等于波次
monType: MonType.ELITE
});
}
@@ -177,7 +150,8 @@ export function getStageMonsterConfigs(wave: number): IMonsConfig[] {
monsterConfigs.push({
uuid: normalUUID,
buff: [],
level: wave // 普通怪物等级等于波次
level: stage, // 普通怪物等级等于波次
monType: MonType.NORMAL
});
}
@@ -191,7 +165,8 @@ export function getStageMonsterConfigs(wave: number): IMonsConfig[] {
monsterConfigs.push({
uuid: extraUUID,
buff: [],
level: wave
level: stage,
monType: MonType.NORMAL
});
}
@@ -199,59 +174,5 @@ export function getStageMonsterConfigs(wave: number): IMonsConfig[] {
}
/**
* 特殊属性类型枚举
*/
export enum SpecialAttribute {
NONE = 0, // 无特殊属性
FAST = 1, // 快速移动
STRONG = 2, // 强力攻击
TANKY = 3, // 高生命值
REGENERATE = 4, // 生命恢复
SHIELD = 5, // 护盾
EXPLOSIVE = 6, // 爆炸伤害（死亡时）
VAMPIRE = 7 // 吸血
}
/**
* 特殊属性配置
*/
export const SpecialAttributeConfig = {
[SpecialAttribute.FAST]: {
name: "疾行",
description: "移动速度提升50%",
effect: { speedMultiplier: 1.5 }
},
[SpecialAttribute.STRONG]: {
name: "强力",
description: "攻击力提升30%",
effect: { attackMultiplier: 1.3 }
},
[SpecialAttribute.TANKY]: {
name: "坦克",
description: "生命值提升50%",
effect: { hpMultiplier: 1.5 }
},
[SpecialAttribute.REGENERATE]: {
name: "再生",
description: "每秒恢复最大生命值2%",
effect: { regenRate: 0.02 }
},
[SpecialAttribute.SHIELD]: {
name: "护盾",
description: "拥有相当于30%最大生命值的护盾",
effect: { shieldRatio: 0.3 }
},
[SpecialAttribute.EXPLOSIVE]: {
name: "爆炸",
description: "死亡时对周围造成范围伤害",
effect: { explosionDamageRatio: 0.5 }
},
[SpecialAttribute.VAMPIRE]: {
name: "吸血",
description: "攻击时恢复造成伤害20%的生命值",
effect: { vampireRatio: 0.2 }
}
};