ZYZ/game-server/app/servers/activity/handler/novemberHandler.ts

import { Application, BackendSession, HandlerService, } from 'pinus';
import { getPlayerNovemberData, getPlayerNovemberDataShow } from '../../../services/activity/novemberServices';
import { genCode, getRandSingleEelm, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityNovemberRecModel, NovemberRecord } from '../../../db/ActivityNovemberRec';
import { RewardInter } from '../../../pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';

/**
 * 辜月集会
 * @param app 
 * @returns 
 */
export default function (app: Application) {
    new HandlerService(app, {});
    return new NovemberHandler(app);
}

export class NovemberHandler {
    constructor(private app: Application) {
    }

    /**
     * 获取数据
     * @param msg 
     * @param session 
     * @returns 
     */
    async getData(msg: { activityId: number }, session: BackendSession) {
        const { activityId } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');

        let playerData = await getPlayerNovemberDataShow(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);

        return resResult(STATUS.SUCCESS, playerData);
    }

    /**
     * 开始游戏
     * @param msg 
     * @param session 
     * @returns 
     */
    async gameStart(msg: { activityId: number }, session: BackendSession) {
        const { activityId } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');

        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData || playerData.menuIds.length == 0) return resResult(STATUS.ACTIVITY_MISSING);

        // 检测挑战次数
        if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);

        const gameCode = genCode(10);
        const menuId = getRandSingleEelm(playerData.menuIds);
        await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, [{
            todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, isSkip: false, menuId, hasPass: false
        }]);

        return resResult(STATUS.SUCCESS, { activityId, gameCode, menuId });
    }

    /**
     * 结束游戏
     * @param msg 
     * @param session 
     * @returns 
     */
    async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
        const { activityId, gameCode, isSuccess } = msg;
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');


        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
        if (!playerData.records || playerData.records.length == 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
        let record = playerData.records.find(cur => cur.gameCode == gameCode);
        if (!record) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
        if (record.hasPass) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_USE);

        let menuId = record.menuId;

        // 检测挑战次数
        if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);

        let rewards: string = playerData.successRewards;
        if (!isSuccess) rewards = '&';//playerData.failRewards;
        let playerRecord = await ActivityNovemberRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), rewards, true);
        if (!playerRecord) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
        playerData = await getPlayerNovemberData(activityId, serverId, roleId);

        let goods: RewardInter[] = await addItems(roleId, roleName, sid, stringToRewardParam(rewards), ITEM_CHANGE_REASON.NOVEMBER_REWARD);

        return resResult(STATUS.SUCCESS, { activityId, menuId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, freeCnt: playerData.freeCnt, goods });
    }

    /**
     * 购买次数
     * @param msg 
     * @param session 
     * @returns 
     */
    async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
        const { activityId, count } = msg;
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');

        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);

        if (playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_BUY_COUNT_OVER);

        // 扣材料
        let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.NOVEMBER_COST);
        if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);

        let buyResult = await ActivityNovemberRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
        if (!buyResult) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);

        playerData = await getPlayerNovemberData(activityId, serverId, roleId);

        return resResult(STATUS.SUCCESS, { activityId, buyCnt: playerData.buyCnt, maxBuyCnt: playerData.maxBuyCnt });
    }

    /**
     * 扫荡
     * @param msg 
     * @param session 
     * @returns 
     */
    async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
        const { activityId, count } = msg;
        const roleId: string = session.get('roleId');
        const roleName: string = session.get('roleName');
        const serverId: number = session.get('serverId');
        const sid: string = session.get('sid');

        let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
        if (playerData.menuIds.length == 0) return (STATUS.ACTIVITY_NOVEMBER_MENU_NOT_FIND)
        if (playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMESWEEP_LOCK);

        if (playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);

        let rewards: RewardInter[] = [];
        let records: NovemberRecord[] = [];
        for (let i = 0; i < count; i++) {
            records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.successRewards, isSuccess: true, isSkip: true, menuId: 0, hasPass: true })
            rewards.push(...stringToRewardParam(playerData.successRewards));
        }
        await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, records);

        let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.NOVEMBER_REWARD)

        playerData = await getPlayerNovemberData(activityId, serverId, roleId);


        return resResult(STATUS.SUCCESS, { activityId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, goods });
    }
}