142 lines
4.8 KiB
TypeScript
142 lines
4.8 KiB
TypeScript
import { Circle, RougelikeTechModel, RougelikeTechType } from '../../db/RougelikeTech';
|
|
import { gameData } from '../../pubUtils/data';
|
|
import { HeroModel } from '../../db/Hero';
|
|
import { compareNumberArray } from '../../pubUtils/util';
|
|
import { ROUGE_EFFECT_TYPE, ROUGE_LIKE_STATUS } from '../../consts';
|
|
import { updateMaxHp } from './rougeService';
|
|
import { RougelikeRecordModel } from '../../db/RougelikeRecord';
|
|
|
|
/**
|
|
* 首页获得的科技树数据
|
|
* @param techData
|
|
* @returns
|
|
*/
|
|
export async function getTechData(roleId: string) {
|
|
let techData = await RougelikeTechModel.findByRoleId(roleId);
|
|
if(!techData) return { techTrees: [], sumTechScore: 0 };
|
|
let { unlockedTech = [], circles = [] } = techData;
|
|
circles = await calCircleCe(roleId, unlockedTech, circles);
|
|
let techTrees = unlockedTech.map(techId => getSingleTechData(techId, circles));
|
|
return {
|
|
techTrees
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 从首页重新进入，重新计算他的战力
|
|
* @param roleId
|
|
* @param circles
|
|
* @returns
|
|
*/
|
|
async function calCircleCe(roleId: string, unlockedTech: number[], circles: Circle[]) {
|
|
let hids: number[] = circles.map(circle => circle.hid).filter(hid => hid > 0);
|
|
if(hids.length <= 0) return circles
|
|
let heroes = await HeroModel.findByHidRange(hids, roleId);
|
|
let newCircle = circles.map(circle => {
|
|
if(circle.hid == 0) return circle;
|
|
let hero = heroes.find(cur => cur.hid == circle.hid);
|
|
return { ...circle, ce: hero?.ce||0 }
|
|
});
|
|
let effectIds = getTechEffectIds(unlockedTech, circles)
|
|
await RougelikeTechModel.updateCircle(roleId, newCircle, effectIds);
|
|
return newCircle;
|
|
}
|
|
|
|
export async function updateEffectId(techData: RougelikeTechType) {
|
|
let effectIds = getTechEffectIdsByData(techData);
|
|
if(!compareNumberArray(effectIds, techData.effectIds||[])) {
|
|
await RougelikeTechModel.updateEffectId(techData.roleId, effectIds);
|
|
if (hasMaxHpUpdate(effectIds, techData.effectIds||[])) {
|
|
const dbRecord = await RougelikeRecordModel.findByRoleIdAndStatus(techData.roleId, ROUGE_LIKE_STATUS.SUCCESS)
|
|
if(dbRecord) await updateMaxHp(techData.roleId, dbRecord.gameCode, dbRecord.type, dbRecord.grade)
|
|
}
|
|
}
|
|
}
|
|
|
|
function hasMaxHpUpdate(effectIds: number[], oldEffectIds: number[]) {
|
|
let newEffectIds: number[] = [];
|
|
for(let effectId of effectIds) {
|
|
if (!oldEffectIds.includes(effectId)) newEffectIds.push(effectId);
|
|
}
|
|
for(let effectId of newEffectIds) {
|
|
let dicRougeEffect = gameData.rougeEffect.get(effectId);
|
|
if(dicRougeEffect && dicRougeEffect.effectType == ROUGE_EFFECT_TYPE.TECH_CHARA_MAIN_ATTR_UP) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 处理后单个科技点的数据
|
|
* @param techData
|
|
* @param techId
|
|
* @returns
|
|
*/
|
|
export function getCurTechData(techData: RougelikeTechType, techId: number) {
|
|
if(!techData || !techId) return { curTechTree: { techId, circles: [] } }
|
|
let { circles = [] } = techData;
|
|
return {
|
|
curTechTree: getSingleTechData(techId, circles)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取单片科技树数据
|
|
* @param techId
|
|
* @param circles
|
|
* @returns
|
|
*/
|
|
function getSingleTechData(techId: number, circles: Circle[]) {
|
|
let result: { circleId: number, hid: number, ce: number }[] = [];
|
|
for(let { techId: curTechId, hid, circleId, ce } of circles) {
|
|
if(curTechId == techId) result.push({ hid, circleId, ce });
|
|
}
|
|
return { techId, circles: result };
|
|
}
|
|
|
|
/**
|
|
* 检查前置科技点是否解锁
|
|
* @param techId
|
|
* @param unlockedTech
|
|
* @returns
|
|
*/
|
|
export function checkPreRougeTech(techId: number, unlockedTech: number[]) {
|
|
let dicTech = gameData.rougeTech.get(techId);
|
|
let preTechId = dicTech?.preTechId||[];
|
|
for(let techId of preTechId) {
|
|
if(!unlockedTech.includes(techId)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 获取科技树带来的type加成
|
|
* @param roleId
|
|
* @returns [{ type: number, param: number[] }]
|
|
*/
|
|
export function getTechEffectIdsByData(techData: RougelikeTechType) {
|
|
if(!techData) return [];
|
|
return getTechEffectIds(techData.unlockedTech, techData.circles);
|
|
}
|
|
|
|
export function getTechEffectIds(unlockedTech: number[], circles: Circle[]) {
|
|
let result: number[] = [];
|
|
let techMap = new Map<number, number>();
|
|
for(let techId of unlockedTech) {
|
|
techMap.set(techId, 0);
|
|
}
|
|
for(let { techId, ce } of circles) {
|
|
let oldCe = techMap.get(techId)||0;
|
|
techMap.set(techId, oldCe + ce);
|
|
}
|
|
for(let [techId, ce] of techMap) {
|
|
let levelDatas = gameData.rougeTechLevel.get(techId)||[];
|
|
let effectIds: number[] = [];
|
|
for(let { techEffectIds, ce: targetCe } of levelDatas) {
|
|
if(ce >= targetCe) effectIds = techEffectIds;
|
|
}
|
|
result.push(...effectIds);
|
|
}
|
|
return result;
|
|
} |