This commit is contained in:
2025-09-20 09:49:22 +08:00
parent 3435f76f5d
commit 577f43042b
5 changed files with 352 additions and 1422 deletions

View File

@@ -1,421 +0,0 @@
// 装备库存操作模块 (equips)
const { getOrCreaterUser } = require('./auth');
const user_db_name = "cocos_users";
const DATA_TYPE = 'equips';
/**
* 获取装备库存数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function getEquips(db, openid) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
return {
code: 200,
data: user[DATA_TYPE],
msg: `${DATA_TYPE}获取成功`
};
} catch (error) {
console.error(`获取${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `获取${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 获取单个装备数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} equipId 装备ID
* @returns {Object} 操作结果
*/
async function getEquip(db, openid, equipId) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const equipCount = user[DATA_TYPE][equipId];
if (equipCount === undefined) {
return {
code: -6,
msg: `${DATA_TYPE.slice(0, -1)} ${equipId} 未找到`
};
}
return {
code: 200,
data: {
item_id: equipId,
count: equipCount
},
msg: `${DATA_TYPE.slice(0, -1)} ${equipId} 获取成功`
};
} catch (error) {
console.error(`获取${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `获取${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 添加装备
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} equipId 装备ID
* @param {number} count 添加数量
* @returns {Object} 操作结果
*/
async function addEquip(db, openid, equipId, count) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const currentCount = user[DATA_TYPE][equipId] || 0;
const newCount = currentCount + count;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${DATA_TYPE}.${equipId}`]: _.set(newCount),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: equipId,
old_count: currentCount,
new_count: newCount,
added: count
},
msg: `${DATA_TYPE.slice(0, -1)} ${equipId} 添加成功`
};
} else {
return {
code: -1,
msg: `添加 ${DATA_TYPE.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`添加${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `添加${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 消耗装备
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} equipId 装备ID
* @param {number} count 消耗数量
* @returns {Object} 操作结果
*/
async function consumeEquip(db, openid, equipId, count) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const currentCount = user[DATA_TYPE][equipId] || 0;
if (currentCount < count) {
return {
code: -6,
msg: `${DATA_TYPE.slice(0, -1)} ${equipId}不足, 当前: ${currentCount}, 需要: ${count}`
};
}
return await addEquip(db, openid, equipId, -count);
} catch (error) {
console.error(`消耗${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `消耗${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 设置装备数量
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} equipId 装备ID
* @param {number} count 新的数量
* @returns {Object} 操作结果
*/
async function setEquip(db, openid, equipId, count) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const oldCount = user[DATA_TYPE][equipId] || 0;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${DATA_TYPE}.${equipId}`]: _.set(count),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: equipId,
old_count: oldCount,
new_count: count
},
msg: `${DATA_TYPE.slice(0, -1)} ${equipId} 设置成功`
};
} else {
return {
code: -1,
msg: `设置 ${DATA_TYPE.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`设置${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `设置${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 批量更新装备库存
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {Object} updateData 更新数据对象
* @param {boolean} merge 是否合并更新默认true
* @returns {Object} 操作结果
*/
async function updateEquips(db, openid, updateData, merge = true) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
// 验证更新数据
if (!updateData || typeof updateData !== 'object') {
return {
code: -3,
msg: "无效的更新数据格式"
};
}
// 验证所有值都是非负数
for (const equipId in updateData) {
const count = updateData[equipId];
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: `装备 ${equipId} 的数量无效: ${count}`
};
}
}
let newData;
if (merge) {
// 合并更新
newData = { ...user[DATA_TYPE], ...updateData };
} else {
// 完全替换
newData = updateData;
}
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[DATA_TYPE]: _.set(newData),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: newData,
msg: `${DATA_TYPE} 更新成功`
};
} else {
return {
code: -1,
msg: `更新 ${DATA_TYPE} 失败`
};
}
} catch (error) {
console.error(`更新${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `更新${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 重置装备库存数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function resetEquips(db, openid) {
try {
const _ = db.command;
const { getNewUserInitData } = require('../user_init_data');
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const defaultData = getNewUserInitData();
let resetRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[DATA_TYPE]: _.set(defaultData[DATA_TYPE]),
last_save_time: _.set(Date.now()),
reset_time: _.set(Date.now())
}
});
if (resetRes?.stats?.updated >= 1) {
return {
code: 200,
data: defaultData[DATA_TYPE],
msg: `${DATA_TYPE} 重置成功`
};
} else {
return {
code: -1,
msg: `重置 ${DATA_TYPE} 失败`
};
}
} catch (error) {
console.error(`重置${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `重置${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 获取拥有的装备列表数量大于0的
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function getOwnedEquips(db, openid) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const ownedEquips = [];
for (const equipId in user[DATA_TYPE]) {
const count = user[DATA_TYPE][equipId];
if (count > 0) {
ownedEquips.push({
item_id: parseInt(equipId),
count: count
});
}
}
return {
code: 200,
data: {
owned_items: ownedEquips,
total_types: ownedEquips.length
},
msg: `拥有的${DATA_TYPE}获取成功`
};
} catch (error) {
console.error(`获取拥有的${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `获取拥有的${DATA_TYPE}错误: ${error.message}`
};
}
}
module.exports = {
getEquips,
getEquip,
addEquip,
consumeEquip,
setEquip,
updateEquips,
resetEquips,
getOwnedEquips
};

View File

@@ -1,8 +1,7 @@
// 通用库存操作模块 (items, tals, equips) // 通用库存操作模块 (items, tals, equips)
// 现在作为统一接口,调用各个独立模块 const { getOrCreaterUser } = require('./auth');
const itemsModule = require('./items');
const talsModule = require('./tals'); const user_db_name = "cocos_users";
const equipsModule = require('./equips');
// 支持的数据类型 // 支持的数据类型
const SUPPORTED_TYPES = ['items', 'tals', 'equips']; const SUPPORTED_TYPES = ['items', 'tals', 'equips'];
@@ -16,24 +15,6 @@ function validateDataType(dataType) {
return SUPPORTED_TYPES.includes(dataType); return SUPPORTED_TYPES.includes(dataType);
} }
/**
* 根据数据类型获取对应的模块
* @param {string} dataType 数据类型
* @returns {Object} 对应的模块
*/
function getModuleByType(dataType) {
switch(dataType) {
case 'items':
return itemsModule;
case 'tals':
return talsModule;
case 'equips':
return equipsModule;
default:
return null;
}
}
/** /**
* 获取库存数据 * 获取库存数据
* @param {Object} db 数据库实例 * @param {Object} db 数据库实例
@@ -42,6 +23,7 @@ function getModuleByType(dataType) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function getInventory(db, openid, dataType) { async function getInventory(db, openid, dataType) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
@@ -49,18 +31,24 @@ async function getInventory(db, openid, dataType) {
}; };
} }
const module = getModuleByType(dataType); let user = await getOrCreaterUser(db, openid);
switch(dataType) { if (!user) {
case 'items':
return await module.getItems(db, openid);
case 'tals':
return await module.getTals(db, openid);
case 'equips':
return await module.getEquips(db, openid);
default:
return { return {
code: -3, code: -4,
msg: `无效的数据类型: ${dataType}` msg: "未找到用户"
};
}
return {
code: 200,
data: user[dataType],
msg: `${dataType}获取成功`
};
} catch (error) {
console.error(`获取${dataType}错误:`, error);
return {
code: -5,
msg: `获取${dataType}错误: ${error.message}`
}; };
} }
} }
@@ -74,6 +62,7 @@ async function getInventory(db, openid, dataType) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function getInventoryItem(db, openid, dataType, itemId) { async function getInventoryItem(db, openid, dataType, itemId) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
@@ -81,18 +70,35 @@ async function getInventoryItem(db, openid, dataType, itemId) {
}; };
} }
const module = getModuleByType(dataType); let user = await getOrCreaterUser(db, openid);
switch(dataType) { if (!user) {
case 'items':
return await module.getItem(db, openid, itemId);
case 'tals':
return await module.getTal(db, openid, itemId);
case 'equips':
return await module.getEquip(db, openid, itemId);
default:
return { return {
code: -3, code: -4,
msg: `无效的数据类型: ${dataType}` msg: "未找到用户"
};
}
const itemCount = user[dataType][itemId];
if (itemCount === undefined) {
return {
code: -6,
msg: `${dataType.slice(0, -1)} ${itemId} 未找到`
};
}
return {
code: 200,
data: {
item_id: itemId,
count: itemCount
},
msg: `${dataType.slice(0, -1)} ${itemId} 获取成功`
};
} catch (error) {
console.error(`获取${dataType}物品错误:`, error);
return {
code: -5,
msg: `获取${dataType}物品错误: ${error.message}`
}; };
} }
} }
@@ -107,6 +113,7 @@ async function getInventoryItem(db, openid, dataType, itemId) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function addInventoryItem(db, openid, dataType, itemId, count) { async function addInventoryItem(db, openid, dataType, itemId, count) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
@@ -114,18 +121,54 @@ async function addInventoryItem(db, openid, dataType, itemId, count) {
}; };
} }
const module = getModuleByType(dataType); const _ = db.command;
switch(dataType) { let user = await getOrCreaterUser(db, openid);
case 'items': if (!user) {
return await module.addItem(db, openid, itemId, count); return {
case 'tals': code: -4,
return await module.addTal(db, openid, itemId, count); msg: "未找到用户"
case 'equips': };
return await module.addEquip(db, openid, itemId, count); }
default:
if (typeof count !== 'number' || count < 0) {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: "数量必须是非负数"
};
}
const currentCount = user[dataType][itemId] || 0;
const newCount = currentCount + count;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${dataType}.${itemId}`]: _.set(newCount),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: itemId,
old_count: currentCount,
new_count: newCount,
added: count
},
msg: `${dataType.slice(0, -1)} ${itemId} 添加成功`
};
} else {
return {
code: -1,
msg: `添加 ${dataType.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`添加${dataType}物品错误:`, error);
return {
code: -5,
msg: `添加${dataType}物品错误: ${error.message}`
}; };
} }
} }
@@ -140,6 +183,7 @@ async function addInventoryItem(db, openid, dataType, itemId, count) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function consumeInventoryItem(db, openid, dataType, itemId, count) { async function consumeInventoryItem(db, openid, dataType, itemId, count) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
@@ -147,18 +191,35 @@ async function consumeInventoryItem(db, openid, dataType, itemId, count) {
}; };
} }
const module = getModuleByType(dataType); let user = await getOrCreaterUser(db, openid);
switch(dataType) { if (!user) {
case 'items': return {
return await module.consumeItem(db, openid, itemId, count); code: -4,
case 'tals': msg: "未找到用户"
return await module.consumeTal(db, openid, itemId, count); };
case 'equips': }
return await module.consumeEquip(db, openid, itemId, count);
default: if (typeof count !== 'number' || count < 0) {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: "数量必须是非负数"
};
}
const currentCount = user[dataType][itemId] || 0;
if (currentCount < count) {
return {
code: -6,
msg: `${dataType.slice(0, -1)} ${itemId}不足, 当前: ${currentCount}, 需要: ${count}`
};
}
return await addInventoryItem(db, openid, dataType, itemId, -count);
} catch (error) {
console.error(`消耗${dataType}物品错误:`, error);
return {
code: -5,
msg: `消耗${dataType}物品错误: ${error.message}`
}; };
} }
} }
@@ -173,6 +234,7 @@ async function consumeInventoryItem(db, openid, dataType, itemId, count) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function setInventoryItem(db, openid, dataType, itemId, count) { async function setInventoryItem(db, openid, dataType, itemId, count) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
@@ -180,18 +242,52 @@ async function setInventoryItem(db, openid, dataType, itemId, count) {
}; };
} }
const module = getModuleByType(dataType); const _ = db.command;
switch(dataType) { let user = await getOrCreaterUser(db, openid);
case 'items': if (!user) {
return await module.setItem(db, openid, itemId, count); return {
case 'tals': code: -4,
return await module.setTal(db, openid, itemId, count); msg: "未找到用户"
case 'equips': };
return await module.setEquip(db, openid, itemId, count); }
default:
if (typeof count !== 'number' || count < 0) {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: "数量必须是非负数"
};
}
const oldCount = user[dataType][itemId] || 0;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${dataType}.${itemId}`]: _.set(count),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: itemId,
old_count: oldCount,
new_count: count
},
msg: `${dataType.slice(0, -1)} ${itemId} 设置成功`
};
} else {
return {
code: -1,
msg: `设置 ${dataType.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`设置${dataType}物品错误:`, error);
return {
code: -5,
msg: `设置${dataType}物品错误: ${error.message}`
}; };
} }
} }
@@ -206,25 +302,75 @@ async function setInventoryItem(db, openid, dataType, itemId, count) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function updateInventory(db, openid, dataType, updateData, merge = true) { async function updateInventory(db, openid, dataType, updateData, merge = true) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: `Invalid data type: ${dataType}`
}; };
} }
const module = getModuleByType(dataType); const _ = db.command;
switch(dataType) { let user = await getOrCreaterUser(db, openid);
case 'items': if (!user) {
return await module.updateItems(db, openid, updateData, merge); return {
case 'tals': code: -4,
return await module.updateTals(db, openid, updateData, merge); msg: "User not found"
case 'equips': };
return await module.updateEquips(db, openid, updateData, merge); }
default:
// 验证更新数据
if (!updateData || typeof updateData !== 'object') {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: "Invalid update data format"
};
}
// 验证所有值都是非负数
for (const itemId in updateData) {
const count = updateData[itemId];
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: `Invalid count for item ${itemId}: ${count}`
};
}
}
let newData;
if (merge) {
// 合并更新
newData = { ...user[dataType], ...updateData };
} else {
// 完全替换
newData = updateData;
}
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[dataType]: _.set(newData),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: newData,
msg: `${dataType} updated successfully`
};
} else {
return {
code: -1,
msg: `Update ${dataType} fail`
};
}
} catch (error) {
console.error(`Update ${dataType} error:`, error);
return {
code: -5,
msg: `Update ${dataType} error: ${error.message}`
}; };
} }
} }
@@ -237,25 +383,51 @@ async function updateInventory(db, openid, dataType, updateData, merge = true) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function resetInventory(db, openid, dataType) { async function resetInventory(db, openid, dataType) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: `Invalid data type: ${dataType}`
}; };
} }
const module = getModuleByType(dataType); const _ = db.command;
switch(dataType) { const { getNewUserInitData } = require('../user_init_data');
case 'items': let user = await getOrCreaterUser(db, openid);
return await module.resetItems(db, openid); if (!user) {
case 'tals':
return await module.resetTals(db, openid);
case 'equips':
return await module.resetEquips(db, openid);
default:
return { return {
code: -3, code: -4,
msg: `无效的数据类型: ${dataType}` msg: "User not found"
};
}
const defaultData = getNewUserInitData();
let resetRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[dataType]: _.set(defaultData[dataType]),
last_save_time: _.set(Date.now()),
reset_time: _.set(Date.now())
}
});
if (resetRes?.stats?.updated >= 1) {
return {
code: 200,
data: defaultData[dataType],
msg: `${dataType} reset successfully`
};
} else {
return {
code: -1,
msg: `Reset ${dataType} fail`
};
}
} catch (error) {
console.error(`Reset ${dataType} error:`, error);
return {
code: -5,
msg: `Reset ${dataType} error: ${error.message}`
}; };
} }
} }
@@ -268,25 +440,46 @@ async function resetInventory(db, openid, dataType) {
* @returns {Object} 操作结果 * @returns {Object} 操作结果
*/ */
async function getOwnedItems(db, openid, dataType) { async function getOwnedItems(db, openid, dataType) {
try {
if (!validateDataType(dataType)) { if (!validateDataType(dataType)) {
return { return {
code: -3, code: -3,
msg: `无效的数据类型: ${dataType}` msg: `Invalid data type: ${dataType}`
}; };
} }
const module = getModuleByType(dataType); let user = await getOrCreaterUser(db, openid);
switch(dataType) { if (!user) {
case 'items':
return await module.getOwnedItems(db, openid);
case 'tals':
return await module.getOwnedTals(db, openid);
case 'equips':
return await module.getOwnedEquips(db, openid);
default:
return { return {
code: -3, code: -4,
msg: `无效的数据类型: ${dataType}` msg: "User not found"
};
}
const ownedItems = [];
for (const itemId in user[dataType]) {
const count = user[dataType][itemId];
if (count > 0) {
ownedItems.push({
item_id: parseInt(itemId),
count: count
});
}
}
return {
code: 200,
data: {
owned_items: ownedItems,
total_types: ownedItems.length
},
msg: `Owned ${dataType} retrieved successfully`
};
} catch (error) {
console.error(`Get owned ${dataType} error:`, error);
return {
code: -5,
msg: `Get owned ${dataType} error: ${error.message}`
}; };
} }
} }

View File

@@ -1,421 +0,0 @@
// 物品库存操作模块 (items)
const { getOrCreaterUser } = require('./auth');
const user_db_name = "cocos_users";
const DATA_TYPE = 'items';
/**
* 获取物品库存数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function getItems(db, openid) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
return {
code: 200,
data: user[DATA_TYPE],
msg: `${DATA_TYPE}获取成功`
};
} catch (error) {
console.error(`获取${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `获取${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 获取单个物品数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} itemId 物品ID
* @returns {Object} 操作结果
*/
async function getItem(db, openid, itemId) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const itemCount = user[DATA_TYPE][itemId];
if (itemCount === undefined) {
return {
code: -6,
msg: `${DATA_TYPE.slice(0, -1)} ${itemId} 未找到`
};
}
return {
code: 200,
data: {
item_id: itemId,
count: itemCount
},
msg: `${DATA_TYPE.slice(0, -1)} ${itemId} 获取成功`
};
} catch (error) {
console.error(`获取${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `获取${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 添加物品
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} itemId 物品ID
* @param {number} count 添加数量
* @returns {Object} 操作结果
*/
async function addItem(db, openid, itemId, count) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const currentCount = user[DATA_TYPE][itemId] || 0;
const newCount = currentCount + count;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${DATA_TYPE}.${itemId}`]: _.set(newCount),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: itemId,
old_count: currentCount,
new_count: newCount,
added: count
},
msg: `${DATA_TYPE.slice(0, -1)} ${itemId} 添加成功`
};
} else {
return {
code: -1,
msg: `添加 ${DATA_TYPE.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`添加${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `添加${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 消耗物品
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} itemId 物品ID
* @param {number} count 消耗数量
* @returns {Object} 操作结果
*/
async function consumeItem(db, openid, itemId, count) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const currentCount = user[DATA_TYPE][itemId] || 0;
if (currentCount < count) {
return {
code: -6,
msg: `${DATA_TYPE.slice(0, -1)} ${itemId}不足, 当前: ${currentCount}, 需要: ${count}`
};
}
return await addItem(db, openid, itemId, -count);
} catch (error) {
console.error(`消耗${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `消耗${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 设置物品数量
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} itemId 物品ID
* @param {number} count 新的数量
* @returns {Object} 操作结果
*/
async function setItem(db, openid, itemId, count) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const oldCount = user[DATA_TYPE][itemId] || 0;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${DATA_TYPE}.${itemId}`]: _.set(count),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: itemId,
old_count: oldCount,
new_count: count
},
msg: `${DATA_TYPE.slice(0, -1)} ${itemId} 设置成功`
};
} else {
return {
code: -1,
msg: `设置 ${DATA_TYPE.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`设置${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `设置${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 批量更新物品库存
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {Object} updateData 更新数据对象
* @param {boolean} merge 是否合并更新默认true
* @returns {Object} 操作结果
*/
async function updateItems(db, openid, updateData, merge = true) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
// 验证更新数据
if (!updateData || typeof updateData !== 'object') {
return {
code: -3,
msg: "无效的更新数据格式"
};
}
// 验证所有值都是非负数
for (const itemId in updateData) {
const count = updateData[itemId];
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: `物品 ${itemId} 的数量无效: ${count}`
};
}
}
let newData;
if (merge) {
// 合并更新
newData = { ...user[DATA_TYPE], ...updateData };
} else {
// 完全替换
newData = updateData;
}
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[DATA_TYPE]: _.set(newData),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: newData,
msg: `${DATA_TYPE} 更新成功`
};
} else {
return {
code: -1,
msg: `更新 ${DATA_TYPE} 失败`
};
}
} catch (error) {
console.error(`更新${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `更新${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 重置物品库存数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function resetItems(db, openid) {
try {
const _ = db.command;
const { getNewUserInitData } = require('../user_init_data');
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const defaultData = getNewUserInitData();
let resetRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[DATA_TYPE]: _.set(defaultData[DATA_TYPE]),
last_save_time: _.set(Date.now()),
reset_time: _.set(Date.now())
}
});
if (resetRes?.stats?.updated >= 1) {
return {
code: 200,
data: defaultData[DATA_TYPE],
msg: `${DATA_TYPE} 重置成功`
};
} else {
return {
code: -1,
msg: `重置 ${DATA_TYPE} 失败`
};
}
} catch (error) {
console.error(`重置${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `重置${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 获取拥有的物品列表数量大于0的
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function getOwnedItems(db, openid) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const ownedItems = [];
for (const itemId in user[DATA_TYPE]) {
const count = user[DATA_TYPE][itemId];
if (count > 0) {
ownedItems.push({
item_id: parseInt(itemId),
count: count
});
}
}
return {
code: 200,
data: {
owned_items: ownedItems,
total_types: ownedItems.length
},
msg: `拥有的${DATA_TYPE}获取成功`
};
} catch (error) {
console.error(`获取拥有的${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `获取拥有的${DATA_TYPE}错误: ${error.message}`
};
}
}
module.exports = {
getItems,
getItem,
addItem,
consumeItem,
setItem,
updateItems,
resetItems,
getOwnedItems
};

View File

@@ -1,421 +0,0 @@
// 天赋库存操作模块 (tals)
const { getOrCreaterUser } = require('./auth');
const user_db_name = "cocos_users";
const DATA_TYPE = 'tals';
/**
* 获取天赋库存数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function getTals(db, openid) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
return {
code: 200,
data: user[DATA_TYPE],
msg: `${DATA_TYPE}获取成功`
};
} catch (error) {
console.error(`获取${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `获取${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 获取单个天赋数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} talId 天赋ID
* @returns {Object} 操作结果
*/
async function getTal(db, openid, talId) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const talCount = user[DATA_TYPE][talId];
if (talCount === undefined) {
return {
code: -6,
msg: `${DATA_TYPE.slice(0, -1)} ${talId} 未找到`
};
}
return {
code: 200,
data: {
item_id: talId,
count: talCount
},
msg: `${DATA_TYPE.slice(0, -1)} ${talId} 获取成功`
};
} catch (error) {
console.error(`获取${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `获取${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 添加天赋
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} talId 天赋ID
* @param {number} count 添加数量
* @returns {Object} 操作结果
*/
async function addTal(db, openid, talId, count) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const currentCount = user[DATA_TYPE][talId] || 0;
const newCount = currentCount + count;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${DATA_TYPE}.${talId}`]: _.set(newCount),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: talId,
old_count: currentCount,
new_count: newCount,
added: count
},
msg: `${DATA_TYPE.slice(0, -1)} ${talId} 添加成功`
};
} else {
return {
code: -1,
msg: `添加 ${DATA_TYPE.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`添加${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `添加${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 消耗天赋
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} talId 天赋ID
* @param {number} count 消耗数量
* @returns {Object} 操作结果
*/
async function consumeTal(db, openid, talId, count) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const currentCount = user[DATA_TYPE][talId] || 0;
if (currentCount < count) {
return {
code: -6,
msg: `${DATA_TYPE.slice(0, -1)} ${talId}不足, 当前: ${currentCount}, 需要: ${count}`
};
}
return await addTal(db, openid, talId, -count);
} catch (error) {
console.error(`消耗${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `消耗${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 设置天赋数量
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {number} talId 天赋ID
* @param {number} count 新的数量
* @returns {Object} 操作结果
*/
async function setTal(db, openid, talId, count) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: "数量必须是非负数"
};
}
const oldCount = user[DATA_TYPE][talId] || 0;
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[`${DATA_TYPE}.${talId}`]: _.set(count),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: {
item_id: talId,
old_count: oldCount,
new_count: count
},
msg: `${DATA_TYPE.slice(0, -1)} ${talId} 设置成功`
};
} else {
return {
code: -1,
msg: `设置 ${DATA_TYPE.slice(0, -1)} 失败`
};
}
} catch (error) {
console.error(`设置${DATA_TYPE}物品错误:`, error);
return {
code: -5,
msg: `设置${DATA_TYPE}物品错误: ${error.message}`
};
}
}
/**
* 批量更新天赋库存
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @param {Object} updateData 更新数据对象
* @param {boolean} merge 是否合并更新默认true
* @returns {Object} 操作结果
*/
async function updateTals(db, openid, updateData, merge = true) {
try {
const _ = db.command;
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
// 验证更新数据
if (!updateData || typeof updateData !== 'object') {
return {
code: -3,
msg: "无效的更新数据格式"
};
}
// 验证所有值都是非负数
for (const talId in updateData) {
const count = updateData[talId];
if (typeof count !== 'number' || count < 0) {
return {
code: -3,
msg: `天赋 ${talId} 的数量无效: ${count}`
};
}
}
let newData;
if (merge) {
// 合并更新
newData = { ...user[DATA_TYPE], ...updateData };
} else {
// 完全替换
newData = updateData;
}
let updateRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[DATA_TYPE]: _.set(newData),
last_save_time: _.set(Date.now())
}
});
if (updateRes?.stats?.updated >= 1) {
return {
code: 200,
data: newData,
msg: `${DATA_TYPE} 更新成功`
};
} else {
return {
code: -1,
msg: `更新 ${DATA_TYPE} 失败`
};
}
} catch (error) {
console.error(`更新${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `更新${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 重置天赋库存数据
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function resetTals(db, openid) {
try {
const _ = db.command;
const { getNewUserInitData } = require('../user_init_data');
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const defaultData = getNewUserInitData();
let resetRes = await db.collection(user_db_name).doc(user._id).update({
data: {
[DATA_TYPE]: _.set(defaultData[DATA_TYPE]),
last_save_time: _.set(Date.now()),
reset_time: _.set(Date.now())
}
});
if (resetRes?.stats?.updated >= 1) {
return {
code: 200,
data: defaultData[DATA_TYPE],
msg: `${DATA_TYPE} 重置成功`
};
} else {
return {
code: -1,
msg: `重置 ${DATA_TYPE} 失败`
};
}
} catch (error) {
console.error(`重置${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `重置${DATA_TYPE}错误: ${error.message}`
};
}
}
/**
* 获取拥有的天赋列表数量大于0的
* @param {Object} db 数据库实例
* @param {string} openid 用户openid
* @returns {Object} 操作结果
*/
async function getOwnedTals(db, openid) {
try {
let user = await getOrCreaterUser(db, openid);
if (!user) {
return {
code: -4,
msg: "未找到用户"
};
}
const ownedTals = [];
for (const talId in user[DATA_TYPE]) {
const count = user[DATA_TYPE][talId];
if (count > 0) {
ownedTals.push({
item_id: parseInt(talId),
count: count
});
}
}
return {
code: 200,
data: {
owned_items: ownedTals,
total_types: ownedTals.length
},
msg: `拥有的${DATA_TYPE}获取成功`
};
} catch (error) {
console.error(`获取拥有的${DATA_TYPE}错误:`, error);
return {
code: -5,
msg: `获取拥有的${DATA_TYPE}错误: ${error.message}`
};
}
}
module.exports = {
getTals,
getTal,
addTal,
consumeTal,
setTal,
updateTals,
resetTals,
getOwnedTals
};

View File

@@ -4,19 +4,19 @@
"customSplash": { "customSplash": {
"id": "customSplash", "id": "customSplash",
"label": "customSplash", "label": "customSplash",
"enable": true, "enable": false,
"customSplash": { "customSplash": {
"complete": true, "complete": false,
"form": "https://creator-api.cocos.com/api/form/show?sid=5867a11f63bd65515866589488c9bca0" "form": "https://creator-api.cocos.com/api/form/show?"
} }
}, },
"removeSplash": { "removeSplash": {
"id": "removeSplash", "id": "removeSplash",
"label": "removeSplash", "label": "removeSplash",
"enable": true, "enable": false,
"removeSplash": { "removeSplash": {
"complete": true, "complete": false,
"form": "https://creator-api.cocos.com/api/form/show?sid=5867a11f63bd65515866589488c9bca0" "form": "https://creator-api.cocos.com/api/form/show?"
} }
} }
} }