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

import { ExpeditionPointModel } from '../db/ExpeditionPoint';
import Role, { RoleModel } from '../db/Role';
import { PvpDefenseModel } from '../db/PvpDefense';

import { getWarJsons, getGamedata } from '../pubUtils/gamedata';
import { decodeStr, resResult, setLocalHours, shouldRefresh } from '../pubUtils/util';
import { WAR_JSON_ATTRIBUTE_TYPE, EXPEDITION_CONST } from '../consts/consts';


// 匹配玩家
export async function matchPlayers(roleId: string, scale: number, range: number, myCe: number, warJsonIndex:any, enemyObj: {enemyFrom: number, enemyId: string, enemies: Array<any> }) {
    let {json: dicWarJson } = getWarJsons(warJsonIndex);

    let min = myCe * scale * (1 - range/100);
    let max = myCe * scale * (1 + range/100);

    let resultRange = await PvpDefenseModel.findByScale(roleId, min, max);
    if(resultRange.length > 0) {
        let index = Math.floor(Math.random() * resultRange.length);
        let result = resultRange[index];
        let {roleId, heroes } = result;

        enemyObj.enemyFrom = 1;
        enemyObj.enemyId = roleId;
        
        let heroIndex = 0;
        for(let enemy of dicWarJson) {
            if(enemy.relation == 2) {
                let hero = heroes[heroIndex];
                if(hero) {
                    enemyObj.enemies.push({...enemy, ...hero});
                    heroIndex ++;
                }
            }
        }

        return true;
    } else {
        return false
    }
}

// 匹配机器人
export async function matchRobots(scale: number, myCe: number, robotCe: number, warJsonIndex:any, lv: number, enemyObj: {enemyFrom: number, enemyId: string, enemies: Array<any> }) {
    let {json: dicWarJson, fileName } = getWarJsons(warJsonIndex);
    if(dicWarJson) {
        enemyObj.enemyFrom = 2;
        enemyObj.enemyId = fileName;

        let ratio = myCe / robotCe * scale; // 玩家战力/机器人初始战力*系数
        for(let enemy of dicWarJson) {
            if(enemy.relation == 2) {
                let attribute = decodeWarJsonAttribute(enemy.attribute);  // 格式：{'hp':1000, ...}
                for(let value in attribute) {
                    attribute[value] *= ratio;
                    attribute[value] = Math.round(attribute[value]);
                }
                enemyObj.enemies.push({...enemy, attribute, lv});
            }
        }

        return true
    } else {
        return false
    }
}

// 远征匹配系数表
export async function getCEScaleAndRange(roleId: string, curDicExpedition: any) {
    // 匹配，判断是不是新手期
    const role = await RoleModel.findByRoleId(roleId);
    let now = new Date();
    let today = setLocalHours(0, now);
    let isNew = today - role.createdAt.getTime() <= 3*24*60*60*1000;
    let scale = isNew?curDicExpedition.CEScaleNew:curDicExpedition.CEScale;
    let range = isNew?curDicExpedition.CERangeNew:curDicExpedition.CERange;
    return {scale, range, lv: role.lv}
}

// 远征表属性解码
export function decodeWarJsonAttribute(attribute) {
    let arr = decodeStr('attribute', attribute);
    let obj = {}
    for(let key in WAR_JSON_ATTRIBUTE_TYPE) {
        obj[WAR_JSON_ATTRIBUTE_TYPE[key]] = 0; // 初始化
    }
    for(let {id, value} of arr) {
        let field = WAR_JSON_ATTRIBUTE_TYPE[id];
        if(field) {
        obj[field] = value;
        }
    }
    return obj
}

// 远征累计点数获取
export async function getPointRewardStatus(roleId: string, role?: Role) {
    if(!role) {
        role = await RoleModel.findByRoleId(roleId);
    }
    let {expeditionPoint = 0} = role;
    let dicExpeditionPoint = getGamedata('dic_expedition_point');
    let pointRewards = {
        expeditionPoint,
        rewards: dicExpeditionPoint.map(cur => {
            return { point: cur.point, received: false }
        })
    };
    let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
    if(pointStatusInDatabase) {
        let { rewards = [] } = pointStatusInDatabase;
        pointRewards.rewards.forEach(cur => {
            let obj = rewards.find(ccur => ccur.point == cur.point);
            if(obj) cur.received = obj.received;
        });
    }
    return pointRewards
}

export async function getResetRemainCnt(curTime: Date, roleId: string, role?: Role, ) {
    if(!role) {
        role = await RoleModel.findByRoleId(roleId);
    }

    let { expeditionResetCnt, expeditionResetRefTime } = role;
    let needRefresh = !expeditionResetRefTime || shouldRefresh(expeditionResetRefTime, curTime, EXPEDITION_CONST.REFRESH_TIME);
    if(needRefresh) {
        expeditionResetCnt = 0; expeditionResetRefTime = curTime;
    }

    let maxCnt = EXPEDITION_CONST.RESET_CNT;
    
    return {
        resetCnt: maxCnt - expeditionResetCnt,
        needRefresh
    };
}