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

import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerChongYangData, getPlayerChongYangDataShow } from '../../../services/activity/chongyangService';
import { ActivityChongYangRecModel } from '../../../db/ActivityChongYangRec';
import { RewardInter } from '../../../pubUtils/interface';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';


export default function (app: Application) {
    new HandlerService(app, {});
    return new ChongYangHandler(app);
}

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

    async getData(msg: { activityId: number }, session: BackendSession) {
        const { activityId } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');

        let playerData = await getPlayerChongYangDataShow(activityId, serverId, roleId);

        if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);

        return resResult(STATUS.SUCCESS, playerData);
    }

    async gameStart(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
        const { activityId, dayIndex } = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');

        let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
        if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
        let scene = playerData.sceneMap.get(dayIndex);
        if (!scene) return resResult(STATUS.ACTIVITY_MISSING);

        // 检测挑战次数
        if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
        // 检测解锁
        if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);

        const gameCode = genCode(10);
        await ActivityChongYangRecModel.gameRecord(serverId, activityId, playerData.roundIndex, roleId, {
            todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, dayIndex, isSkip: false
        });

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

    async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean, dayIndex: number }, session: BackendSession) {
        const { activityId, gameCode, isSuccess, dayIndex } = 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 getPlayerChongYangData(activityId, serverId, roleId);
        if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
        let scene = playerData.sceneMap.get(dayIndex);
        if (!scene) return resResult(STATUS.ACTIVITY_MISSING);

        // 检测挑战次数
        if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
        // 检测解锁
        if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);

        let curRecord = playerData.gameRecords.find(cur => cur.gameCode == gameCode);
        if (!curRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
        if (curRecord.isSuccess) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_USE);

        let playerRecord = await ActivityChongYangRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), scene.rewards);
        if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
        playerData = await getPlayerChongYangData(activityId, serverId, roleId);
        scene = playerData.sceneMap.get(dayIndex);

        let goods: RewardInter[] = [];
        if (isSuccess) {
            goods = await addItems(roleId, roleName, sid, stringToRewardParam(scene.rewards), ITEM_CHANGE_REASON.CHONGYANG_REWARD)
        }

        return resResult(STATUS.SUCCESS, {
            activityId,
            playCnt: scene.playCnt,
            maxPlayCnt: scene.maxPlayCnt,
            gameCode,
            goods
        });
    }

    async buyCnt(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
        const { activityId, dayIndex, count } = msg;
        const roleId = session.get('roleId');
        const sid = session.get('sid');
        const serverId = session.get('serverId');

        let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
        if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
        let scene = playerData.sceneMap.get(dayIndex);
        if (!scene) return resResult(STATUS.ACTIVITY_MISSING);

        // 检测购买次数
        if (scene.buyCnt + count > scene.dailyBuyCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_BUY_COUNT_OVER);
        // 检测解锁
        if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);

        // 扣材料
        let costResult = await handleCost(roleId, sid, stringToConsumeParam(scene.buyCost), ITEM_CHANGE_REASON.CHONGYANG_COST);
        if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
        // 保存数据
        let playerRecord = await ActivityChongYangRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, { dayIndex, buyCnt: count }, scene.isPushBuyRecord);
        if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);

        playerData = await getPlayerChongYangData(activityId, serverId, roleId);
        scene = playerData.sceneMap.get(dayIndex);

        return resResult(STATUS.SUCCESS, { activityId, dailyBuyCnt: scene.dailyBuyCnt, buyCnt: scene.buyCnt, });
    }

    async gameSweep(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
        const { activityId, dayIndex, 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 getPlayerChongYangData(activityId, serverId, roleId);
        if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
        let scene = playerData.sceneMap.get(dayIndex);
        if (!scene) return resResult(STATUS.ACTIVITY_MISSING);

        // 检测挑战次数
        if (scene.playCnt + count > scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
        // 检测解锁
        if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
        // 检测通关
        let isHasPass = playerData.gameRecords.find(cur => cur.dayIndex == dayIndex && cur.isSuccess && !cur.isSkip && (getZeroPoint() * 1000 <= cur.time.getTime()));
        if (!isHasPass) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMESWEEP_LOCK);

        let rewards: RewardInter[] = [];
        for (let i = 0; i < count; i++) {
            await ActivityChongYangRecModel.gameRecord(serverId, activityId, playerData.roundIndex, roleId, {
                todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: scene.rewards, isSuccess: true, dayIndex, isSkip: true
            });
            rewards.push(...stringToRewardParam(scene.rewards));
        }

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

        playerData = await getPlayerChongYangData(activityId, serverId, roleId);
        scene = playerData.sceneMap.get(dayIndex);

        return resResult(STATUS.SUCCESS, {
            activityId,
            playCnt: scene.playCnt,
            maxPlayCnt: scene.maxPlayCnt,
            goods
        });
    }
}