213 lines
8.0 KiB
TypeScript
213 lines
8.0 KiB
TypeScript
|
|
import { ActionPointModel } from '../../../db/ActionPoint';
|
|
import { BattleDropModel } from '../../../db/BattleDrop';
|
|
import { ExpeditionPointModel } from '../../../db/ExpeditionPoint';
|
|
import { RoleModel } from '../../../db/Role';
|
|
|
|
import { getWarById, getWarJsons, getGamedata } from '../../../util/gamedata';
|
|
import { decodeStr, Reward } from '../../../util/util';
|
|
import { ACTION_POIN, BATTLE_REWARD_TYPE, WAR_JSON_ATTRIBUTE_TYPE } from '../../../consts/consts';
|
|
|
|
export async function getAp(now: number, roleId: string) {
|
|
let dataAp = await ActionPointModel.getAp(roleId);
|
|
const maxAp = ACTION_POIN.MAX; // 最大体力值
|
|
const per = ACTION_POIN.PER; // 恢复时间（ms)
|
|
let {ap, refTime} = dataAp;
|
|
if(ap >= maxAp) {
|
|
// 体力溢出不需要做时间的处理
|
|
return { ap, maxAp, refTime: now, apRemainTime:0, isOver: true }
|
|
} else {
|
|
if(refTime > now) refTime = now; // refTime：每次记录时候最近的一个整的时间点，绝对不会大于now
|
|
let n = Math.floor((now - refTime)/per); // 上次记录到现在可以增长多少体力
|
|
ap += n; // 增加上
|
|
if(ap >= maxAp) { // 加上后溢出了
|
|
ap = maxAp;
|
|
return { ap, maxAp, refTime: now, apRemainTime:0, isOver: true }
|
|
} else {
|
|
refTime += n * per; // 更新refTime到离现在最近的一个整的时间点
|
|
let apRemainTime = Math.floor((refTime + per - now)/1000); // 恢复下一点需要多少时间
|
|
|
|
return { ap, maxAp, refTime, apRemainTime, isOver: false }
|
|
}
|
|
}
|
|
}
|
|
|
|
export async function setAp(now: number, roleId: string, changeAp: number) {
|
|
let ApResult = await getAp(now, roleId);
|
|
let { ap, maxAp, refTime, apRemainTime, isOver } = ApResult; // 更新ap
|
|
ap += changeAp;
|
|
if(ap >= maxAp) { // 溢出
|
|
refTime = now;
|
|
apRemainTime = 0;
|
|
}
|
|
if(ap < 0) return null // 体力不足
|
|
await ActionPointModel.saveAp(roleId, ap, refTime);
|
|
|
|
if(isOver && ap < maxAp) apRemainTime = Math.floor(ACTION_POIN.PER / 1000); // 特殊处理
|
|
return {ap, maxAp, refTime, apRemainTime}
|
|
}
|
|
|
|
export class WarReward {
|
|
roleId: string;
|
|
roleName: string;
|
|
battleId: number;
|
|
condition: Map<number, boolean>;
|
|
warInfo: any;
|
|
isSuccess: boolean;
|
|
rewards: Array<{type: number, gid: number, count: number}>;
|
|
|
|
constructor(roleId: string, roleName: string, battleId: number, isSuccess: boolean) {
|
|
this.roleId = roleId;
|
|
this.roleName = roleName;
|
|
this.battleId = battleId;
|
|
this.condition = new Map();
|
|
this.warInfo = getWarById(battleId);
|
|
this.isSuccess = isSuccess;
|
|
}
|
|
|
|
public setCondition(id: number, isOk: boolean) {
|
|
this.condition.set(id, isOk);
|
|
}
|
|
|
|
private handleFixReward(num: number) {
|
|
if(this.isSuccess) { // 成功了才给固定奖励
|
|
let {fixReward = ''} = this.warInfo;
|
|
let reward = decodeStr('fixReward', fixReward);
|
|
for(let obj of reward) this.rewards.push({type: BATTLE_REWARD_TYPE.FIX_REWARD, ...obj, count: obj.count * num});
|
|
}
|
|
}
|
|
private handleConditionReward(num: number) {
|
|
if(this.isSuccess) {
|
|
let {conditionReward = ''} = this.warInfo;
|
|
let reward = decodeStr('conditionReward', conditionReward);
|
|
for(let obj of reward) {
|
|
if(this.condition.get(obj.condition)) {
|
|
this.rewards.push({type: BATTLE_REWARD_TYPE.CONDITION_REWARD, ...obj, count: obj.count * num});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private async handleRandomReward(num: number) {
|
|
if(this.isSuccess) {
|
|
let {RandomReward:randomReward = ''} = this.warInfo;
|
|
|
|
let reward = decodeStr('randomReward', randomReward);
|
|
for(let obj of reward) {
|
|
let { gid, frequency } = obj;
|
|
let dropHistory = await BattleDropModel.findByGid(this.roleId, this.battleId, gid);
|
|
let { getNum = 0, allNum = 0, getSum = 0, allSum = 0 } = dropHistory;
|
|
for(let i = 0; i < num; i ++) {
|
|
let flag = false; // 是否可以获得
|
|
if(allNum + 1 > frequency) {
|
|
allNum = 0; getNum = 0;
|
|
}
|
|
allNum++; allSum++;
|
|
if(getNum == 0) {
|
|
let r = Math.random();
|
|
if(r <= 1/frequency*allNum || (allNum >= frequency) ) {
|
|
flag = true; // 独立概率随机
|
|
}
|
|
}
|
|
if(flag) {
|
|
getNum ++; getSum++;
|
|
this.rewards.push({type: BATTLE_REWARD_TYPE.RANDOM_REWARD, ...obj});
|
|
}
|
|
}
|
|
await BattleDropModel.updateByGid(this.roleId, this.battleId, gid, {
|
|
getNum, allNum, getSum, allSum
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
public async saveReward(num: number) {
|
|
this.rewards = new Array();
|
|
let warType = this.warInfo.warType;
|
|
|
|
await this.handleFixReward(num);
|
|
await this.handleConditionReward(num);
|
|
await this.handleRandomReward(num);
|
|
|
|
let rewardObject = new Reward(this.roleId, this.roleName, this.rewards);
|
|
let returnGoods = await rewardObject.saveReward();
|
|
return returnGoods;
|
|
}
|
|
|
|
}
|
|
|
|
export async function matchPlayers(scale: number, range: number, myCe: number ,enemyObj: {enemyFrom: number, enemyId: string, enemies: Array<any> }) {
|
|
|
|
let min = myCe * scale * (1 - range/100);
|
|
let max = myCe * scale * (1 + range/100);
|
|
console.log(min, max, enemyObj);
|
|
|
|
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) {
|
|
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 function decodeWarJsonAttribute(attribute) {
|
|
let arr = decodeStr('attribute', attribute);
|
|
let obj = {};
|
|
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) {
|
|
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
let {expeditionPoint} = 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 getCEScaleAndRange(roleId: string, curDicExpedition: any) {
|
|
// 匹配，判断是不是新手期
|
|
const role = await RoleModel.findByRoleId(roleId);
|
|
let now = new Date();
|
|
let today = now.setHours(0,0,0,0);
|
|
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}
|
|
} |