ZYZ/shared/pubUtils/util.ts

import { STATUS } from './../consts/statusCode';

import { getGamedata } from './gamedata';
import { HeroModel } from '../db/Hero';
const moment = require('moment');

  export function genCode(len) {
    const chars = '123456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijklmnopqrstuvwxyz';
    const charArr = chars.split('');
    let code = '';
    for (let i = 0; i < len; i++) {
      code += charArr[Math.floor(Math.random() * charArr.length)];
    }
    return code;
  }

  export function decodeStr(type, str, splitForm='|') {
    if(str == '&'|| !str) {
      return []
    } else {
      return str.split(splitForm).map(cur => {
        return decodeStrSingle(type,cur);
      });
    };
  }

  export function decodeStrSingle(type, str) { //单层，返回对象而不是数组
    if(str == '&'|| !str) {
      return {}
    } else {
      let arr = str.split('&');
      let result: any;
      switch (type) {
        case 'fixReward': {
          let [gid, count] = arr;
          if(isNaN(gid) || isNaN(count)) throw new Error('data table format wrong');
          result = { gid: parseInt(gid), count: parseInt(count)};
          break;
        }
        case 'conditionReward': {
          let [gid, count, condition] = arr;
          if(isNaN(gid) || isNaN(count)) throw new Error('data table format wrong');
          result = { gid: parseInt(gid), count: parseInt(count), condition: parseInt(condition) };
          break;
        }
        case 'randomReward': {
          let [gid, count, frequency] = arr;
          if(isNaN(gid) || isNaN(count)) throw new Error('data table format wrong');
          result = { gid: parseInt(gid), count: parseInt(count), frequency: parseInt(frequency) };
          break;
        }
        case 'eventSuitLevel': {
          let [min, max] = arr;
          if(isNaN(min) || isNaN(max)) throw new Error('data table format wrong');
          result = { min: parseInt(min), max: parseInt(max) };
          break;
        }
        case 'attribute': {
          let [id, value] = arr;
          if(isNaN(id) || isNaN(value)) throw new Error('data table format wrong');
          result = { id: parseInt(id), value: parseInt(value) };
          break;
        }
        case 'point': {
          let [x] = arr;
          if(isNaN(x)) throw new Error('data table format wrong');
          result = x;
          break;
        }
      }
      return result;
    };
  }

/**
 * 将 | 分隔的字符串解析为数组，如：a|b|c 解析为[a, b, c]
 * @param str 要解析的字符串
 */
export function decodeArrayStr(str: string) {
  if(str == '&') str = '';
  return str.split('|');
}

/**
 * 将 | 和 & 分隔的字符串解析为 Map，，如：a&b|c&d|e&f 解析为 Map {a=>b, c=>d, e=>f}
 * @param str 要解析的字符串
 */
export function decodeIdCntArrayStr(str: string, multi: number) {
  const strArr = decodeArrayStr(str);
  const strMap = new Map();
  strArr.forEach(item => {
    const kv = item.split('&');
    strMap.set(kv[0], multi? parseInt(kv[1]) * multi: kv[1]);
  });
  return strMap;
}

  // 计算当前武将战力
  export async function calculateSumCE(roleId: string, type: number, param: { num?: number, heroes?: Array<number> }) {
    let sum;
    if(type == 1) { // 最高num人战力和
      sum = await HeroModel.sumTopHeroCe(roleId, param.num||0);
    } else if(type == 2) { // 所有人战力和
      sum = await HeroModel.sumHeroCe(roleId);
    }
    return sum;
  }
  // 计算当前武将战力
  export function calculateCE(heroInfo: {hid: number, lv: number }) {
    let { hid, lv } = heroInfo;
    // 假设所有属性和等级的关系是简单的线性关系
    let dicHero = getGamedata('dic_zyz_hero');
    let curDicHero = dicHero.find(cur => cur.heroId == hid);

    let { atk, matk, def, mdef, agi, luk, atk_up, matk_up, def_up, mdef_up, agi_up, luk_up } = curDicHero;
    atk += lv * atk_up;
    matk += lv * matk_up;
    def += lv * def_up;
    mdef += lv * mdef_up;
    agi += lv * agi_up;
    luk += lv * luk_up;

    // 假设战力为所有属性的简单加法

    let ce = atk + matk + def + mdef + agi + luk;
    return ce;
  }


  export function getRandomWithWeight(randomList: any) {
    let len = randomList.reduce((pre, cur) => {
        return pre + cur.weight||1;
    }, 0);
    let index = Math.floor(Math.random() * len);
    let result = { dic: null, index: -1 };
    for(let i = 0; i < randomList.length; i++) {
        let {weight = 0} = randomList[i];
        if(index < weight) {
          result.dic = randomList[i]; 
          result.index = i;
          break;
        }
        index -= weight;
    }
    return result
  }
/**
 * 传入两个时间，返回按照时间差计算，第二个时间比第一个晚几天
 * @param preTime 之前的时间
 * @param proTime 之后的时间
 */
export function deltaDays(preTime: Date, proTime: Date): number {
  return moment(proTime).diff(moment(preTime), "days");
}

/**
 * 计算按照每 x 天 y 点刷新一次，是否应该刷新
 * @param preTime 基准时间
 * @param curTime 当前时间
 * @param hour 几点刷新
 * @param deltaDay 间隔几天刷新，默认每天刷新(deltaDay = 1)
 */
export function shouldRefresh(preTime: Date, curTime: Date, hour: number, deltaDay = 1): boolean {
  let refeshTime = curTime.setHours(hour, 0, 0, 0);
  if (refeshTime - preTime.getTime() > deltaDay * 24 * 60 * 60 * 1000 && curTime.getTime() >= refeshTime) {
    return true;
  }
  return false;
}

export function getRandEelm(source: Array<any> = [], cnt = 1): Array<any> {
  if (cnt > source.length) return [];
  if (cnt === source.length) return source;
  let idxs = new Set();
  for (let i = 0; i < cnt; ++i) {
    let rand = Math.floor(Math.random() * source.length);
    idxs.add(rand);
    if (idxs.size == cnt) {
      break;
    }
  }
  return source.filter((_item, idx) => idxs.has(idx));
}

export function resResult(status: {code: number, simStr: string}, data = null, customMsg = '') {
  const { code, simStr } = status;
  if (code !== STATUS.SUCCESS.code) {
    console.log(`normal err, code: ${code}, des: ${customMsg || simStr}`);
  }
  return {code, msg: customMsg || simStr, data};
}