HJ_Server/src/public/xstask.ts

import { OptionalId, UpdateFilter } from 'mongodb';
import { ApiCall } from 'tsrpc';
import { playerInfoType } from '../module/collection_palyerInfo';
import { CollectionXstask } from '../module/collection_xstask';
import { PublicShared } from '../shared/public/public';



export class XstaskFun {
    /**所有玩家的悬赏任务缓存 */
    static uidTask: k_v<CollectionXstask[]> = {};
    /**获取单个悬赏任务 */
    static async getTask(uid: string, _id: string) {
        return this.uidTask[uid]?.find(task => task._id == _id) || await G.mongodb.collection('xstask').findOne({ uid: uid, _id: G.mongodb.conversionId(_id) });
    }
    /**获取所有悬赏任务 */
    static async getAllTask(uid: string) {
        let taskList = this.uidTask[uid];

        if (!taskList) {
            taskList = this.uidTask[uid] = (await G.mongodb.collection('xstask').find({ uid: uid }).toArray()).map(task => G.mongodb.conversionIdObj(task));
        };

        return taskList;
    }

    /**完成任务标记 */
    static async finishTask(uid: string, _id: string) {
        // 修改数据库
        G.mongodb.collection('xstask').updateOne({ uid: uid, _id: G.mongodb.conversionId(_id) }, { $set: { 'receiveData.rec': true } });
        // 修改缓存
        let index = this.uidTask[uid]?.findIndex(task => task._id == _id);
        this.uidTask[uid][index].receiveData.rec = true
        return 
    }

    /**更新任务单个 */
    static async updateTask(uid: string, _id: string, taskId: string) {
        G.mongodb.collection('xstask').updateOne({ uid: uid, _id: G.mongodb.conversionId(_id) }, { $unset: { receiveData: 1 }, $set: {taskId: taskId} });
        let index = this.uidTask[uid]?.findIndex(task => task._id == _id);
        delete this.uidTask[uid][index].receiveData;
        this.uidTask[uid][index].taskId = taskId;
    }

    /**删除单个悬赏任务 */
    static async delTask(uid: string, _id: string) {

        let task = this.uidTask[uid]?.find(task => task._id == _id);
        task && this.uidTask[uid].removeOne(task);

        G.mongodb.collection('xstask').deleteOne({ uid: uid, _id: G.mongodb.conversionId(_id) });
    }
    /**删除多个悬赏任务 */
    static async delTasks(uid: string, _id: string[]) {

        for (let id of _id) await this.delTask(uid, id);
    }
    /**添加多个悬赏任务 */
    static async addTasks(uid: string, taskArr: { taskId: string; }[]) {

        let taskList = taskArr.map(task => {
            return {
                taskId: task.taskId,
                uid: uid,
            };
        });
        let result = await G.mongodb.collection('xstask').insertMany(taskList);

        this.uidTask[uid] = this.uidTask[uid] || [];
        taskList.forEach((task, index) => {
            this.uidTask[uid].push(G.mongodb.conversionIdObj({
                _id: result.insertedIds[index],
                ...task
            }));
        });

        return this.uidTask[uid];
    }
    /**派遣任务任务 */
    static async receiveTask(uid: string, _id: string, d: CollectionXstask['receiveData']) {
        let cache = this.uidTask[uid]?.find(task => task._id == _id);
        if (cache) cache.receiveData = d;
        G.mongodb.collection('xstask').updateOne({ uid: uid, _id: G.mongodb.conversionId(_id) }, { $set: { receiveData: d } });
    }
    /**获取所有已被派遣的英雄 */
    static async getAllReceiveHero(uid: string) {
        let heroIds: string[] = [];
        let allTask = await this.getAllTask(uid);

        allTask.forEach(task => heroIds = heroIds.concat(task.receiveData?.heros || []));

        return heroIds;
    }
    /**获取悬赏任务记录信息 */
    static async getInfo(uid: string) {
        return await G.mongodb.collection('playerInfo', 'xstask').findOne({ uid: uid, type: 'xstask' });
    }
    /**修改悬赏任务记录信息 */
    static async changeInfo(uid: string, change: Pick<UpdateFilter<OptionalId<playerInfoType['xstask']>>, '$inc' | '$set'>) {

        G.mongodb.collection('playerInfo', 'xstask').updateOne(
            { uid: uid, type: 'xstask' },
            change,
            { upsert: true }
        );
    }
    /**随机任务 */
    static randomTasks(lv: number, num: number) {
        let tasks = Object.values(G.gc.xstask).filter(task => G.gc.xstaskcom.lv[lv].taskColor.includes(task.colour)).sort(function () {
            return Math.random() - 0.5;
        });

        return (PublicShared.randomDropGroup(0, num, [tasks] as any) as any as typeof tasks).map(v => {
            return {
                taskId: v.id.toString()
            };
        });
    }

    /**红点 */
    static async getHongDian(call: ApiCall) {
        let _res = {
            show: false
        };
        let _xstasks = await this.getAllTask(call.uid);
        _res.show = _xstasks.every(v => !v.receiveData);
        for (let index = 0; index < _xstasks.length; index++) {
            const element = _xstasks[index];
            // 未派遣
            if (!element.receiveData) continue;
            let taskConf = G.gc.xstask[element?.taskId];
            // 派遣时间不足
            if (element.receiveData.time + taskConf.time > G.time) continue;
            _res.show = true;
            break;
        }
        return _res;
    }
}