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

奖励已经双倍奖励

Browse Source
This commit is contained in:
panfudan
2025-08-19 19:40:34 +08:00
parent 22f35893d7
commit 854affeaae
32 changed files with 12848 additions and 7746 deletions
Download Patch File Download Diff File Expand all files Collapse all files

402
assets/script/game/common/GameDataSyncManager.ts
View File

@@ -1,3 +1,4 @@
import { oops } from "db://oops-framework/core/Oops";
import { WxCloudApi ,UserGameData} from "../wx_clound_client_api/WxCloudApi";
import { smc } from "./SingletonModuleComp";
@@ -47,7 +48,7 @@ export class GameDataSyncManager {
// 直接覆盖道具数据
if (remoteData.items) {
Object.assign(smc.itmes, remoteData.items);
Object.assign(smc.items, remoteData.items);
console.log(`[Initialize]: 道具数据已从${dataSource}覆盖`);
}
@@ -238,183 +239,6 @@ export class GameDataSyncManager {
}
}
/**
* 删除指定英雄
* @param heroId 英雄ID
* @returns 是否成功
*/
async deleteHero(heroId: number): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 删除英雄 ID:${heroId}`);
const result = await WxCloudApi.deleteHero(heroId);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
delete smc.heros[heroId];
console.log(`[GameDataSyncManager]: 英雄删除成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 英雄删除失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 删除英雄异常:`, error);
return false;
}
}
// ==================== 库存管理 (items, tals, equips) ====================
/**
* 增加指定物品的数量
* @param type 库存类型 ('items', 'tals', 'equips')
* @param itemId 物品ID
* @param count 添加数量
* @returns 是否成功
*/
async addInventoryItem(type: 'items' | 'tals' | 'equips', itemId: number, count: number): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 增加库存物品 类型:${type}, ID:${itemId}, 数量:${count}`);
const result = await WxCloudApi.addInventoryItem(type, itemId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
const targetData = this.getTargetData(type);
targetData[itemId] = (targetData[itemId] || 0) + count;
console.log(`[GameDataSyncManager]: 库存物品增加成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 库存物品增加失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 增加库存物品异常:`, error);
return false;
}
}
/**
* 消耗指定数量的物品
* @param type 库存类型 ('items', 'tals', 'equips')
* @param itemId 物品ID
* @param count 消耗数量
* @returns 是否成功
*/
async consumeInventoryItem(type: 'items' | 'tals' | 'equips', itemId: number, count: number): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 消耗库存物品 类型:${type}, ID:${itemId}, 数量:${count}`);
const result = await WxCloudApi.consumeInventoryItem(type, itemId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
const targetData = this.getTargetData(type);
targetData[itemId] = Math.max(0, (targetData[itemId] || 0) - count);
console.log(`[GameDataSyncManager]: 库存物品消耗成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 库存物品消耗失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 消耗库存物品异常:`, error);
return false;
}
}
/**
* 直接设置物品的数量
* @param type 库存类型 ('items', 'tals', 'equips')
* @param itemId 物品ID
* @param count 新的数量
* @returns 是否成功
*/
async setInventoryItem(type: 'items' | 'tals' | 'equips', itemId: number, count: number): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 设置库存物品 类型:${type}, ID:${itemId}, 数量:${count}`);
const result = await WxCloudApi.setInventoryItem(type, itemId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
const targetData = this.getTargetData(type);
targetData[itemId] = count;
console.log(`[GameDataSyncManager]: 库存物品设置成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 库存物品设置失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 设置库存物品异常:`, error);
return false;
}
}
/**
* 批量更新多个物品的数量
* @param type 库存类型 ('items', 'tals', 'equips')
* @param data 更新数据对象
* @param merge 是否合并更新（默认true）
* @returns 是否成功
*/
async updateInventory(type: 'items' | 'tals' | 'equips', data: any, merge: boolean = true): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 批量更新库存 类型:${type}, 数据:`, data);
const result = await WxCloudApi.updateInventory(type, data, merge);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
const targetData = this.getTargetData(type);
if (merge) {
Object.assign(targetData, data);
} else {
Object.keys(targetData).forEach(key => delete targetData[key]);
Object.assign(targetData, data);
}
console.log(`[GameDataSyncManager]: 库存批量更新成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 库存批量更新失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 批量更新库存异常:`, error);
return false;
}
}
/**
* 重置指定类型的库存为默认值
* @param type 库存类型 ('items', 'tals', 'equips')
* @returns 是否成功
*/
async resetInventory(type: 'items' | 'tals' | 'equips'): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 重置库存 类型:${type}`);
const result = await WxCloudApi.resetInventory(type);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
const targetData = this.getTargetData(type);
Object.keys(targetData).forEach(key => delete targetData[key]);
Object.assign(targetData, result.result.data);
console.log(`[GameDataSyncManager]: 库存重置成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 库存重置失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 重置库存异常:`, error);
return false;
}
}
// ==================== 便捷方法 ====================
/**
@@ -424,7 +248,22 @@ export class GameDataSyncManager {
* @returns 是否成功
*/
async addItem(itemId: number, count: number): Promise<boolean> {
return this.addInventoryItem('items', itemId, count);
smc.items[itemId] = (smc.items[itemId] || 0) + count;
try {
console.log(`[GameDataSyncManager]: 增加道具 ID:${itemId}, 数量:${count}`);
const result = await WxCloudApi.addInventoryItem('items', itemId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
console.log(`[GameDataSyncManager]: 道具增加成功`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 道具增加失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 增加道具异常:`, error);
return false;
}
}
/**
@@ -434,9 +273,30 @@ export class GameDataSyncManager {
* @returns 是否成功
*/
async consumeItem(itemId: number, count: number): Promise<boolean> {
return this.consumeInventoryItem('items', itemId, count);
if(!smc.items[itemId]||smc.items[itemId]<count){
oops.gui.toast("道具数量不足")
return false
}
try {
console.log(`[GameDataSyncManager]: 消耗道具 ID:${itemId}, 数量:${count}`);
const result = await WxCloudApi.consumeInventoryItem('items', itemId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.items[itemId] = Math.max(0, (smc.items[itemId] || 0) - count);
console.log(`[GameDataSyncManager]: 道具消耗成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 道具消耗失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 消耗道具异常:`, error);
return false;
}
}
/**
* 增加天赋点
* @param talId 天赋ID
@@ -444,7 +304,24 @@ export class GameDataSyncManager {
* @returns 是否成功
*/
async addTalent(talId: number, count: number): Promise<boolean> {
return this.addInventoryItem('tals', talId, count);
try {
console.log(`[GameDataSyncManager]: 增加天赋点 ID:${talId}, 数量:${count}`);
const result = await WxCloudApi.addInventoryItem('tals', talId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.tals[talId] = (smc.tals[talId] || 0) + count;
console.log(`[GameDataSyncManager]: 天赋点增加成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 天赋点增加失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 增加天赋点异常:`, error);
return false;
}
}
/**
@@ -454,7 +331,51 @@ export class GameDataSyncManager {
* @returns 是否成功
*/
async consumeTalent(talId: number, count: number): Promise<boolean> {
return this.consumeInventoryItem('tals', talId, count);
try {
console.log(`[GameDataSyncManager]: 消耗天赋点 ID:${talId}, 数量:${count}`);
const result = await WxCloudApi.consumeInventoryItem('tals', talId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.tals[talId] = Math.max(0, (smc.tals[talId] || 0) - count);
console.log(`[GameDataSyncManager]: 天赋点消耗成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 天赋点消耗失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 消耗天赋点异常:`, error);
return false;
}
}
/**
* 设置天赋点数量
* @param talId 天赋ID
* @param count 数量
* @returns 是否成功
*/
async setTalent(talId: number, count: number): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 设置天赋点数量 ID:${talId}, 数量:${count}`);
const result = await WxCloudApi.setInventoryItem('tals', talId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.tals[talId] = count;
console.log(`[GameDataSyncManager]: 天赋点数量设置成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 天赋点数量设置失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 设置天赋点数量异常:`, error);
return false;
}
}
/**
@@ -464,7 +385,24 @@ export class GameDataSyncManager {
* @returns 是否成功
*/
async addEquipment(equipId: number, count: number): Promise<boolean> {
return this.addInventoryItem('equips', equipId, count);
try {
console.log(`[GameDataSyncManager]: 增加装备 ID:${equipId}, 数量:${count}`);
const result = await WxCloudApi.addInventoryItem('equips', equipId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.equips[equipId] = (smc.equips[equipId] || 0) + count;
console.log(`[GameDataSyncManager]: 装备增加成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 装备增加失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 增加装备异常:`, error);
return false;
}
}
/**
@@ -474,29 +412,55 @@ export class GameDataSyncManager {
* @returns 是否成功
*/
async consumeEquipment(equipId: number, count: number): Promise<boolean> {
return this.consumeInventoryItem('equips', equipId, count);
}
// ==================== 私有辅助方法 ====================
/**
* 根据类型获取对应的目标数据对象
* @param type 库存类型
* @returns 对应的数据对象
*/
private getTargetData(type: 'items' | 'tals' | 'equips'): any {
switch (type) {
case 'items':
return smc.itmes;
case 'tals':
return smc.tals;
case 'equips':
return smc.equips;
default:
throw new Error(`未知的库存类型: ${type}`);
try {
console.log(`[GameDataSyncManager]: 消耗装备 ID:${equipId}, 数量:${count}`);
const result = await WxCloudApi.consumeInventoryItem('equips', equipId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.equips[equipId] = Math.max(0, (smc.equips[equipId] || 0) - count);
console.log(`[GameDataSyncManager]: 装备消耗成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 装备消耗失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 消耗装备异常:`, error);
return false;
}
}
/**
* 设置装备数量
* @param equipId 装备ID
* @param count 数量
* @returns 是否成功
*/
async setEquipment(equipId: number, count: number): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 设置装备数量 ID:${equipId}, 数量:${count}`);
const result = await WxCloudApi.setInventoryItem('equips', equipId, count);
if (result.result.code === 200) {
// 远程修改成功，同步本地数据
smc.equips[equipId] = count;
console.log(`[GameDataSyncManager]: 装备数量设置成功，本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 装备数量设置失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 设置装备数量异常:`, error);
return false;
}
}
/**
* 从云端加载所有游戏数据并同步到本地
* @returns 是否成功
@@ -513,7 +477,7 @@ export class GameDataSyncManager {
smc.data = cloudData.data;
smc.fight_heros = cloudData.fight_heros;
smc.heros = cloudData.heros;
smc.itmes = cloudData.items;
smc.items = cloudData.items;
smc.tals = cloudData.tals;
smc.equips = cloudData.equips;
@@ -545,23 +509,31 @@ export const gameDataSyncManager = GameDataSyncManager.getInstance();
使用示例：
// 1. 出战英雄管理
await gameDataSyncManager.setFightHero(0, 5001); // 设置位置0的英雄
await gameDataSyncManager.swapFightHeros(0, 1); // 交换位置0和1的英雄
await gameDataSyncManager.updateFightHeros({0: 5001, 1: 5005}); // 批量更新
await gameDataSyncManager.resetFightHeros(); // 重置为默认配置
// 2. 英雄管理
await gameDataSyncManager.addHero(5008, {uuid: 5008, lv: 1}); // 添加新英雄
await gameDataSyncManager.levelUpHero(5001, 5); // 英雄升级5级
await gameDataSyncManager.setHeroProperty(5001, "exp", 1000); // 设置英雄经验
await gameDataSyncManager.addHero(5008, {uuid: 5008, lv: 1}); // 添加新英雄
await gameDataSyncManager.levelUpHero(5001, 100, 50, 5); // 英雄升级5级
await gameDataSyncManager.setHeroProperty(5001, "exp", 1000); // 设置英雄经验
// 3. 库存管理
// 3. 道具管理 (items)
await gameDataSyncManager.addItem(1001, 10); // 增加道具
await gameDataSyncManager.consumeItem(1001, 2); // 消耗道具
await gameDataSyncManager.addTalent(2001, 5); // 增加天赋点
await gameDataSyncManager.addEquipment(3001, 2); // 增加装备
await gameDataSyncManager.consumeItem(1001, 2); // 消耗道具
await gameDataSyncManager.setItem(1001, 5); // 设置道具数量
// 4. 数据加载
await gameDataSyncManager.loadAllGameData(); // 从云端加载所有数据
// 4. 天赋点管理 (tals)
await gameDataSyncManager.addTalent(2001, 5); // 增加天赋点
await gameDataSyncManager.consumeTalent(2001, 2); // 消耗天赋点
await gameDataSyncManager.setTalent(2001, 10); // 设置天赋点数量
// 5. 装备管理 (equips)
await gameDataSyncManager.addEquipment(3001, 2); // 增加装备
await gameDataSyncManager.consumeEquipment(3001, 1); // 消耗装备
await gameDataSyncManager.setEquipment(3001, 3); // 设置装备数量
// 6. 数据加载
await gameDataSyncManager.loadAllGameData(); // 从云端加载所有数据
注意：所有方法都返回 Promise<boolean>，true表示成功，false表示失败
只有在远程修改成功后，本地数据才会被同步修改

19
assets/script/game/common/SingletonModuleComp.ts
View File

@@ -42,7 +42,7 @@ export class SingletonModuleComp extends ecs.Comp {
5005:{uuid:5005,lv:1},
5007:{uuid:5007,lv:1},
};
itmes:any={
items:any={
}
tals:any={
}
@@ -151,10 +151,17 @@ export class SingletonModuleComp extends ecs.Comp {
// ==================== 统一的数据操作接口 ====================
/**
* 增加游戏数据属性（统一接口）
* @param property 属性名
* property list:
* ***gold:金币
* ***diamond:钻石
* ***meat:肉
* ***exp:经验
* ***score:分数
* ***mission:关卡
* @param value 增加的值
* @param autoSave 是否自动保存 (默认true)
* @returns 操作结果
@@ -221,6 +228,14 @@ export class SingletonModuleComp extends ecs.Comp {
return true;
}
addItem(item_uuid:number,count:number,autoSave:boolean=true){
if(this.isWxClient()){
this.gameDataSyncManager.addItem(item_uuid,count);
}
else{
this.items[item_uuid] = (this.items[item_uuid] || 0) + count;
}
}
}

2
assets/script/game/common/config/GameUIConfig.ts
View File

@@ -19,6 +19,7 @@ export enum UIID {
HeroInfo,
Victory,
HeroSelect,
ItemInfo,
// Shop_Page,
// Hero_Page,
}
@@ -32,6 +33,7 @@ export var UIConfigData: { [key: number]: UIConfig } = {
[UIID.HeroInfo]: { layer: LayerType.UI, prefab: "gui/Hinfo" },
[UIID.Victory]: { layer: LayerType.UI, prefab: "gui/element/victory" },
[UIID.HeroSelect]: { layer: LayerType.UI, prefab: "gui/hero_select" },
[UIID.ItemInfo]: { layer: LayerType.UI, prefab: "gui/element/item_info" },
// [UIID.Shop_Page]: { layer: LayerType.UI, prefab: "gui/shop_page" },
// [UIID.Hero_Page]: { layer: LayerType.UI, prefab: "gui/heros_page" },
// [UIID.Toast]: { layer: LayerType.PopUp, prefab: "common/prefab/toast" },

240
assets/script/game/common/config/Items.ts
View File

@@ -1,31 +1,217 @@
/*
type:
1 普通消耗品，武器升级或技能升级原材料
2 可双击打开，如宝箱，
ghstone:0, //英雄石 绿色 普通英雄升星
bhstone:0, //英雄石 蓝色 稀有英雄升星
phlestone:0, //英雄石 紫色 史诗英雄升星
rhstone:0, //英雄石 红色 传说英雄升星
herocard:0, //英雄卡,抽卡凭证
ckey:0, //铜钥匙 解锁稀有英雄 也可以直接兑换金币
skey:0, //银钥匙 解锁史诗英雄 也可以直接兑换金币
gkey:0, //金钥匙 解锁传说英雄 也可以直接兑换金币
*/
import * as exp from "constants";
import { QualitySet } from "./BoxSet";
export const Items={
1001:{uuid: 1001,path: "1001",type:1,quality:QualitySet.GREEN,name: "经验药水",info:"增加英雄经验", },
1002:{uuid: 1002,path: "1002",type:1,quality:QualitySet.BLUE,name: "绿色英雄石",info:"稀有英雄升星必须材料", },
1003:{uuid: 1003,path: "1003",type:1,quality:QualitySet.BLUE,name: "蓝色英雄石",info:"史诗英雄升星必须材料", },
1004:{uuid: 1004,path: "1004",type:1,quality:QualitySet.PURPLE,name: "紫色英雄石",info:"传说英雄升星必须材料", },
1005:{uuid: 1005,path: "1005",type:1,quality:QualitySet.ORANGE,name: "红色英雄石",info:"传说英雄升星必须材料", },
1006:{uuid: 1006,path: "1006",type:1,quality:QualitySet.GREEN,name: "招募劵",info:"可以在英雄酒馆招募英雄", },
1007:{uuid: 1007,path: "1007",type:1,quality:QualitySet.BLUE,name: "铜钥匙",info:"解锁稀有英雄 也可以直接兑换金币", },
1008:{uuid: 1008,path: "1008",type:1,quality:QualitySet.PURPLE,name: "银钥匙",info:"解锁史诗英雄 也可以直接兑换金币", },
1009:{uuid: 1009,path: "1009",type:1,quality:QualitySet.ORANGE,name: "金钥匙",info:"解锁传说英雄 也可以直接兑换金币", },
export enum ItemType{
NORMAL=0,//普通
SPECIAL=1,//特殊 可双击打开
EQUIP=2,//装备
}
// 掉落物品接口
export interface DropItem {
item_uuid: number; // 物品ID
probability: number; // 掉落概率 (0-1之间)
minCount: number; // 最小掉落数量
maxCount: number; // 最大掉落数量
baseCount: number; // 基础掉落数量
growthRate: number; // 增长参数
}
// 怪物掉落配置接口
export interface MonsterDropConfig {
monsterId: number; // 怪物ID
quality: QualitySet; // 怪物品质
drops: DropItem[]; // 掉落物品列表
}
export const Items={
1001:{uuid: 1001,path: "1001",type:1,quality:QualitySet.GREEN,name: "绿色英雄石",info:"稀有英雄升星必须材料", },
1002:{uuid: 1002,path: "1002",type:1,quality:QualitySet.BLUE,name: "蓝色英雄石",info:"史诗英雄升星必须材料", },
1003:{uuid: 1003,path: "1003",type:1,quality:QualitySet.PURPLE,name: "紫色英雄石",info:"传说英雄升星必须材料", },
1004:{uuid: 1004,path: "1004",type:1,quality:QualitySet.ORANGE,name: "红色英雄石",info:"传说英雄升星必须材料", },
1005:{uuid: 1005,path: "1005",type:1,quality:QualitySet.ORANGE,name: "招募劵",info:"可以在英雄酒馆招募英雄", },
1006:{uuid: 1006,path: "1006",type:1,quality:QualitySet.BLUE,name: "铜钥匙",info:"解锁稀有英雄 也可以直接兑换金币", },
1007:{uuid: 1007,path: "1007",type:1,quality:QualitySet.PURPLE,name: "银钥匙",info:"解锁史诗英雄 也可以直接兑换金币", },
1008:{uuid: 1008,path: "1008",type:1,quality:QualitySet.ORANGE,name: "金钥匙",info:"解锁传说英雄 也可以直接兑换金币", },
}
export enum DropKey{
ItemUUId=0, // 物品ID
Pro=1, // 概率
Diff=2, // 上下限差值
Base=3, // 基础数量
GrowthRate=4, // 增长参数
}
// 怪物掉落配置表 - 按照DropKey顺序配置
export const MonsterDropTable: { [monsterId: number]: [number, number, number, number, number][] } = {
// 普通怪物 - 绿色品质
5201: [ // 兽人战士
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.3, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
],
5202: [ // 兽人刺客
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.4, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
],
5203: [ // 兽人护卫
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.3, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
],
5204: [ // 石卫
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.35, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 35%概率掉落铜钥匙
],
5205: [ // 土卫
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.35, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 35%概率掉落铜钥匙
],
5206: [ // 树卫
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.35, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 35%概率掉落铜钥匙
],
5219: [ // 牛头战士
[Items[1001].uuid, 1.0, 1, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1-2个绿色英雄石
[Items[1006].uuid, 0.4, 0, 1, 0.15] // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
],
5220: [ // 牛头战士
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.3, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
],
5221: [ // 牛头战士
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.4, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
],
5222: [ // 独眼巨人
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.3, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
],
5223: [ // 独眼巨人
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.3, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 30%概率掉落铜钥匙
],
5224: [ // 独眼巨人
[Items[1001].uuid, 1.0, 0, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个绿色英雄石
[Items[1006].uuid, 0.4, 0, 1, 0.1] // [item_uuid, probability, diff, baseCount, growthRate] - 40%概率掉落铜钥匙
],
// 精英怪物 - 蓝色品质
5225: [ // 精英独眼
[Items[1001].uuid, 1.0, 1, 2, 0.3], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落2-3个绿色英雄石
[Items[1002].uuid, 1.0, 0, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个蓝色英雄石
[Items[1006].uuid, 0.6, 1, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 60%概率掉落铜钥匙
[Items[1007].uuid, 0.2, 0, 1, 0.15] // [item_uuid, probability, diff, baseCount, growthRate] - 20%概率掉落银钥匙
],
5226: [ // 精英牛头
[Items[1001].uuid, 1.0, 1, 2, 0.3], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落2-3个绿色英雄石
[Items[1002].uuid, 1.0, 0, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个蓝色英雄石
[Items[1006].uuid, 0.6, 1, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 60%概率掉落铜钥匙
[Items[1007].uuid, 0.2, 0, 1, 0.15] // [item_uuid, probability, diff, baseCount, growthRate] - 20%概率掉落银钥匙
],
5227: [ // 精英兽人
[Items[1001].uuid, 1.0, 1, 2, 0.3], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落2-3个绿色英雄石
[Items[1002].uuid, 1.0, 0, 1, 0.25], // [item_uuid, probability, diff, baseCount, growthRate] - 100%掉落1个蓝色英雄石
[Items[1006].uuid, 0.6, 1, 1, 0.2], // [item_uuid, probability, diff, baseCount, growthRate] - 60%概率掉落铜钥匙
[Items[1007].uuid, 0.2, 0, 1, 0.15] // [item_uuid, probability, diff, baseCount, growthRate] - 20%概率掉落银钥匙
]
};
// 怪物掉落管理器
export class MonsterDropManager {
/**
* 根据怪物ID获取掉落配置
* @param monsterId 怪物ID
* @returns 掉落配置
*/
static getDropConfig(monsterId: number): [number, number, number, number, number][] | null {
return MonsterDropTable[monsterId] || null;
}
/**
* 计算指定关卡数的掉落数量
* @param baseCount 基础数量
* @param growthRate 增长参数
* @param stageNumber 关卡数
* @param diff 上下限差值
* @returns 计算后的掉落数量
*/
static calculateDropCount(baseCount: number, growthRate: number, stageNumber: number, diff: number): number {
// 公式：基础数量 * 增长参数 * 关卡数 + (0-差值的随机数)
const calculatedCount = baseCount * growthRate * stageNumber;
const randomBonus = Math.floor(Math.random() * (diff + 1)); // 0到diff的随机数
const finalCount = calculatedCount + randomBonus;
// 允许掉落数量为0
return Math.max(0, Math.floor(finalCount));
}
/**
* 计算怪物掉落物品
* @param monsterId 怪物ID
* @param stageNumber 关卡数
* @param playerLuck 玩家幸运值加成
* @returns 掉落物品数组
*/
static calculateMonsterDrops(monsterId: number, stageNumber: number, playerLuck: number = 0): Array<{item_uuid: number, count: number}> {
const dropArray = this.getDropConfig(monsterId);
if (!dropArray) {
console.warn(`[MonsterDropManager]: No drop config found for monster ${monsterId}`);
return [];
}
const result: Array<{item_uuid: number, count: number}> = [];
const luckBonus = 1 + (playerLuck * 0.01); // 幸运值加成
// 处理所有掉落物品（统一按概率处理）
dropArray.forEach(dropData => {
const [item_uuid, probability, diff, baseCount, growthRate] = dropData;
if (Math.random() < probability) {
// 使用新的计算公式：基础值*关卡数*增长参数+(0-差值的随机数)
const finalCount = this.calculateDropCount(baseCount, growthRate, stageNumber, diff);
const countWithLuck = Math.floor(finalCount * luckBonus);
result.push({
item_uuid: item_uuid,
count: Math.max(1, countWithLuck) // 确保至少掉落1个
});
}
});
return result;
}
/**
* 预览指定关卡数的掉落数量（不包含随机因素）
* @param monsterId 怪物ID
* @param stageNumber 关卡数
* @returns 掉落物品预览数组
*/
static previewMonsterDrops(monsterId: number, stageNumber: number): Array<{item_uuid: number, baseCount: number, calculatedCount: number, maxCount: number}> {
const dropArray = this.getDropConfig(monsterId);
if (!dropArray) {
console.warn(`[MonsterDropManager]: No drop config found for monster ${monsterId}`);
return [];
}
const result: Array<{item_uuid: number, baseCount: number, calculatedCount: number, maxCount: number}> = [];
// 处理所有掉落物品
dropArray.forEach(dropData => {
const [item_uuid, probability, diff, baseCount, growthRate] = dropData;
const calculatedCount = baseCount * growthRate * stageNumber;
const maxCount = calculatedCount + diff;
result.push({
item_uuid: item_uuid,
baseCount: baseCount,
calculatedCount: Math.floor(calculatedCount),
maxCount: Math.floor(maxCount)
});
});
return result;
}
}