云环境和本地调试 添加

This commit is contained in:
2025-08-18 17:00:40 +08:00
parent addc61e2a9
commit a824d9a124
155 changed files with 6531 additions and 997 deletions

View File

@@ -0,0 +1,568 @@
import { WxCloudApi ,UserGameData} from "../wx_clound_client_api/WxCloudApi";
import { smc } from "./SingletonModuleComp";
/**
* 游戏数据同步管理器
* 负责管理fight_heros、heros、items、tals、equips的远程操作和本地同步
* 只有在远程修改成功后才同步修改本地数据
*/
export class GameDataSyncManager {
private static instance: GameDataSyncManager;
private constructor() {}
public static getInstance(): GameDataSyncManager {
if (!GameDataSyncManager.instance) {
GameDataSyncManager.instance = new GameDataSyncManager();
}
return GameDataSyncManager.instance;
}
/**
* 用远程数据覆盖本地数据(统一方法)
* @param remoteData 远程数据(云端或本地调试)
* @param dataSource 数据源描述
*/
async overrideLocalDataWithRemote(remoteData: UserGameData, dataSource: string) {
try {
console.log(`[Initialize]: 开始用${dataSource}数据覆盖客户端数据...`);
// 直接覆盖基础游戏数据
if (remoteData.data) {
Object.assign(smc.data, remoteData.data);
console.log(`[Initialize]: 基础游戏数据已从${dataSource}覆盖`);
}
// 直接覆盖出战英雄配置
if (remoteData.fight_heros) {
Object.assign(smc.fight_heros, remoteData.fight_heros);
console.log(`[Initialize]: 出战英雄配置已从${dataSource}覆盖`);
}
// 直接覆盖英雄数据
if (remoteData.heros) {
smc.heros = { ...remoteData.heros };
console.log(`[Initialize]: 英雄数据已从${dataSource}覆盖`);
}
// 直接覆盖道具数据
if (remoteData.items) {
Object.assign(smc.itmes, remoteData.items);
console.log(`[Initialize]: 道具数据已从${dataSource}覆盖`);
}
// 直接覆盖天赋数据
if (remoteData.tals) {
Object.assign(smc.tals, remoteData.tals);
console.log(`[Initialize]: 天赋数据已从${dataSource}覆盖`);
}
// 直接覆盖装备数据
if (remoteData.equips) {
Object.assign(smc.equips, remoteData.equips);
console.log(`[Initialize]: 装备数据已从${dataSource}覆盖`);
}
// 同步ViewModel数据
smc.syncData();
// 保存到本地存储(确保数据持久化)
// smc.saveGameData();
console.log(`[Initialize]: ${dataSource}数据覆盖完成,已保存到本地`);
} catch (error) {
console.error(`[Initialize]: ${dataSource}数据覆盖失败:`, error);
}
}
/**
* 批量更新出战英雄配置
* @param fightHeros 出战英雄配置对象
* @returns 是否成功
*/
async updateFightHeros(fightHeros: any): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 批量更新出战英雄配置:`, fightHeros);
const result = await WxCloudApi.updateFightHeros(fightHeros);
if (result.result.code === 200) {
// 远程修改成功,同步本地数据
Object.assign(smc.fight_heros, fightHeros);
console.log(`[GameDataSyncManager]: 出战英雄配置更新成功,本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 出战英雄配置更新失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 更新出战英雄配置异常:`, error);
return false;
}
}
/**
* 重置出战英雄配置为默认值
* @returns 是否成功
*/
async resetFightHeros(): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 重置出战英雄配置`);
const result = await WxCloudApi.resetFightHeros();
if (result.result.code === 200) {
// 远程修改成功,同步本地数据
smc.fight_heros = 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;
}
}
// ==================== 英雄管理 ====================
/**
* 添加新英雄到用户库存
* @param heroId 英雄ID
* @param heroData 英雄数据(可选)
* @returns 是否成功
*/
async addHero(heroId: number, heroData?: any): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 添加英雄 ID:${heroId}, 数据:`, heroData);
const result = await WxCloudApi.addHero(heroId, heroData);
if (result.result.code === 200) {
// 远程修改成功,同步本地数据
smc.heros[heroId] = 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;
}
}
/**
* 更新英雄的多个属性
* @param heroId 英雄ID
* @param updateData 要更新的属性
* @returns 是否成功
*/
async updateHero(heroId: number, updateData: any): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 更新英雄 ID:${heroId}, 更新数据:`, updateData);
const result = await WxCloudApi.updateHero(heroId, updateData);
if (result.result.code === 200) {
// 远程修改成功,同步本地数据
Object.assign(smc.heros[heroId], result.result.data.new_data);
console.log(`[GameDataSyncManager]: 英雄更新成功,本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 英雄更新失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 更新英雄异常:`, error);
return false;
}
}
/**
* 设置英雄的单个属性值
* @param heroId 英雄ID
* @param property 属性名
* @param value 属性值
* @returns 是否成功
*/
async setHeroProperty(heroId: number, property: any, value: any): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 设置英雄属性 ID:${heroId}, 属性:${property}, 值:${value}`);
const result = await WxCloudApi.setHeroProperty(heroId, property, value);
if (result.result.code === 200) {
// 远程修改成功,同步本地数据
smc.heros[heroId][property] = value;
console.log(`[GameDataSyncManager]: 英雄属性设置成功,本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 英雄属性设置失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 设置英雄属性异常:`, error);
return false;
}
}
/**
* 英雄升级指定级数
* @param heroId 英雄ID
* @param levels 升级级数默认1级
* @returns 是否成功
*/
async levelUpHero(heroId: number, exp:number,gold:number,levels: number = 1,): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 英雄升级 ID:${heroId}, 级数:${levels}`);
const result = await WxCloudApi.levelUpHero(heroId, exp,gold,levels);
if (result.result.code === 200) {
// 远程修改成功,同步本地数据
smc.heros[heroId].lv = result.result.data.new_value;
console.log(`[GameDataSyncManager]: 英雄升级成功,本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 英雄升级失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 英雄升级异常:`, error);
return false;
}
}
/**
* 删除指定英雄
* @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;
}
}
// ==================== 便捷方法 ====================
/**
* 增加道具
* @param itemId 道具ID
* @param count 数量
* @returns 是否成功
*/
async addItem(itemId: number, count: number): Promise<boolean> {
return this.addInventoryItem('items', itemId, count);
}
/**
* 消耗道具
* @param itemId 道具ID
* @param count 数量
* @returns 是否成功
*/
async consumeItem(itemId: number, count: number): Promise<boolean> {
return this.consumeInventoryItem('items', itemId, count);
}
/**
* 增加天赋点
* @param talId 天赋ID
* @param count 数量
* @returns 是否成功
*/
async addTalent(talId: number, count: number): Promise<boolean> {
return this.addInventoryItem('tals', talId, count);
}
/**
* 消耗天赋点
* @param talId 天赋ID
* @param count 数量
* @returns 是否成功
*/
async consumeTalent(talId: number, count: number): Promise<boolean> {
return this.consumeInventoryItem('tals', talId, count);
}
/**
* 增加装备
* @param equipId 装备ID
* @param count 数量
* @returns 是否成功
*/
async addEquipment(equipId: number, count: number): Promise<boolean> {
return this.addInventoryItem('equips', equipId, count);
}
/**
* 消耗装备
* @param equipId 装备ID
* @param count 数量
* @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}`);
}
}
/**
* 从云端加载所有游戏数据并同步到本地
* @returns 是否成功
*/
async loadAllGameData(): Promise<boolean> {
try {
console.log(`[GameDataSyncManager]: 从云端加载所有游戏数据`);
const result = await WxCloudApi.getAllGameData();
if (result.result.code === 200) {
// 远程数据获取成功,同步本地数据
const cloudData = result.result.data;
smc.data = cloudData.data;
smc.fight_heros = cloudData.fight_heros;
smc.heros = cloudData.heros;
smc.itmes = cloudData.items;
smc.tals = cloudData.tals;
smc.equips = cloudData.equips;
// 同步vmdata
smc.syncData();
console.log(`[GameDataSyncManager]: 云端数据加载成功,本地数据已同步`);
return true;
} else {
console.warn(`[GameDataSyncManager]: 云端数据加载失败: ${result.result.msg}`);
return false;
}
} catch (error) {
console.error(`[GameDataSyncManager]: 加载云端数据异常:`, error);
return false;
}
}
}
// 导出单例实例
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}); // 批量更新
// 2. 英雄管理
await gameDataSyncManager.addHero(5008, {uuid: 5008, lv: 1}); // 添加新英雄
await gameDataSyncManager.levelUpHero(5001, 5); // 英雄升级5级
await gameDataSyncManager.setHeroProperty(5001, "exp", 1000); // 设置英雄经验
// 3. 库存管理
await gameDataSyncManager.addItem(1001, 10); // 增加道具
await gameDataSyncManager.consumeItem(1001, 2); // 消耗道具
await gameDataSyncManager.addTalent(2001, 5); // 增加天赋点
await gameDataSyncManager.addEquipment(3001, 2); // 增加装备
// 4. 数据加载
await gameDataSyncManager.loadAllGameData(); // 从云端加载所有数据
注意:所有方法都返回 Promise<boolean>true表示成功false表示失败
只有在远程修改成功后,本地数据才会被同步修改
*/