刷怪 未完成

This commit is contained in:
2025-10-28 23:48:04 +08:00
parent 0121f5b363
commit 166200af73
4 changed files with 219 additions and 270 deletions

View File

@@ -11,301 +11,161 @@
* @date 2025-10-19
*/
import { isModuleNamespaceObject } from "util/types";
import { getMonList, HeroInfo } from "../common/config/heroSet";
import { Attrs } from "../common/config/SkillSet";
import { NATIVE } from "cc/env";
import { BuffConf } from "../common/config/SkillSet";
// 精英怪物配置表
export const EliteMonsterList = [
5201, // 兽人战士
5202, // 兽人刺客
5203, // 兽人护卫
export const EliteMonsterList = [ 5201, 5202, 5203,
// 可以添加更多精英怪物UUID
];
// Boss怪物配置表
export const BossMonsterList = [
5201, // 兽人战士
5202, // 兽人刺客
export const BossMonsterList = [ 5201, 5202,
// 可以添加更多Boss怪物UUID
];
export enum IMons{
ORC=1,
NATIVE=2,
ELF=3,
}
export const Mons={
[IMons.ORC]:[5201,5202],
[IMons.NATIVE]:[5201,5202],
[IMons.ELF]:[5201,5202]
}
/**
* 怪物类型枚举
*/
export enum MonsterType {
NORMAL = "normal", // 普通怪物
ELITE = "elite", // 精英怪物
BOSS = "boss" // Boss怪物
NORMAL = 0, // 普通怪物
ELITE = 1, // 精英怪物
BOSS = 2 // Boss怪物
}
/**
* 关卡类型枚举
*/
export enum StageType {
NORMAL = "normal", // 普通关卡
ELITE = "elite", // 精英关卡
BOSS = "boss", // Boss关卡
EVENT = "event" // 事件关卡
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 = "treasure", // 额外奖励
TRAP = "trap", // 陷阱伤害
BUFF = "buff", // 临时增益效果
DEBUFF = "debuff" // 临时减益效果
TREASURE = 1, // 额外奖励
TRAP =2, // 陷阱伤害
BUFF = 3, // 临时增益效果
DEBUFF = 4 // 临时减益效果
}
/**
* 关卡配置规则 - 增强版,支持怪物数量和强度随关卡递增
* 关卡生怪物相关配置
*/
export const StageConfigRules = {
// 普通关卡
[StageType.NORMAL]: {
description: "普通关卡",
monsters: [
{ type: MonsterType.NORMAL, count: 3, minCount: 2, maxCount: 6 } // 普通怪物数量随关卡递增
]
},
export const StageRule = {
MonsNum: 5, // 关卡中默认怪物数量
/** 额外怪物出现概率在固定5个怪物基础上有概率多刷1个 */
extraMonsterRate: 0.3, // 30%概率出现第6个怪物
// 精英关卡
[StageType.ELITE]: {
description: "精英关卡",
monsters: [
{ type: MonsterType.ELITE, count: 2, minCount: 1, maxCount: 4 }, // 精英怪物
{ type: MonsterType.NORMAL, count: 3, minCount: 2, maxCount: 5 } // 普通怪物
]
},
/** 事件怪物出现概率5个怪物中有1个替换为事件怪 */
eventMonsterRate: 0.25, // 25%概率出现事件怪物
// Boss关卡
[StageType.BOSS]: {
description: "Boss关卡",
monsters: [
{ type: MonsterType.BOSS, count: 1, minCount: 1, maxCount: 1 }, // 1个Boss怪物
{ type: MonsterType.ELITE, count: 2, minCount: 1, maxCount: 3 }, // 精英怪物
{ type: MonsterType.NORMAL, count: 2, minCount: 1, maxCount: 4 } // 普通怪物
]
},
/** 特殊属性怪物出现概率5个怪物中有怪物携带特殊属性 */
specialAttributeRate: 0.4, // 40%概率出现特殊属性怪物
// 事件关卡
[StageType.EVENT]: {
description: "事件关卡",
monsters: [
{ type: MonsterType.NORMAL, count: 2, minCount: 1, maxCount: 4 } // 少量普通怪物
]
/** 特殊属性怪物数量范围 */
specialAttributeCount: { min: 1, max: 2 } // 出现时1-2个怪物会有特殊属性
};
interface IMonsConfig {
/** 怪物波次 */
uuid: number; // 怪物ID
/** 怪物数量 */
buff: BuffConf[]; //附加属性
}
export enum MonAttrSet{
HP_MAX=1.1,
AP=1.05,
MP=1.1,
DEF=1.05,
MDEF=1.05,
MAP=1.05,
}
export const getMonAttr=(lv:number,uuid:number)=>{
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
return {hp:hp,mp:mp,ap:ap,map:map,def:def,mdef:mdef}
}
/**
* 特殊属性类型枚举
*/
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 }
}
};
/**
* 随机事件配置
*/
export const EventConfig = {
[EventType.TREASURE]: {
description: "宝箱事件",
probability: 0.3, // 30%概率触发
effect: "获得额外奖励"
},
[EventType.TRAP]: {
description: "陷阱事件",
probability: 0.25, // 25%概率触发
effect: "受到一定伤害"
},
[EventType.BUFF]: {
description: "增益事件",
probability: 0.25, // 25%概率触发
effect: "获得临时增益效果"
},
[EventType.DEBUFF]: {
description: "减益事件",
probability: 0.2, // 20%概率触发
effect: "受到临时减益效果"
}
};
/**
* 根据关卡号和等级判断关卡类型
* @param stageNumber 关卡号从1开始
* @param level 等级1-5
* @returns 关卡类型
*/
export function getStageType(stageNumber: number, level: number = 1): StageType {
// 每隔5关设置特殊事件关卡
if (stageNumber % 5 === 0 && level === 3) {
return StageType.EVENT;
}
// 第10关的特殊规则
if (stageNumber % 10 === 0) {
if (level === 5) {
return StageType.BOSS; // 第10关第5级为Boss关
} else if (level === 4) {
return StageType.ELITE; // 第10关第4级为精英关
} else {
return StageType.NORMAL; // 第10关1-3级为普通关
}
}
// 1-9关的规则
else {
if (level === 5) {
return StageType.ELITE; // 1-9关第5级为精英关
} else {
return StageType.NORMAL; // 1-9关1-4级为普通关
}
}
}
/**
* 计算怪物数量,随关卡进度递增
* @param stageNumber 关卡号
* @param baseCount 基础数量
* @param minCount 最小数量
* @param maxCount 最大数量
* @returns 实际怪物数量
*/
export function calculateMonsterCount(stageNumber: number, baseCount: number, minCount: number, maxCount: number): number {
// 随关卡递增每5关增加1个怪物最多不超过最大数量
const increment = Math.floor(stageNumber / 5);
let count = baseCount + increment;
// 确保在最小和最大数量之间
count = Math.max(minCount, Math.min(maxCount, count));
return count;
}
/**
* 计算怪物强度倍率,随关卡进度递增
* @param stageNumber 关卡号
* @param level 等级
* @returns 强度倍率
*/
export function calculateMonsterStrengthMultiplier(stageNumber: number, level: number): number {
// 基础倍率基于关卡号和等级
const stageMultiplier = 1 + (stageNumber - 1) * 0.1; // 每关增加10%
const levelMultiplier = 1 + (level - 1) * 0.05; // 每级增加5%
return stageMultiplier * levelMultiplier;
}
/**
* 生成关卡配置
* @param stageNumber 关卡号从1开始
* @param level 等级1-5
* @returns MonsterType数组格式
*/
export function generateStageConfig(stageNumber: number, level: number = 1): MonsterType[] {
const stageType = getStageType(stageNumber, level);
const rule = StageConfigRules[stageType];
const monsterArray: MonsterType[] = [];
// 根据配置生成怪物类型数组
rule.monsters.forEach(monsterGroup => {
// 计算实际怪物数量
const actualCount = calculateMonsterCount(
stageNumber,
monsterGroup.count,
monsterGroup.minCount,
monsterGroup.maxCount
);
for (let i = 0; i < actualCount; i++) {
monsterArray.push(monsterGroup.type);
}
});
return monsterArray;
}
/**
* 根据怪物类型获取对应配置表中的怪物UUID数组
* @param monsterType 怪物类型
* @returns 怪物UUID数组
*/
export function getMonsterUUIDsByType(monsterType: MonsterType): number[] {
switch (monsterType) {
case MonsterType.NORMAL:
// 普通怪物使用原有的getMonList方法
return getMonList();
case MonsterType.ELITE:
// 精英怪物使用精英配置表
return EliteMonsterList;
case MonsterType.BOSS:
// Boss怪物使用Boss配置表
return BossMonsterList;
default:
return [];
}
}
/**
* 获取当前关卡对应的所有怪物UUID数组
* @param stageNumber 关卡号
* @param level 等级1-5
* @returns 怪物UUID数组按关卡配置顺序排列
*/
export function getStageMonsterUUIDs(stageNumber: number, level: number = 1): number[] {
const monsterTypes = generateStageConfig(stageNumber, level);
const monsterUUIDs: number[] = [];
monsterTypes.forEach(monsterType => {
const availableUUIDs = getMonsterUUIDsByType(monsterType);
if (availableUUIDs.length > 0) {
// 随机选择一个该类型的怪物
const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
monsterUUIDs.push(randomUUID);
}
});
return monsterUUIDs;
}
/**
* 获取关卡怪物配置包含UUID和强度信息
* @param stageNumber 关卡号
* @param level 等级1-5
* @returns 怪物配置数组
*/
export function getStageMonsterConfigs(stageNumber: number, level: number = 1) {
const monsterTypes = generateStageConfig(stageNumber, level);
const monsterConfigs = [];
// 计算强度倍率
const strengthMultiplier = calculateMonsterStrengthMultiplier(stageNumber, level);
monsterTypes.forEach((monsterType, index) => {
const availableUUIDs = getMonsterUUIDsByType(monsterType);
if (availableUUIDs.length > 0) {
const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
monsterConfigs.push({
uuid: randomUUID,
type: monsterType,
stageNumber: stageNumber,
level: level,
strengthMultiplier: strengthMultiplier // 强度倍率
});
}
});
return monsterConfigs;
}
/**
* 随机决定是否触发事件
* @returns 事件类型或null
*/
export function getRandomEvent(): EventType | null {
const random = Math.random();
let cumulativeProbability = 0;
for (const eventType in EventConfig) {
cumulativeProbability += EventConfig[eventType].probability;
if (random <= cumulativeProbability) {
return eventType as EventType;
}
}
return null; // 不触发事件
}