ZYZ/game-server/app/services/guildActivityService.ts

import { ServerlistModel } from "../db/Serverlist";
import { RoleModel } from "../db/Role";
import { reduceCe } from "../pubUtils/util";
import { GUILDACTIVITY } from "../pubUtils/dicParam";
import { gameData, getTodayGuildActivity } from "../pubUtils/data";
import { getCurHourPoint, getCutDay, nowSeconds } from "../pubUtils/timeUtil";
import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY } from "../consts";
import { Record } from "../db/UserGuildActivityRec";
import { GateMembersRec, GateActivityObject } from "../domain/battleField/guildActivity";
import { DicGuildActivity } from "../pubUtils/dictionary/DicGuildActivity";
import { getUnionRank, getRank, getGuildKeyName } from "./redisService";
import { GuildModel } from "../db/Guild";
import { SimpleGuildRankParam, SimpleRoleRankParam } from "../domain/rank";
import { getGuildChannelSid, getWorldChannelSid } from "./chatChannelService";
import { pinus } from "pinus";

let gateActivityObj: GateActivityObject;
export function getGuildActivityObj(aid: number) {
    if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
        if(!gateActivityObj) {
            gateActivityObj = new GateActivityObject()
        }
        return gateActivityObj;
    }
}

/**
 * 定时任务，获得前一天的活跃玩家中位数武将战力
 */
export async function setMedianCe() {
    let servers = await ServerlistModel.getAllServerList();

    for(let server of servers) {
        if(server.serverType == 'official') {
            let medianRole = await RoleModel.getMedianRole(server.id);
            if(!medianRole) {
                await ServerlistModel.updateByServerId(server.id, { medianCe: GUILDACTIVITY.GATEACTIVITY_ENEMYCE });
            } else {
                let { topLineup } = medianRole;
                let topHero = topLineup.sort((a, b) => b.ce - a.ce);
                let medianCe = reduceCe(topHero[0].ce);
                await ServerlistModel.updateByServerId(server.id, { medianCe });
            }
        }
    }
    return servers;
}


/**
 * 获得本服前一天活跃玩家中位数玩家的最强武将战力
 * @param serverId 
 */
export async function getMedianCe(serverId: number) {
    let server = await ServerlistModel.findByServerId(serverId);
    if(server) {
        return server.medianCe;
    }
    return GUILDACTIVITY.GATEACTIVITY_ENEMYCE;
}

/**
 * 根据当前时间判断军团活动倒计时
 * @param id 军团活动id
 */
export function getGuildActivityStatus(id: number) {
    let dicGuildActivity = gameData.guildActivity.get(id);
    if(!dicGuildActivity) return false;
    return getGuildActivityByDic(dicGuildActivity);
}

export function getGuildActivityByDic(dicGuildActivity: DicGuildActivity) {
    
    let startTime = getCurHourPoint(dicGuildActivity.startTime);
    let countdownTime = getCurHourPoint(dicGuildActivity.countDown);
    let { duringTime, openDay } = dicGuildActivity;
    let endTime = startTime + duringTime;

    let status = 0, time = 0;
    let now = nowSeconds();
    if(now >= countdownTime && now < startTime) {
        status = GUILD_ACTIVITY_STATUS.WAITING;
        time = startTime - now;
    } else if (now >= startTime && now < endTime) {
        status = GUILD_ACTIVITY_STATUS.START;
        time = endTime - now;
    } else {
        status = GUILD_ACTIVITY_STATUS.END;
    }

    let day = getCutDay();
    let isOpen = openDay.includes(day);

    return {
        status, time, isOpen
    }
}

/**
 * 根据每回合上报数据判断军功
 * @param aid 
 * @param record 
 * @param memberRecord 
 */
export function getRecordScore(aid: number, record: { round: number, dataId: number }[], memberRecord: GateMembersRec) {
    let dicGuildActivity = gameData.guildActivity.get(aid);
    if(!dicGuildActivity) return false;

    let dicWarJson = gameData.warJson.get(dicGuildActivity.warid);
    if(!dicWarJson) return false;

    let { round: curRound, enemies: historyEnemies} = memberRecord;
    let sum = 0, newRecords = new Array<Record>();
    for(let {round, dataId} of record) {
        if(!historyEnemies.includes(dataId)) {

            let enemy = dicWarJson.find(cur => cur.dataId == dataId);
            let enemyType = enemy.enemyType;
            let score = gameData.gateActivityPoint.get(enemyType);
            newRecords.push({ round, dataId, score, enemyType});
            sum += score;
            if(round > curRound) { // 每回合开始得10分
                sum += gameData.gateActivityPoint.get(GET_POINT_WAYS.ROUND_START);
                curRound = round;
            }

            historyEnemies.push(dataId);            
        }
    }


    return { score: sum, newRecords, memberRecord }
}

/**
 * 获得军团活动排行榜
 * @param guildCode 
 * @param serverId 
 * @param roleId 
 * @param roleName 
 */
export async function getGuildActivityRank(guildCode: string, serverId: number, roleId?: string, roleName?: string) {
    
    let guildRankResult = await getUnionRank(REDIS_KEY.GUILD_ACTIVITY, serverId, guildCode);
    let guildRank = new Array<SimpleGuildRankParam>();
    for(let { rank, code, name, num } of guildRankResult.ranks) {
        let param = new SimpleGuildRankParam(rank, code, name, num);
        guildRank.push(param);
    }
    let myGuildRank: SimpleGuildRankParam;
    if(guildRankResult.myRank) {
        let { rank, code, name, num } = guildRankResult.myRank;
        myGuildRank = new SimpleGuildRankParam(rank, code, name, num);
    } else {
        let guild = await GuildModel.findByCode(guildCode, serverId, 'name');
        myGuildRank = new SimpleGuildRankParam(0, guildCode, guild.name, 0);
    }

    let memberRankResult = await getRank(getGuildKeyName(REDIS_KEY.USER_GUILD_ACTIVITY, guildCode), serverId, roleId);
    let memberRank = new Array<SimpleRoleRankParam>();
    for(let { rank, roleId, roleName, num } of memberRankResult.ranks) {
        let param = new SimpleRoleRankParam(rank, roleId, roleName, num);
        memberRank.push(param)
    }
    let myMemberRank: SimpleRoleRankParam;
    if(roleName) {
        if(memberRankResult.myRank) {
            let { rank, roleId, roleName, num } = memberRankResult.myRank;
            myMemberRank = new SimpleRoleRankParam(rank, roleId, roleName, num);
        } else {
            myMemberRank = new SimpleRoleRankParam(0, roleId, roleName, 0);
        }
    }

    return { guildRank, myGuildRank, memberRank, myMemberRank }
}

/**
 * 对这个guild服内所有军团发排行榜信息
 */
export async function sendAllGuildRanks() {
    let obj = getGuildActivityObj(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
    let guilds = obj.getGuilds();
    for(let [ serverId, guildCodes ] of guilds) {
        // TODO 不需要每个军团都排序一次
        for(let guildCode of guildCodes) {
            let ranks =  await getGuildActivityRank(guildCode, serverId);
            let chatSid = await getGuildChannelSid(guildCode);
            pinus.app.rpc.chat.guildRemote.pushRank.toServer(chatSid, ranks);
        }
    }
}

export async function sendGuildActEndMsg() {
    let obj = getGuildActivityObj(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
    let guilds = obj.getGuilds();
    for(let [ serverId ] of guilds) {
        let chatSid = await getWorldChannelSid(serverId);
        pinus.app.rpc.chat.chatRemote.sendGuildActivityEnd.toServer(chatSid, serverId);
    }
}