xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

战力：修复创建武将bug

Browse Source
This commit is contained in:
luying
2022-03-28 17:44:14 +08:00
parent f35af70adc
commit 14b28921af
13 changed files with 379 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-server/app/servers/gm/handler/gmRoleHandler.ts
+3 -5
View File
@@ -20,9 +20,8 @@ import { GuildLeader } from '../../../domain/rank';
import { HeroModel } from '../../../db/Hero'; import { HeroModel } from '../../../db/Hero';
import { SkinModel } from '../../../db/Skin'; import { SkinModel } from '../../../db/Skin';
import { PvpDefenseModel } from '../../../db/PvpDefense'; import { PvpDefenseModel } from '../../../db/PvpDefense';
import { calculatetopLineup } from '../../../pubUtils/util';
import { createHeroes } from '../../../services/role/createHero'; import { createHeroes } from '../../../services/role/createHero';
import { calculateCe } from '../../../services/playerCeService'; import { calculateCeWithHero } from '../../../services/playerCeService';
let timer: NodeJS.Timer; let timer: NodeJS.Timer;
export default function (app: Application) { export default function (app: Application) {
@@ -95,7 +94,7 @@ export class GmRoleHandler {
param.lv = newLv; param.lv = newLv;
param['exp'] = exp; param['exp'] = exp;
} }
await calculateCe(HERO_SYSTEM_TYPE.INIT, roleId, hero.serverId, sid, param, {}, { hid }); await calculateCeWithHero(HERO_SYSTEM_TYPE.INIT, roleId, hero.serverId, sid, hid, param);
// if(param.job > 0) { // if(param.job > 0) {
// await calculateCe(HERO_SYSTEM_TYPE.STAGEUP, roleId, hero.serverId, sid, param, {}, { hid }); // await calculateCe(HERO_SYSTEM_TYPE.STAGEUP, roleId, hero.serverId, sid, param, {}, { hid });
@@ -118,9 +117,8 @@ export class GmRoleHandler {
await HeroModel.deleteHero(roleId, hid); await HeroModel.deleteHero(roleId, hid);
await SkinModel.deleteByHero(roleId, hid); await SkinModel.deleteByHero(roleId, hid);
let role = await RoleModel.findByRoleId(roleId); let role = await RoleModel.findByRoleId(roleId);
let { topLineup, topLineupCe } = await calculatetopLineup(role, hid, 0, null);
await PvpDefenseModel.deleteHero(roleId, hid); await PvpDefenseModel.deleteHero(roleId, hid);
await RoleModel.updateRoleInfo(roleId, { topLineup, topLineupCe, ce: role.ce - hero.ce }); await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup.filter(cur => cur.hid != hid), topLineupCe: role.topLineupCe - hero.ce, ce: role.ce - hero.ce });
return resResult(STATUS.SUCCESS); return resResult(STATUS.SUCCESS);
} }
game-server/app/servers/role/handler/equipHandler.ts
+13 -13
View File
@@ -16,7 +16,7 @@ import { pushEquipQualityMax, pushEquipStarMax } from "../../../services/sysChat
import { addConsumeToHero } from "../../../services/roleService"; import { addConsumeToHero } from "../../../services/roleService";
import { CheckMeterial } from "../../../services/role/checkMaterial"; import { CheckMeterial } from "../../../services/role/checkMaterial";
import { combineItems } from "../../../services/role/util"; import { combineItems } from "../../../services/role/util";
import { calculateCe } from "../../../services/playerCeService"; import { calculateCeWithHero } from "../../../services/playerCeService";
export default function (app: Application) { export default function (app: Application) {
new HandlerService(app, {}); new HandlerService(app, {});
@@ -58,7 +58,7 @@ export class EquipHandler {
consumes: addConsumeToHero(hero.consumes, dicEquip.composeMaterial), consumes: addConsumeToHero(hero.consumes, dicEquip.composeMaterial),
} }
await calculateCe(HERO_SYSTEM_TYPE.COMPOSE_EQUIP, roleId, serverId, sid, update, {}, { hid, ePlaceId }); await calculateCeWithHero(HERO_SYSTEM_TYPE.COMPOSE_EQUIP, roleId, serverId, sid, hid, update, { ePlaceId });
await checkTaskInComposeEquip(serverId, roleId, sid, oldEplace, newEplace); await checkTaskInComposeEquip(serverId, roleId, sid, oldEplace, newEplace);
let curHero = { let curHero = {
@@ -105,7 +105,7 @@ export class EquipHandler {
ePlace: newEplace, ePlace: newEplace,
consumes: addConsumeToHero(hero.consumes, consumes) consumes: addConsumeToHero(hero.consumes, consumes)
} }
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, serverId, sid, update, {}, { hid, ePlaceId }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, serverId, sid, hid, update, { ePlaceId });
await checkTaskInEquipLvUp(serverId, roleId, sid, oldEplace, newEplace, [ePlaceId]); await checkTaskInEquipLvUp(serverId, roleId, sid, oldEplace, newEplace, [ePlaceId]);
const curHero = { const curHero = {
@@ -156,7 +156,7 @@ export class EquipHandler {
ePlace: newEplace, ePlace: newEplace,
consumes: addConsumeToHero(hero.consumes, consumes), consumes: addConsumeToHero(hero.consumes, consumes),
} }
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, serverId, sid, update, {}, { hid, ePlaceIds: [...eplaceIds.keys()] }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, serverId, sid, hid, update, { ePlaceIds: [...eplaceIds.keys()] });
await checkTaskInEquipLvUp(serverId, roleId, sid, ePlace, newEplace, [...eplaceIds.keys()]); await checkTaskInEquipLvUp(serverId, roleId, sid, ePlace, newEplace, [...eplaceIds.keys()]);
const curHero = { const curHero = {
@@ -223,7 +223,7 @@ export class EquipHandler {
ePlace: newEplace, ePlace: newEplace,
consumes: addConsumeToHero(hero.consumes, consumes), consumes: addConsumeToHero(hero.consumes, consumes),
} }
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_QUALITY, roleId, serverId, sid, update, {}, { hid, ePlaceId }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_QUALITY, roleId, serverId, sid, hid, update, { ePlaceId });
await checkTaskInEquipQualityUp(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, hid, isUpQuality); await checkTaskInEquipQualityUp(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, hid, isUpQuality);
pushEquipQualityMax(roleId, roleName, serverId, hid, newEquip, isUpQuality); pushEquipQualityMax(roleId, roleName, serverId, hid, newEquip, isUpQuality);
@@ -298,7 +298,7 @@ export class EquipHandler {
ePlace: newEplace, ePlace: newEplace,
consumes: addConsumeToHero(hero.consumes, consumes) consumes: addConsumeToHero(hero.consumes, consumes)
} }
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_STAR, roleId, serverId, sid, update, {}, { hid, ePlaceId }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_STAR, roleId, serverId, sid, hid, update, { ePlaceId });
await checkTaskInEquipStarUp(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, hid, isUpStar); await checkTaskInEquipStarUp(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, hid, isUpStar);
pushEquipStarMax(roleId, roleName, serverId, hid, newEquip, isUpStar); pushEquipStarMax(roleId, roleName, serverId, hid, newEquip, isUpStar);
@@ -343,7 +343,7 @@ export class EquipHandler {
let canChange = originJewel && checkJewelCanPutOnEquip(originEquip, originJewel); let canChange = originJewel && checkJewelCanPutOnEquip(originEquip, originJewel);
if(canChange) canSentMineToOrigin = true; if(canChange) canSentMineToOrigin = true;
let { newEplace, updatedEplace } = updateEplace(originEplace, ePlaceId, { jewel: canChange? originJewel.seqId: 0 }); let { newEplace, updatedEplace } = updateEplace(originEplace, ePlaceId, { jewel: canChange? originJewel.seqId: 0 });
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_JEWEL, roleId, serverId, sid, { ePlace: newEplace }, {}, { hid, ePlaceId, oldJewel: jewel, newJewel: canChange? originJewel:null }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_JEWEL, roleId, serverId, sid, hid, { ePlace: newEplace }, { ePlaceId, oldJewel: jewel, newJewel: canChange? originJewel:null });
await checkTaskInPutJewel(serverId, roleId, sid, originEplace, newEplace, ePlaceId, jewel, canChange? originJewel:null); await checkTaskInPutJewel(serverId, roleId, sid, originEplace, newEplace, ePlaceId, jewel, canChange? originJewel:null);
originHeroResult = { hid: originHero.hid, ePlace: updatedEplace }; originHeroResult = { hid: originHero.hid, ePlace: updatedEplace };
@@ -356,7 +356,7 @@ export class EquipHandler {
// 目标镶嵌上 // 目标镶嵌上
let curJewel = await JewelModel.putOnOrOff(seqId, hid, ePlaceId); let curJewel = await JewelModel.putOnOrOff(seqId, hid, ePlaceId);
let { newEplace, updatedEplace } = updateEplace(oldEplace, ePlaceId, { jewel: seqId }); let { newEplace, updatedEplace } = updateEplace(oldEplace, ePlaceId, { jewel: seqId });
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_JEWEL, roleId, serverId, sid, { ePlace: newEplace }, {}, { hid, ePlaceId, oldJewel: originJewel, newJewel: curJewel }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_JEWEL, roleId, serverId, sid, hid, { ePlace: newEplace }, { ePlaceId, oldJewel: originJewel, newJewel: curJewel });
await checkTaskInPutJewel(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, originJewel, curJewel); await checkTaskInPutJewel(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, originJewel, curJewel);
let curHero = { let curHero = {
@@ -384,7 +384,7 @@ export class EquipHandler {
let curJewel = await JewelModel.putOnOrOff(curEquip.jewel, 0, 0); let curJewel = await JewelModel.putOnOrOff(curEquip.jewel, 0, 0);
let { newEplace, updatedEplace } = updateEplace(oldEplace, ePlaceId, { jewel: 0 }); let { newEplace, updatedEplace } = updateEplace(oldEplace, ePlaceId, { jewel: 0 });
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_JEWEL, roleId, serverId, sid, { ePlace: newEplace }, {}, { hid, ePlaceId, oldJewel: curJewel }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_JEWEL, roleId, serverId, sid, hid, { ePlace: newEplace }, { ePlaceId, oldJewel: curJewel });
await checkTaskInPutJewel(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, null, curJewel); await checkTaskInPutJewel(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, null, curJewel);
let curHero = { let curHero = {
@@ -437,7 +437,7 @@ export class EquipHandler {
ePlace: newEplace, ePlace: newEplace,
consumes: updateConsumes, consumes: updateConsumes,
} }
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_STONE, roleId, serverId, sid, update, {}, { hid, ePlaceId, jewel }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_STONE, roleId, serverId, sid, hid, update, { ePlaceId, jewel });
await checkTaskInPutStone(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, jewel); await checkTaskInPutStone(serverId, roleId, sid, oldEplace, newEplace, ePlaceId, jewel);
let curHero = { let curHero = {
@@ -557,7 +557,7 @@ export class EquipHandler {
// 更新战力 // 更新战力
if(hid > 0) { if(hid > 0) {
const hero = await HeroModel.findByHidAndRole(hid, roleId); const hero = await HeroModel.findByHidAndRole(hid, roleId);
await calculateCe(HERO_SYSTEM_TYPE.JEWEL_RESET_RANDSE, roleId, serverId, sid, {}, {}, { hid, ePlaceId, oldJewel: jewel, newJewel, hero }); await calculateCeWithHero(HERO_SYSTEM_TYPE.JEWEL_RESET_RANDSE, roleId, serverId, sid, hid, {}, { ePlaceId, oldJewel: jewel, newJewel, hero });
} }
await checkTaskInEquipReset(serverId, roleId, sid); await checkTaskInEquipReset(serverId, roleId, sid);
@@ -639,7 +639,7 @@ export class EquipHandler {
// 更新战力 // 更新战力
if(isSuccess && hid > 0) { if(isSuccess && hid > 0) {
const hero = await HeroModel.findByHidAndRole(hid, roleId); const hero = await HeroModel.findByHidAndRole(hid, roleId);
await calculateCe(HERO_SYSTEM_TYPE.JEWEL_QUENCH, roleId, serverId, sid, {}, {}, { hid, ePlaceId, oldJewel: jewel, newJewel, hero }); await calculateCeWithHero(HERO_SYSTEM_TYPE.JEWEL_QUENCH, roleId, serverId, sid, hid, {}, { ePlaceId, oldJewel: jewel, newJewel, hero });
} }
await checkTaskInEquipQuench(serverId, roleId, sid, isSuccess); await checkTaskInEquipQuench(serverId, roleId, sid, isSuccess);
@@ -759,7 +759,7 @@ export class EquipHandler {
// 更新战力 // 更新战力
if(targetJewel.hid > 0) { if(targetJewel.hid > 0) {
const hero = await HeroModel.findByHidAndRole(targetJewel.hid, roleId); const hero = await HeroModel.findByHidAndRole(targetJewel.hid, roleId);
await calculateCe(HERO_SYSTEM_TYPE.JEWEL_RESET_RANDSE, roleId, serverId, sid, {}, {}, { hid: targetJewel.ePlaceId, ePlaceId: targetJewel.ePlaceId, oldJewel: originJewel, newJewel, hero }); await calculateCeWithHero(HERO_SYSTEM_TYPE.JEWEL_RESET_RANDSE, roleId, serverId, sid, targetJewel.hid, {}, { hid: targetJewel.ePlaceId, ePlaceId: targetJewel.ePlaceId, oldJewel: originJewel, newJewel, hero });
} }
game-server/app/servers/role/handler/heroHandler.ts
+14 -17
View File
@@ -10,7 +10,6 @@ import { gameData, getHeroExpByLv, getHeroStarByQuality, getHeroWakeByQuality, g
import { ItemInter, RewardInter } from '../../../pubUtils/interface'; import { ItemInter, RewardInter } from '../../../pubUtils/interface';
import { getDropItems, FIGURE_UNLOCK_CONDITION } from '../../../consts/constModules/itemConst' import { getDropItems, FIGURE_UNLOCK_CONDITION } from '../../../consts/constModules/itemConst'
import { pushComposeOrangeHero, pushHeroQualityUpMsg, pushHeroStarMax, pushHeroWakeUp } from '../../../services/chatService'; import { pushComposeOrangeHero, pushHeroQualityUpMsg, pushHeroStarMax, pushHeroWakeUp } from '../../../services/chatService';
import { calculatetopLineup } from '../../../pubUtils/util';
import { PvpDefenseModel } from '../../../db/PvpDefense'; import { PvpDefenseModel } from '../../../db/PvpDefense';
import { checkTask, checkTaskInHeroQUalityUp, checkTaskInHeroStarUp, checkTaskInHeroTrain, checkTaskInHeroWakeUp } from '../../../services/task/taskService'; import { checkTask, checkTaskInHeroQUalityUp, checkTaskInHeroStarUp, checkTaskInHeroTrain, checkTaskInHeroWakeUp } from '../../../services/task/taskService';
import { isNumber, pick } from 'underscore'; import { isNumber, pick } from 'underscore';
@@ -22,7 +21,7 @@ import { HERO, REBORN } from '../../../pubUtils/dicParam';
import { createHero, createHeroes } from '../../../services/role/createHero'; import { createHero, createHeroes } from '../../../services/role/createHero';
import { CheckMeterial } from '../../../services/role/checkMaterial'; import { CheckMeterial } from '../../../services/role/checkMaterial';
import { HeroParam } from '../../../domain/roleField/hero'; import { HeroParam } from '../../../domain/roleField/hero';
import { calculateCe } from '../../../services/playerCeService'; import { calculateCeWithHero } from '../../../services/playerCeService';
export default function (app: Application) { export default function (app: Application) {
new HandlerService(app, {}); new HandlerService(app, {});
@@ -85,7 +84,6 @@ export class HeroHandler {
let { lv: oldLv, exp: oldExp } = hero; let { lv: oldLv, exp: oldExp } = hero;
if (oldLv >= playerLv) return resResult(STATUS.ROLE_HERO_LV_OVER); if (oldLv >= playerLv) return resResult(STATUS.ROLE_HERO_LV_OVER);
if (oldLv + addLv > playerLv) addLv = playerLv - oldLv; if (oldLv + addLv > playerLv) addLv = playerLv - oldLv;
console.log('******* addLv', addLv, oldLv, playerLv);
let nextExp = getHeroExpByLv(oldLv + addLv - 1); let nextExp = getHeroExpByLv(oldLv + addLv - 1);
console.log('nextExp', nextExp, oldLv + addLv - 1, oldExp) console.log('nextExp', nextExp, oldLv + addLv - 1, oldExp)
@@ -127,7 +125,7 @@ export class HeroHandler {
consumes: addConsumeToHero(hero.consumes, material) consumes: addConsumeToHero(hero.consumes, material)
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.LVUP, roleId, serverId, sid, update, {}, { hid }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.LVUP, roleId, serverId, sid, hid, update);
// 任务 // 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_LV, { oldLv, hero: curHero }); await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_LV, { oldLv, hero: curHero });
@@ -188,7 +186,7 @@ export class HeroHandler {
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.STAR, roleId, serverId, sid, update, {}, { hid, hero, isUpStar }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.STAR, roleId, serverId, sid, hid, update, { hid, hero, isUpStar });
if (isUpStar) { if (isUpStar) {
await checkTaskInHeroStarUp(serverId, roleId, sid, curHero, oldStar); // 任务 await checkTaskInHeroStarUp(serverId, roleId, sid, curHero, oldStar); // 任务
} }
@@ -236,7 +234,7 @@ export class HeroHandler {
consumes: addConsumeToHero(hero.consumes, material) consumes: addConsumeToHero(hero.consumes, material)
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.QUALITY, roleId, serverId, sid, update, {}, { hid, hero }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.QUALITY, roleId, serverId, sid, hid, update, { hero });
await checkTaskInHeroQUalityUp(serverId, roleId, sid, curHero); await checkTaskInHeroQUalityUp(serverId, roleId, sid, curHero);
pushHeroQualityUpMsg(roleId, roleName, serverId, curHero); pushHeroQualityUpMsg(roleId, roleName, serverId, curHero);
return resResult(STATUS.SUCCESS, { curHero: pick(curHero, ['hid', 'quality']) }); return resResult(STATUS.SUCCESS, { curHero: pick(curHero, ['hid', 'quality']) });
@@ -301,7 +299,7 @@ export class HeroHandler {
consumes: addConsumeToHero(hero.consumes, consumes) consumes: addConsumeToHero(hero.consumes, consumes)
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.COLORSTAR, roleId, serverId, sid, update, {}, { hid, hero, isUpStar }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.COLORSTAR, roleId, serverId, sid, hid, update, { hero, isUpStar });
if (isUpStar) { if (isUpStar) {
await checkTaskInHeroWakeUp(serverId, roleId, sid, curHero, oldColorStar); // 任务 await checkTaskInHeroWakeUp(serverId, roleId, sid, curHero, oldColorStar); // 任务
} }
@@ -353,7 +351,7 @@ export class HeroHandler {
jobStage: newJobStage, jobStage: newJobStage,
consumes: addConsumeToHero(hero.consumes, consumes) consumes: addConsumeToHero(hero.consumes, consumes)
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.TRAIN, roleId, serverId, sid, update, {}, { hid, hero }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.TRAIN, roleId, serverId, sid, hid, update, { hero });
await checkTaskInHeroTrain(serverId, roleId, sid, curHero, trainCount); // 任务 await checkTaskInHeroTrain(serverId, roleId, sid, curHero, trainCount); // 任务
return resResult(STATUS.SUCCESS, { curHero: pick(curHero, ['hid', 'job', 'jobStage'])}); return resResult(STATUS.SUCCESS, { curHero: pick(curHero, ['hid', 'job', 'jobStage'])});
} }
@@ -389,7 +387,7 @@ export class HeroHandler {
consumes: addConsumeToHero(hero.consumes, consumes) consumes: addConsumeToHero(hero.consumes, consumes)
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.STAGEUP, roleId, serverId, sid, update, {}, { hid, hero }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.STAGEUP, roleId, serverId, sid, hid, update, { hid, hero });
await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_STAGE_UP, { hero: curHero, stageUpCnt: 1 }); // 任务 await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_STAGE_UP, { hero: curHero, stageUpCnt: 1 }); // 任务
const heroResult = new HeroParam(curHero); const heroResult = new HeroParam(curHero);
return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'job', 'jobStage', 'totalTalentPoint']) }}); return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'job', 'jobStage', 'totalTalentPoint']) }});
@@ -444,7 +442,7 @@ export class HeroHandler {
consumes: addConsumeToHero(hero.consumes, consumes) consumes: addConsumeToHero(hero.consumes, consumes)
} }
//重算战力并下发 //重算战力并下发
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.CONNECT, roleId, serverId, sid, update, {}, { hid: hero.hid, shipId }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.CONNECT, roleId, serverId, sid, hero.hid, update, { shipId });
// 任务 // 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_CONNECT, { connectLv: level }) await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_CONNECT, { connectLv: level })
return resResult(STATUS.SUCCESS, { curHero: pick(curHero, ['hid', 'connections']) }); return resResult(STATUS.SUCCESS, { curHero: pick(curHero, ['hid', 'connections']) });
@@ -531,7 +529,7 @@ export class HeroHandler {
// } else { // } else {
// hero = await HeroModel.updateHeroInfo(roleId, hero.hid, update); // hero = await HeroModel.updateHeroInfo(roleId, hero.hid, update);
// } // }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.FAVOUR, roleId, serverId, sid, update, {}, { hid: hero.hid, isFavourLvUp }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.FAVOUR, roleId, serverId, sid, hero.hid, update, { isFavourLvUp });
if(isFavourLvUp) { if(isFavourLvUp) {
await unlockFigure(sid, roleId, [{ type: FIGURE_UNLOCK_CONDITION.HERO_FAVOR, paramHid: curHero.hid, paramFavourLv: curHero.favourLv }]); await unlockFigure(sid, roleId, [{ type: FIGURE_UNLOCK_CONDITION.HERO_FAVOR, paramHid: curHero.hid, paramFavourLv: curHero.favourLv }]);
await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_FAVOUR_LV, { hero: curHero, oldFavourLv: oldLv }); // 任务 await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_FAVOUR_LV, { hero: curHero, oldFavourLv: oldLv }); // 任务
@@ -591,7 +589,7 @@ export class HeroHandler {
job: dicNewJob.jobid, job: dicNewJob.jobid,
ePlace: newEplace ePlace: newEplace
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.SKIN, roleId, serverId, sid, update, {}, { hid: hero.hid }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.SKIN, roleId, serverId, sid, hero.hid, update);
let resultHero = new HeroParam(curHero); let resultHero = new HeroParam(curHero);
return resResult(STATUS.SUCCESS, { curHero: {...pick(resultHero, ['hid', 'skins', 'skinId', 'job', 'talent', 'usedTalentPoint']), ePlace: newEplace }}); return resResult(STATUS.SUCCESS, { curHero: {...pick(resultHero, ['hid', 'skins', 'skinId', 'job', 'talent', 'usedTalentPoint']), ePlace: newEplace }});
} }
@@ -658,7 +656,7 @@ export class HeroHandler {
} }
} }
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.REBIRTH, roleId, serverId, sid, {...initInfo, attr: heroAttr}, {}, { hid }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.REBIRTH, roleId, serverId, sid, hid, {...initInfo, attr: heroAttr});
let goods = await addItems(roleId, roleName, sid, consumes, ITEM_CHANGE_REASON.REBIRTH); let goods = await addItems(roleId, roleName, sid, consumes, ITEM_CHANGE_REASON.REBIRTH);
const heroResult = new HeroParam(curHero); const heroResult = new HeroParam(curHero);
@@ -698,7 +696,7 @@ export class HeroHandler {
let { newSkins } = updateSkinTalent(skins, new Talent(id), usedTalentPoint + needTalentPoint); let { newSkins } = updateSkinTalent(skins, new Talent(id), usedTalentPoint + needTalentPoint);
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.TALENT, roleId, serverId, sid, { skins: newSkins }, {}, { hid }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.TALENT, roleId, serverId, sid, hid, { skins: newSkins });
const heroResult = new HeroParam(curHero); const heroResult = new HeroParam(curHero);
return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'talent', 'usedTalentPoint', 'totalTalentPoint']) }}); return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'talent', 'usedTalentPoint', 'totalTalentPoint']) }});
@@ -735,7 +733,7 @@ export class HeroHandler {
let { newSkins } = updateSkinTalent(skins, new Talent(id, talent.level + 1), usedTalentPoint + needTalentPoint); let { newSkins } = updateSkinTalent(skins, new Talent(id, talent.level + 1), usedTalentPoint + needTalentPoint);
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.TALENT, roleId, serverId, sid, { skins: newSkins }, {}, { hid }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.TALENT, roleId, serverId, sid, hid, { skins: newSkins });
const heroResult = new HeroParam(curHero); const heroResult = new HeroParam(curHero);
return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'talent', 'usedTalentPoint', 'totalTalentPoint']) }}); return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'talent', 'usedTalentPoint', 'totalTalentPoint']) }});
} }
@@ -760,7 +758,7 @@ export class HeroHandler {
let newSkins = initSkinTalent(skins); let newSkins = initSkinTalent(skins);
let { curHero } = await calculateCe(HERO_SYSTEM_TYPE.TALENT, roleId, serverId, sid, { skins: newSkins }, {}, { hid }); let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.TALENT, roleId, serverId, sid, hid, { skins: newSkins });
const heroResult = new HeroParam(curHero); const heroResult = new HeroParam(curHero);
return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'talent', 'usedTalentPoint', 'totalTalentPoint']) }}); return resResult(STATUS.SUCCESS, { curHero: {...pick(heroResult, ['hid', 'talent', 'usedTalentPoint', 'totalTalentPoint']) }});
@@ -820,7 +818,6 @@ export class HeroHandler {
await HeroModel.deleteHero(roleId, hid); await HeroModel.deleteHero(roleId, hid);
let role = await RoleModel.findByRoleId(roleId); let role = await RoleModel.findByRoleId(roleId);
await calculatetopLineup(role, hid, 0, null);
await PvpDefenseModel.deleteHero(roleId, hid); await PvpDefenseModel.deleteHero(roleId, hid);
await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup, topLineupCe: role.topLineupCe, ce: role.ce - hero.ce }); await RoleModel.updateRoleInfo(roleId, { topLineup: role.topLineup, topLineupCe: role.topLineupCe, ce: role.ce - hero.ce });
return resResult(STATUS.SUCCESS); return resResult(STATUS.SUCCESS);
game-server/app/servers/role/handler/roleHandler.ts
+13 -13
View File
@@ -1,6 +1,6 @@
import { STATUS } from '../../../consts/statusCode'; import { STATUS } from '../../../consts/statusCode';
import { RoleModel, RoleUpdate } from './../../../db/Role'; import { RoleModel, RoleUpdate } from './../../../db/Role';
import { HeroModel, HeroUpdate } from '../../../db/Hero'; import { HeroModel, HeroType, HeroUpdate } from '../../../db/Hero';
import { resResult, decodeIdCntArrayStr, parseGoodStr, genCode } from '../../../pubUtils/util'; import { resResult, decodeIdCntArrayStr, parseGoodStr, genCode } from '../../../pubUtils/util';
import { Application, BackendSession, pinus, HandlerService, } from 'pinus'; import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
import { handleCost, addItems, getGoldObject, getCoinObject } from '../../../services/role/rewardService'; import { handleCost, addItems, getGoldObject, getCoinObject } from '../../../services/role/rewardService';
@@ -24,8 +24,8 @@ import * as dicParam from '../../../pubUtils/dicParam';
import Counter from '../../../db/Counter'; import Counter from '../../../db/Counter';
import { UserModel } from '../../../db/User'; import { UserModel } from '../../../db/User';
import { checkFilterWords, reportTAEvent, treatRoleName } from '../../../services/sdkService'; import { checkFilterWords, reportTAEvent, treatRoleName } from '../../../services/sdkService';
import { createHeroes, CreateHeroes } from '../../../services/role/createHero'; import { createHeroes } from '../../../services/role/createHero';
import { calculateCe } from '../../../services/playerCeService'; import { calculateCeWithHero, calculateWithRole } from '../../../services/playerCeService';
export default function (app: Application) { export default function (app: Application) {
new HandlerService(app, {}); new HandlerService(app, {});
@@ -44,14 +44,14 @@ export class RoleHandler {
let { roleName } = msg; let { roleName } = msg;
let role = await RoleModel.findByRoleId(roleId, 'roleName hasInit', true); let role = await RoleModel.findByRoleId(roleId, 'roleName hasInit title teraphs', true);
if (role.hasInit) return resResult(STATUS.ROLE_HAS_INIT); if (role.hasInit) return resResult(STATUS.ROLE_HAS_INIT);
let checkName = await RoleModel.checkName(roleName, serverId); let checkName = await RoleModel.checkName(roleName, serverId);
if (checkName) return resResult(STATUS.NAME_HAS_USED); if (checkName) return resResult(STATUS.NAME_HAS_USED);
let { resultHeroes: heroes } = await createHeroes(roleId, roleName, sid, serverId, DEFAULT_HEROES.map(hid => ({hid, count: 1}))); let { resultHeroes: heroes } = await createHeroes(roleId, roleName, sid, serverId, DEFAULT_HEROES.map(hid => ({hid, count: 1})), { roleName, hasInit: true, title: role.title, teraphs: role.teraphs });
role = await RoleModel.updateRoleInfo(roleId, { roleName, hasInit: true }); // role = await RoleModel.updateRoleInfo(roleId, { roleName, hasInit: true }); // 在算战力的时候一起更新
session.set('roleName', roleName); session.set('roleName', roleName);
session.push('roleName', () => { }); session.push('roleName', () => { });
@@ -95,7 +95,7 @@ export class RoleHandler {
return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH); return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let update = { title: title + 1 } let update = { title: title + 1 }
let { curRole } = await calculateCe(HERO_SYSTEM_TYPE.TITLE, roleId, serverId, sid, {}, update, {}); let { curRole } = await calculateWithRole(HERO_SYSTEM_TYPE.TITLE, roleId, serverId, sid, update);
// 任务 // 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_TITLE, { oldTitle: title, title: update.title }); await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_TITLE, { oldTitle: title, title: update.title });
@@ -128,7 +128,7 @@ export class RoleHandler {
if (!result) if (!result)
return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH); return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let { curRole } = await calculateCe(HERO_SYSTEM_TYPE.TERAPH, roleId, serverId, sid, {}, { teraphs }, { teraphId: id }); let { curRole } = await calculateWithRole(HERO_SYSTEM_TYPE.TERAPH, roleId, serverId, sid, { teraphs }, { teraphId: id });
// 任务 // 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_TERAPH_STRENGTHEN, { count }); await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_TERAPH_STRENGTHEN, { count });
@@ -171,7 +171,7 @@ export class RoleHandler {
let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.TERAPH_QUALITY_UP); let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.TERAPH_QUALITY_UP);
if (!result) if (!result)
return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH); return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let { curRole } = await calculateCe(HERO_SYSTEM_TYPE.TERAPH_UP, roleId, serverId, sid, {}, { teraphs }, { teraphId: id }); let { curRole } = await calculateWithRole(HERO_SYSTEM_TYPE.TERAPH_UP, roleId, serverId, sid, { teraphs }, { teraphId: id });
// 神像进阶，进阶一次就触发一次礼包弹框 // 神像进阶，进阶一次就触发一次礼包弹框
await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_TERAPH_STAGE_UP); await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_TERAPH_STAGE_UP);
@@ -204,14 +204,14 @@ export class RoleHandler {
return resResult(STATUS.DIC_DATA_NOT_FOUND); return resResult(STATUS.DIC_DATA_NOT_FOUND);
} }
let isOpen = !!dicPosition.get(positionId.toString()); // 该位置是否解锁 let isOpen = !!dicPosition.get(positionId.toString()); // 该位置是否解锁
let curHero: HeroType = null;
if (hid > 0) { if (hid > 0) {
let findHero = await SchoolModel.findByHid(roleId, hid); let findHero = await SchoolModel.findByHid(roleId, hid);
if (!!findHero) { if (!!findHero) {
return resResult(STATUS.ROLE_SCHOOL_HERO_USED); return resResult(STATUS.ROLE_SCHOOL_HERO_USED);
} }
let curHero = await HeroModel.findByHidAndRole(hid, roleId); curHero = await HeroModel.findByHidAndRole(hid, roleId);
if (!curHero) return resResult(STATUS.HERO_NOT_FIND); if (!curHero) return resResult(STATUS.HERO_NOT_FIND);
} }
@@ -228,7 +228,7 @@ export class RoleHandler {
} }
await SchoolModel.updateBySclAndPos(roleId, schoolId, positionId, { hid, isOpen }) await SchoolModel.updateBySclAndPos(roleId, schoolId, positionId, { hid, isOpen })
await calculateCe(HERO_SYSTEM_TYPE.SCHOOL, roleId, serverId, sid, {}, {}, { schoolId, schoolHid: hid, preSchoolHid: preHid }); await calculateWithRole(HERO_SYSTEM_TYPE.SCHOOL, roleId, serverId, sid, {}, { schoolId, hero: curHero, schoolHid: hid, preSchoolHid: preHid });
// 任务 // 任务
await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_SCHOOL_PUT_HERO, { hid, preHid }); await checkTask(serverId, roleId, sid, TASK_TYPE.ROLE_SCHOOL_PUT_HERO, { hid, preHid });
@@ -319,7 +319,7 @@ export class RoleHandler {
update.scrollId = dicHeroScroll ? dicHeroScroll.id : 0; update.scrollId = dicHeroScroll ? dicHeroScroll.id : 0;
let hero = await HeroModel.updateHeroInfo(roleId, hid, update); let hero = await HeroModel.updateHeroInfo(roleId, hid, update);
await calculateCe(HERO_SYSTEM_TYPE.SCROLL, roleId, serverId, sid, update, {}, { hid }); await calculateCeWithHero(HERO_SYSTEM_TYPE.SCROLL, roleId, serverId, sid, hid, update);
// 任务 // 任务
await checkTaskInActiveScroll(serverId, roleId, sid, scrollActive, hero); await checkTaskInActiveScroll(serverId, roleId, sid, scrollActive, hero);
game-server/app/services/playerCeService.ts
+105 -23
View File
@@ -5,7 +5,7 @@
import { pinus } from 'pinus'; import { pinus } from 'pinus';
import { STATUS } from '../consts/statusCode'; import { STATUS } from '../consts/statusCode';
import { resResult, reduceCe, calculatetopLineup } from '../pubUtils/util'; import { resResult, reduceCe } from '../pubUtils/util';
import { HeroModel, HeroType, HeroUpdate } from '../db/Hero'; import { HeroModel, HeroType, HeroUpdate } from '../db/Hero';
import { RoleUpdate, RoleType, RoleModel } from '../db/Role'; import { RoleUpdate, RoleType, RoleModel } from '../db/Role';
@@ -18,8 +18,11 @@ import { RoleCeModel } from '../db/RoleCe';
import { PvpDefenseModel } from '../db/PvpDefense'; import { PvpDefenseModel } from '../db/PvpDefense';
import { saveCeChangeLog } from '../pubUtils/logUtil'; import { saveCeChangeLog } from '../pubUtils/logUtil';
import { JewelType } from '../db/Jewel'; import { JewelType } from '../db/Jewel';
import { SchoolModel } from '../db/School';
import { HasJustId } from 'mongoose';
interface Param { interface Param {
isInitRole?: boolean,
hid?: number, hid?: number,
hero?: HeroType, hero?: HeroType,
isUpStar?: boolean, isUpStar?: boolean,
@@ -37,56 +40,135 @@ interface Param {
skinId?: number, skinId?: number,
} }
export async function calculateCe(type: HERO_SYSTEM_TYPE, roleId: string, serverId: number, sid: string, heroUpdate: HeroUpdate, roleUpdate: RoleUpdate, param: Param) { export async function calculateCeWithHero(type: HERO_SYSTEM_TYPE, roleId: string, serverId: number, sid: string, hid: number, heroUpdate: HeroUpdate, param: Param = {}) {
let heroUpdates = new Map<number, HeroUpdate>();
heroUpdates.set(hid, heroUpdate);
let { heroes, curRole } = await calculateCes(type, roleId, serverId, sid, heroUpdates, {}, {}, param);
let curHero = heroes.find(cur => cur.hid == hid);
return { heroes, curHero, curRole }
}
export async function calculateWithRole(type: HERO_SYSTEM_TYPE, roleId: string, serverId: number, sid: string, roleUpdate: RoleUpdate, param: Param = {}) {
let { heroes, curRole } = await calculateCes(type, roleId, serverId, sid, new Map(), roleUpdate, {}, param);
return { heroes, curRole };
}
export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serverId: number, sid: string, heroUpdates: Map<number, HeroUpdate>, roleUpdate: RoleUpdate, roleIncUpdate: RoleUpdate, param: Param = {}) {
let calCe = new CalCe(); let calCe = new CalCe();
let roleCe = await RoleCeModel.findByRoleId(roleId); let roleCe = await RoleCeModel.findByRoleId(roleId);
calCe.setRoleCe(roleCe); calCe.setRoleCe(roleCe);
switch (type) { switch (type) {
case HERO_SYSTEM_TYPE.LVUP: // 升级 case HERO_SYSTEM_TYPE.INIT:
{ {
calCe.setHeroLv(param.hid, heroUpdate.lv); for(let [hid, { skinId, lv, quality, star, starStage, colorStar, colorStarStage, job, jobStage, }] of heroUpdates) {
calCe.setHeroBase(hid, skinId);
calCe.setHeroLv(hid, lv);
calCe.setHeroStar(hid, job, quality, star, starStage, colorStar, colorStarStage);
calCe.setJob(hid, job, jobStage);
}
if(param.isInitRole) {
let { title, teraphs } = roleUpdate;
calCe.setTitle(title);
calCe.setTeraph(teraphs);
}
break; break;
} }
case HERO_SYSTEM_TYPE.STAR: // 升星 case HERO_SYSTEM_TYPE.LVUP: // 1. 升级
{ {
let { star, starStage, colorStar, colorStarStage } = heroUpdate; for(let [hid, { lv }] of heroUpdates) {
let { hid, hero: { quality, job } } = param; calCe.setHeroLv(hid, lv);
calCe.setHeroStar(hid, job, quality, star, starStage, colorStar, colorStarStage); }
break;
}
case HERO_SYSTEM_TYPE.STAR: // 2. 升星
{
for(let [hid, { star, starStage }] of heroUpdates) {
let { hero: { quality, job, colorStar, colorStarStage }, isUpStar } = param;
await treatHeroStar(calCe, roleId, hid, star, starStage, quality, colorStar, colorStarStage, job, isUpStar);
}
break;
}
case HERO_SYSTEM_TYPE.QUALITY: // 3. 升品
{
for(let [hid, { quality }] of heroUpdates) {
let { hero: { star, starStage, colorStar, colorStarStage, job } } = param;
await treatHeroStar(calCe, roleId, hid, star, starStage, quality, colorStar, colorStarStage, job, true);
}
break;
}
case HERO_SYSTEM_TYPE.COLORSTAR: // 4. 觉醒
{
for(let [hid, { colorStar, colorStarStage }] of heroUpdates) {
let { hero: { star, starStage, quality, job }, isUpStar } = param;
await treatHeroStar(calCe, roleId, hid, star, starStage, quality, colorStar, colorStarStage, job, isUpStar);
}
break;
}
case HERO_SYSTEM_TYPE.SCHOOL: // 放百家学宫
{
let { schoolId, schoolHid, preSchoolHid, hero } = param;
if(preSchoolHid) {
calCe.setSchool(false, preSchoolHid, schoolId, 0, 0, 0);
}
if(schoolHid) {
let { star, colorStar, quality } = hero;
calCe.setSchool(true, schoolHid, schoolId, star, colorStar, quality);
}
break; break;
} }
} }
let { heroCe, roleInc } = calCe.getCeInc(); // 计算战力，获得有变化的武将战力 let { heroCe, roleInc } = calCe.getCeInc(); // 计算战力，获得有变化的武将战力
let changeHids: number[] = [];
let pushHeros = new Array<{ hid: number, ce: number, incHeroCe: number }>(); let pushHeros = new Array<{ hid: number, ce: number, incHeroCe: number }>();
let heroes: HeroType[] = [], curHero: HeroType; let heroes: HeroType[] = [];
for(let [ hid, { ce, inc } ] of heroCe) {
let hero: HeroType; for(let [hid, heroUpdate] of heroUpdates) {
if(hid == param.hid) { // 更新的那一个武将 if(heroCe.has(hid)) {
hero = await HeroModel.updateHeroInfo(roleId, hid, { ...heroUpdate, ce }); let { ce, inc } = heroCe.get(hid);
curHero = hero; let heroUpdate = heroUpdates.get(hid)||{};
} else { // 由于百家学宫等问题牵扯到的其他武将 let hero = await HeroModel.updateHeroInfo(roleId, hid, { ...heroUpdate, ce });
hero = await HeroModel.updateHeroInfo(roleId, hid, { ce });
}
calCe.setResultHero(hero); calCe.setResultHero(hero);
heroes.push(hero); heroes.push(hero);
await PvpDefenseModel.updateCe(roleId, hid, inc); // 更新pvp防守阵战力 await PvpDefenseModel.updateCe(roleId, hid, inc); // 更新pvp防守阵战力
pushHeros.push({ hid, ce, incHeroCe: inc }) pushHeros.push({ hid, ce, incHeroCe: inc });
changeHids.push(hid);
} else {
let hero = await HeroModel.updateHeroInfo(roleId, param.hid, heroUpdate);
heroes.push(hero);
} }
if(!heroCe.has(param.hid)) {
curHero = await HeroModel.updateHeroInfo(roleId, param.hid, heroUpdate);
} }
for(let [hid, { ce, inc }] of heroCe) {
if(changeHids.indexOf(hid) == -1) {
let hero = await HeroModel.updateHeroInfo(roleId, hid, { ce });
pushHeros.push({ hid, ce: hero.ce, incHeroCe: inc });
changeHids.push(hid);
}
}
let { topLineup, topLineupCe } = calCe.getTopLineup(); let { topLineup, topLineupCe } = calCe.getTopLineup();
let role = await RoleModel.incRoleInfo(roleId, { ce: roleInc }, { ...roleUpdate, topLineup, topLineupCe }); let roleCeUpdate = calCe.getRoleCeTable();
roleCe = await RoleCeModel.updateRoleCe(roleId, roleCeUpdate);
let role = await RoleModel.incRoleInfo(roleId, { ...roleIncUpdate, ce: roleInc }, { ...roleUpdate, topLineup, topLineupCe });
let guild = await GuildModel.updateCe(roleId, roleInc); // 公会更新战力 let guild = await GuildModel.updateCe(roleId, roleInc); // 公会更新战力
saveCeChangeLog(role, roleInc, role.ce, type, [...heroCe.keys()]); saveCeChangeLog(role, roleInc, role.ce, type, changeHids);
updateRank(roleId, serverId, topLineupCe, role, pushHeros, guild); updateRank(roleId, serverId, topLineupCe, role, pushHeros, guild);
let uids = [{ uid: roleId, sid }]; let uids = [{ uid: roleId, sid }];
pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: role.ce, heros: pushHeros, topLineupCe }), uids); pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: role.ce, heros: pushHeros, topLineupCe }), uids);
if(guild) { if(guild) {
await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]); await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]);
} }
return { heroes, curHero, curRole: role } return { heroes, curRole: role }
}
async function treatHeroStar(calCe: CalCe, roleId: string, hid: number, star: number, starStage: number, quality: number, colorStar: number, colorStarStage: number, job: number, isUpStar: boolean) {
calCe.setHeroStar(hid, job, quality, star, starStage, colorStar, colorStarStage);
if(isUpStar) {
let school = await SchoolModel.findByHid(roleId, hid);
if(school) calCe.setSchool(true, hid, school.schoolId, star, colorStar, quality);
}
} }
// 更新排行榜数据 // 更新排行榜数据
game-server/app/services/role/calCe.ts
+95 -50
View File
@@ -1,10 +1,10 @@
import { ABI_STAGE, ABI_STAGE_TO_TYPE, ABI_TYPE_MAIN, LINEUP_NUM, SEID_TYPE } from "../../consts"; import { ABI_STAGE, ABI_STAGE_TO_TYPE, ABI_TYPE_MAIN, LINEUP_NUM, SEID_TYPE } from "../../consts";
import { HeroType, HeroUpdate } from "../../db/Hero"; import { HeroType, HeroUpdate } from "../../db/Hero";
import { RoleUpdate, Teraph } from "../../db/Role"; import { RoleUpdate, Teraph } from "../../db/Role";
import { AttrCell, EquipAttr, HeroAttr, RoleCeType } from "../../db/RoleCe"; import { AttrCell, EquipAttr, HeroAttr, RoleCeType, SchoolAttr } from "../../db/RoleCe";
import { TopHero } from "../../domain/dbGeneral"; import { TopHero } from "../../domain/dbGeneral";
import { AttributeCal } from "../../domain/roleField/attribute"; import { AttributeCal } from "../../domain/roleField/attribute";
import { gameData, getHeroStarByQuality, getHeroWakeByQuality, getTeraph } from "../../pubUtils/data"; import { gameData, getHeroStarByQuality, getHeroWakeByQuality, getSchoolRateByStar, getTeraph } from "../../pubUtils/data";
import { DicRandomEffectPool } from "../../pubUtils/dictionary/DicRandomEffectPool"; import { DicRandomEffectPool } from "../../pubUtils/dictionary/DicRandomEffectPool";
import { DicSe } from "../../pubUtils/dictionary/DicSe"; import { DicSe } from "../../pubUtils/dictionary/DicSe";
import { addToMap, deepCopy } from "../../pubUtils/util"; import { addToMap, deepCopy } from "../../pubUtils/util";
@@ -23,6 +23,8 @@ export class CalCe {
equipLv: Map<string, number> = new Map(); // hid+eplaceId => lv equipLv: Map<string, number> = new Map(); // hid+eplaceId => lv
originCes: Map<number, number> = new Map(); // hid => ce originCes: Map<number, number> = new Map(); // hid => ce
resultCes: Map<number, number> = new Map(); // hid => ce resultCes: Map<number, number> = new Map(); // hid => ce
schoolAttrs: Map<string, { hid: number, attrId: number, ce: number }> = new Map(); // hid + attr => ratio
schoolAttrsByAttrId: Map<number, string[]> = new Map(); // attrId => hid + attr
private getGlobalAttrById(attrId: number) { private getGlobalAttrById(attrId: number) {
if(!this.globalAttrs.has(attrId)) { if(!this.globalAttrs.has(attrId)) {
@@ -39,6 +41,7 @@ export class CalCe {
private getHeroAttrByHidAndId(hid: number, attrId: number) { private getHeroAttrByHidAndId(hid: number, attrId: number) {
let key = `${hid}_${attrId}`; let key = `${hid}_${attrId}`;
console.log('$$$$$$$$ getHeroAttrByHidAndId', hid, attrId)
if(!this.heroAttrs.has(key)) { if(!this.heroAttrs.has(key)) {
if(ABI_TYPE_MAIN.indexOf(attrId) != -1) { if(ABI_TYPE_MAIN.indexOf(attrId) != -1) {
let obj = new HeroMainAttr(hid, attrId); let obj = new HeroMainAttr(hid, attrId);
@@ -53,6 +56,7 @@ export class CalCe {
} }
this.heroAttrsByHid.get(hid).push(key); this.heroAttrsByHid.get(hid).push(key);
} }
console.log('$$$$$$$$ heroAttrsByHid', this.heroAttrsByHid)
return this.heroAttrs.get(key); return this.heroAttrs.get(key);
} }
@@ -80,6 +84,30 @@ export class CalCe {
return this.equipAttrs.get(key); return this.equipAttrs.get(key);
} }
private setSchoolRate(hid: number, attrId: number, value: number) {
let key = `${hid}_${attrId}`;
if(!this.schoolAttrs.has(key)) {
this.schoolAttrs.set(key, { hid, attrId, ce: value });
if(!this.schoolAttrsByAttrId.has(attrId)) {
this.schoolAttrsByAttrId.set(attrId, []);
}
this.schoolAttrsByAttrId.get(attrId).push(key);
} else {
this.schoolAttrs.get(key).ce = value;
}
}
private calSchoolAttrsToGlobal(attrId: number) {
let keys = this.schoolAttrsByAttrId.get(attrId)||[];
let schoolResult = 0;
for(let key of keys) {
let { ce } = this.schoolAttrs.get(key);
schoolResult += ce;
}
let globalAttr = this.getGlobalAttrById(attrId);
globalAttr.school = schoolResult;
}
public calHeroCe() { public calHeroCe() {
let ces = new Map<number, { id: number, val: number }[]>(); // hid => [{attrId, val}] let ces = new Map<number, { id: number, val: number }[]>(); // hid => [{attrId, val}]
for(let [hid, keys] of this.heroAttrsByHid) { for(let [hid, keys] of this.heroAttrsByHid) {
@@ -98,17 +126,20 @@ export class CalCe {
ces.get(hid).push({ id: attrId, val }); ces.get(hid).push({ id: attrId, val });
} }
} }
let result = new Map<number, number>();
for(let [hid, arr] of ces) { for(let [hid, arr] of ces) {
let obj = new AttributeCal(); let obj = new AttributeCal();
obj.setByWarJson(arr); obj.setByWarJson(arr);
let ce = obj.calCe(); let ce = obj.calCe();
this.resultCes.set(hid, ce); this.resultCes.set(hid, ce);
result.set(hid, ce);
} }
return this.resultCes; return result;
} }
public getCeInc() { public getCeInc() {
let ceResult = this.calHeroCe(); let ceResult = this.calHeroCe();
console.log('##### ceResult', ceResult, 'originCes', this.originCes)
let heroCe = new Map<number, { inc: number, origin: number, ce: number }>(); let heroCe = new Map<number, { inc: number, origin: number, ce: number }>();
let roleInc = 0; let roleInc = 0;
for(let [hid, ce] of ceResult) { for(let [hid, ce] of ceResult) {
@@ -137,7 +168,7 @@ export class CalCe {
let heroAttrs: HeroAttr[] = []; let heroAttrs: HeroAttr[] = [];
for(let [hid, keys] of this.heroAttrsByHid) { for(let [hid, keys] of this.heroAttrsByHid) {
let lv = this.heroLv.get(hid); let lv = this.heroLv.get(hid);
let historyCe = this.heroHistoryCe.get(hid); let historyCe = this.heroHistoryCe.get(hid)||0;
let objectId = this.heroObjectId.get(hid); let objectId = this.heroObjectId.get(hid);
let attrs: AttrCell[] = []; let attrs: AttrCell[] = [];
for(let key of keys) { for(let key of keys) {
@@ -160,12 +191,18 @@ export class CalCe {
hid, eplaceId, lv, attrs hid, eplaceId, lv, attrs
}); });
} }
let schoolAttrs: SchoolAttr[] = [];
for(let [_, { hid, attrId, ce }] of this.schoolAttrs) {
schoolAttrs.push({ hid, attrId, value: ce });
}
return { return {
roleId: this.roleId, globalAttrs, heroAttrs, equipAttrs roleId: this.roleId, globalAttrs, heroAttrs, equipAttrs, schoolAttrs
} }
} }
public setRoleCe(roleCe: RoleCeType) { public setRoleCe(roleCe: RoleCeType) {
console.log('&&&&&&&& setRoleCe', roleCe)
this.roleId = roleCe.roleId; this.roleId = roleCe.roleId;
if(roleCe) { if(roleCe) {
for(let globalAttr of roleCe.globalAttrs) { for(let globalAttr of roleCe.globalAttrs) {
@@ -188,23 +225,14 @@ export class CalCe {
obj.setByRoleCe(cell); obj.setByRoleCe(cell);
} }
} }
for(let { hid, attrId, value } of roleCe.schoolAttrs) {
this.setSchoolRate(hid, attrId, value);
}
} }
this.originCes = this.calHeroCe(); this.originCes = this.calHeroCe();
console.log('############ setRoleCe', this.originCes)
} }
public setInitHero(role: RoleUpdate, heroes: HeroUpdate[]) {
this.roleId = role.roleId;
for(let { hid, skinId, lv, quality, star, starStage, colorStar, colorStarStage, job, jobStage, } of heroes) {
this.setHeroBase(hid, skinId);
this.setHeroLv(hid, lv);
this.setHeroStar(hid, job, quality, star, starStage, colorStar, colorStarStage);
this.setJob(hid, job, jobStage);
}
this.setTitle(role.title);
this.setTeraph(role.teraphs);
}
public setResultHero(hero: HeroType) { public setResultHero(hero: HeroType) {
this.heroObjectId.set(hero.hid, hero._id); this.heroObjectId.set(hero.hid, hero._id);
} }
@@ -267,7 +295,6 @@ export class CalCe {
let heroAttr = this.getHeroAttrByHidAndId(hid, attrId); let heroAttr = this.getHeroAttrByHidAndId(hid, attrId);
heroAttr.starUp = value; heroAttr.starUp = value;
}; };
} }
// 职业基础 // 职业基础
@@ -313,6 +340,23 @@ export class CalCe {
} }
} }
// 百家学宫
public setSchool(isPutOn: boolean, hid: number, schoolId: number, star: number, colorStar: number, quality: number) {
let dicSchool = gameData.school.get(schoolId);
let dicSchoolRate = getSchoolRateByStar(star, colorStar, quality);
console.log('#### setSchool', star, colorStar, quality, dicSchoolRate)
for (let attrId of dicSchool.upAttribute) {
if(ABI_TYPE_MAIN.includes(attrId)) { // 主属性
this.setSchoolRate(hid, attrId, isPutOn?dicSchoolRate.mainAttrAPerent: 0);
} else {
this.setSchoolRate(hid, attrId, isPutOn?dicSchoolRate.assiAttrAddValue: 0);
}
this.calSchoolAttrsToGlobal(attrId);
}
}
// 添加技能增加的被动属性 // 添加技能增加的被动属性
private addSeidEffect(seidList: number[]) { private addSeidEffect(seidList: number[]) {
let fixUp = new Map<number, number>(), ratioUp = new Map<number, number>(); let fixUp = new Map<number, number>(), ratioUp = new Map<number, number>();
@@ -383,9 +427,10 @@ abstract class GlobalAllAttr {
abstract getValues(): number[]; abstract getValues(): number[];
public getGlobalAttr() { public getGlobalAttr() {
let values = this.getValues().map(cur => (cur||0));
return { return {
attrId: this.attrId, attrId: this.attrId,
values: this.getValues() values
} }
} }
} }
@@ -417,19 +462,19 @@ class GlobalMainAttr extends GlobalAllAttr {
for(let i = GLOBAL_MAIN_ATTR_INDEX.START; i < GLOBAL_MAIN_ATTR_INDEX.END; i++) { for(let i = GLOBAL_MAIN_ATTR_INDEX.START; i < GLOBAL_MAIN_ATTR_INDEX.END; i++) {
switch(i) { switch(i) {
case GLOBAL_MAIN_ATTR_INDEX.SCHOOL: case GLOBAL_MAIN_ATTR_INDEX.SCHOOL:
if(this.school) values[i] = this.school; values.push(this.school);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.TERAPH: case GLOBAL_MAIN_ATTR_INDEX.TERAPH:
if(this.teraph) values[i] = this.teraph; values.push(this.teraph);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.TITLE: case GLOBAL_MAIN_ATTR_INDEX.TITLE:
if(this.title) values[i] = this.title; values.push(this.title);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.SCROLL: case GLOBAL_MAIN_ATTR_INDEX.SCROLL:
if(this.scroll) values[i] = this.scroll; values.push(this.scroll);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.SKIN: case GLOBAL_MAIN_ATTR_INDEX.SKIN:
if(this.skin) values[i] = this.skin; values.push(this.skin);
break; break;
} }
} }
@@ -462,16 +507,16 @@ class GlobalSubAttr extends GlobalAllAttr {
for(let i = GLOBAL_MAIN_ATTR_INDEX.START; i < GLOBAL_MAIN_ATTR_INDEX.END; i++) { for(let i = GLOBAL_MAIN_ATTR_INDEX.START; i < GLOBAL_MAIN_ATTR_INDEX.END; i++) {
switch(i) { switch(i) {
case GLOBAL_MAIN_ATTR_INDEX.SCHOOL: case GLOBAL_MAIN_ATTR_INDEX.SCHOOL:
if(this.school) values[i] = this.school; values.push(this.school);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.TERAPH: case GLOBAL_MAIN_ATTR_INDEX.TERAPH:
if(this.teraph) values[i] = this.teraph; values.push(this.teraph);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.TITLE: case GLOBAL_MAIN_ATTR_INDEX.TITLE:
if(this.title) values[i] = this.title; values.push(this.title);
break; break;
case GLOBAL_MAIN_ATTR_INDEX.SKIN: case GLOBAL_MAIN_ATTR_INDEX.SKIN:
if(this.skin) values[i] = this.skin; values.push(this.skin);
break; break;
} }
} }
@@ -543,31 +588,31 @@ class HeroMainAttr extends HeroAllAttr {
for(let i = HERO_MAIN_ATTR_INDEX.START; i < HERO_MAIN_ATTR_INDEX.END; i++) { for(let i = HERO_MAIN_ATTR_INDEX.START; i < HERO_MAIN_ATTR_INDEX.END; i++) {
switch(i) { switch(i) {
case HERO_MAIN_ATTR_INDEX.BASE: case HERO_MAIN_ATTR_INDEX.BASE:
if(this.base) values[i] = this.base; values.push(this.base);
break; break;
case HERO_MAIN_ATTR_INDEX.JOB: case HERO_MAIN_ATTR_INDEX.JOB:
if(this.job) values[i] = this.job; values.push(this.job);
break; break;
case HERO_MAIN_ATTR_INDEX.STAR_UP: case HERO_MAIN_ATTR_INDEX.STAR_UP:
if(this.starUp) values[i] = this.starUp; values.push(this.starUp);
break; break;
case HERO_MAIN_ATTR_INDEX.CONNECT: case HERO_MAIN_ATTR_INDEX.CONNECT:
if(this.connect) values[i] = this.connect; values.push(this.connect);
break; break;
case HERO_MAIN_ATTR_INDEX.FAVOUR: case HERO_MAIN_ATTR_INDEX.FAVOUR:
if(this.favour) values[i] = this.favour; values.push(this.favour);
break; break;
case HERO_MAIN_ATTR_INDEX.TALENT: case HERO_MAIN_ATTR_INDEX.TALENT:
if(this.talent) values[i] = this.talent; values.push(this.talent);
break; break;
case HERO_MAIN_ATTR_INDEX.EQUIP: case HERO_MAIN_ATTR_INDEX.EQUIP:
if(this.equip) values[i] = this.equip; values.push(this.equip);
break; break;
case HERO_MAIN_ATTR_INDEX.EQUIP_UP: case HERO_MAIN_ATTR_INDEX.EQUIP_UP:
if(this.equipUp) values[i] = this.equipUp; values.push(this.equipUp);
break; break;
case HERO_MAIN_ATTR_INDEX.EQUIP_STONE: case HERO_MAIN_ATTR_INDEX.EQUIP_STONE:
if(this.equipStone) values[i] = this.equipStone; values.push(this.equipStone);
break; break;
} }
} }
@@ -599,16 +644,16 @@ class HeroSubAttr extends HeroAllAttr {
for(let i = HERO_SUB_ATTR_INDEX.START; i < HERO_SUB_ATTR_INDEX.END; i++) { for(let i = HERO_SUB_ATTR_INDEX.START; i < HERO_SUB_ATTR_INDEX.END; i++) {
switch(i) { switch(i) {
case HERO_SUB_ATTR_INDEX.BASE: case HERO_SUB_ATTR_INDEX.BASE:
if(this.base) values[i] = this.base; values.push(this.base);
break; break;
case HERO_SUB_ATTR_INDEX.JOB: case HERO_SUB_ATTR_INDEX.JOB:
if(this.job) values[i] = this.job; values.push(this.job);
break; break;
case HERO_SUB_ATTR_INDEX.TALENT: case HERO_SUB_ATTR_INDEX.TALENT:
if(this.talent) values[i] = this.talent; values.push(this.talent);
break; break;
case HERO_SUB_ATTR_INDEX.EQUIP: case HERO_SUB_ATTR_INDEX.EQUIP:
if(this.equip) values[i] = this.equip; values.push(this.equip);
break; break;
} }
} }
@@ -672,22 +717,22 @@ class EquipMainAttr extends EquipAllAttr {
for(let i = EQUIP_MAIN_ATTR_INDEX.START; i < EQUIP_MAIN_ATTR_INDEX.END; i++) { for(let i = EQUIP_MAIN_ATTR_INDEX.START; i < EQUIP_MAIN_ATTR_INDEX.END; i++) {
switch(i) { switch(i) {
case EQUIP_MAIN_ATTR_INDEX.EQUIP_QUALITY: case EQUIP_MAIN_ATTR_INDEX.EQUIP_QUALITY:
if(this.equipQuality) values[i] = this.equipQuality; values.push(this.equipQuality);
break; break;
case EQUIP_MAIN_ATTR_INDEX.EQUIP_STRENGTH: case EQUIP_MAIN_ATTR_INDEX.EQUIP_STRENGTH:
if(this.equipStrengthen) values[i] = this.equipStrengthen; values.push(this.equipStrengthen);
break; break;
case EQUIP_MAIN_ATTR_INDEX.EQUIP_STAR: case EQUIP_MAIN_ATTR_INDEX.EQUIP_STAR:
if(this.equipStar) values[i] = this.equipStar; values.push(this.equipStar);
break; break;
case EQUIP_MAIN_ATTR_INDEX.EQUIP_SUIT: case EQUIP_MAIN_ATTR_INDEX.EQUIP_SUIT:
if(this.equipSuit) values[i] = this.equipSuit; values.push(this.equipSuit);
break; break;
case EQUIP_MAIN_ATTR_INDEX.JEWEL: case EQUIP_MAIN_ATTR_INDEX.JEWEL:
if(this.jewel) values[i] = this.jewel; values.push(this.jewel);
break; break;
case EQUIP_MAIN_ATTR_INDEX.STONE: case EQUIP_MAIN_ATTR_INDEX.STONE:
if(this.stone) values[i] = this.stone; values.push(this.stone);
break; break;
} }
} }
@@ -715,10 +760,10 @@ class EquipSubAttr extends EquipAllAttr {
for(let i = EQUIP_SUB_ATTR_INDEX.START; i < EQUIP_SUB_ATTR_INDEX.END; i++) { for(let i = EQUIP_SUB_ATTR_INDEX.START; i < EQUIP_SUB_ATTR_INDEX.END; i++) {
switch(i) { switch(i) {
case EQUIP_SUB_ATTR_INDEX.EQUIP_STAR: case EQUIP_SUB_ATTR_INDEX.EQUIP_STAR:
if(this.equipStar) values[i] = this.equipStar; values.push(this.equipStar);
break; break;
case EQUIP_SUB_ATTR_INDEX.JEWEL: case EQUIP_SUB_ATTR_INDEX.JEWEL:
if(this.jewel) values[i] = this.jewel; values.push(this.jewel);
break; break;
} }
} }
game-server/app/services/role/createHero.ts
+50 -183
View File
@@ -1,188 +1,19 @@
import { FIGURE_UNLOCK_CONDITION, ITEM_CHANGE_REASON, REDIS_KEY, STATUS, TASK_TYPE, HERO_SYSTEM_TYPE, LINEUP_NUM } from "../../consts"; import { FIGURE_UNLOCK_CONDITION, ITEM_CHANGE_REASON, REDIS_KEY, STATUS, TASK_TYPE, HERO_SYSTEM_TYPE, LINEUP_NUM, COUNTER } from "../../consts";
import { SkinModel } from "../../db/Skin"; import { SkinModel } from "../../db/Skin";
import { HeroModel, HeroSkin, HeroType, HeroUpdate } from "../../db/Hero"; import { HeroModel, HeroSkin, HeroType, HeroUpdate } from "../../db/Hero";
import { RoleModel, RoleType, RoleUpdate } from "../../db/Role";
import { SkinUpdate } from "../../db/Skin"; import { SkinUpdate } from "../../db/Skin";
import { Figure, TopHero } from "../../domain/dbGeneral";
import { TaskListReturn } from "../../domain/roleField/task";
import { GuildModel, GuildType } from "../../db/Guild";
import { PvpDefenseModel } from "../../db/PvpDefense";
import { pick } from "underscore";
import { calculatetopLineup } from "../../pubUtils/util";
import { nowSeconds } from "../../pubUtils/timeUtil"; import { nowSeconds } from "../../pubUtils/timeUtil";
import { saveCeChangeLog } from "../../pubUtils/logUtil";
import { getRandSingleEelm, reduceCe, resResult } from "../../pubUtils/util"; import { getRandSingleEelm, reduceCe, resResult } from "../../pubUtils/util";
import { AttributeCal } from "../../domain/roleField/attribute";
import { CreateHeroParam, HeroParam, HeroShowParam } from "../../domain/roleField/hero"; import { CreateHeroParam, HeroParam, HeroShowParam } from "../../domain/roleField/hero";
import { pinus } from "pinus"; import { pinus } from "pinus";
import { Rank } from "../rankService"; import { Rank } from "../rankService";
import { checkTaskInCreateHero } from "../task/taskService"; import { checkTaskInCreateHero } from "../task/taskService";
import { ItemInter, RewardInter } from "../../pubUtils/interface"; import { ItemInter, RewardInter } from "../../pubUtils/interface";
import { transPiece } from "./util"; import { transPiece } from "./util";
import { getInitHeroById } from "../roleService"; import { addItems, combineFigureInfo, unlockFigure, } from "./rewardService";
import { addItems, combineFigureInfo, unlockFigure, unlockFigureWithoutSave } from "./rewardService"; import { CounterModel } from "../../db/Counter";
import { gameData } from "../../pubUtils/data"; import { calculateCes } from "../playerCeService";
import { CalCe } from "./calCe"; import { RoleUpdate } from "../../db/Role";
import RoleCe, { RoleCeModel, RoleCeUpdate } from "../../db/RoleCe";
export class CreateHeroes {
private roleId: string;
private roleName: string;
private serverId: number;
private incHeroNum: number = 0;
private incRoleCe: number = 0;
private role: RoleType;
private guild: GuildType;
// 推送信息
private figureConditions: { type: FIGURE_UNLOCK_CONDITION, paramHid: number }[] = [];
private skins: SkinUpdate[] = [];
private heroes: HeroUpdate[] = [];
private roleCe: RoleCeUpdate = {};
private resultHeroes: HeroType[] = [];
private topLineup: TopHero[] = [];
private topLineupCe: number = 0;
constructor(roleId: string, roleName: string, serverId: number) {
this.roleId = roleId;
this.roleName = roleName;
this.serverId = serverId;
}
public setRole(role: RoleType) {
this.role = role;
}
public async getRole() {
if(!this.role) {
this.role = await RoleModel.findByRoleId(this.roleId);
this.topLineup = this.role.topLineup;
this.topLineupCe = this.role.topLineupCe;
}
return this.role;
}
public async createHeroes(hids: number[]) {
let { roleId, roleName } = this;
for(let hid of hids) {
let initSkin = SkinModel.getInitInfo(hid);
let initHero = HeroModel.getInitInfo(hid, { roleId, roleName, skins: [new HeroSkin(initSkin)] });
this.heroes.push(initHero);
this.skins.push(initSkin);
this.figureConditions.push({ type: FIGURE_UNLOCK_CONDITION.GET_HERO, paramHid: hid });
this.incHeroNum ++;
}
await this.calCe(); // 计算战力
await this.saveCeToDb();
}
private async calCe() {
let role = await this.getRole();
let calCe = new CalCe();
calCe.setInitHero(role, this.heroes); // 设置武将初始信息
let ces = calCe.calHeroCe(); // 战力
for(let hero of this.heroes) {
hero.ce = ces.get(hero.hid)||0;
this.incRoleCe += hero.ce;
}
this.roleCe = calCe.getRoleCeTable();
}
// 更新战力相关的各个表
private async saveCeToDb() {
let role = await this.getRole();
// 更新武将表
for(let hero of this.heroes) {
let resultHero = await HeroModel.createHero(hero);
this.resultHeroes.push(resultHero);
await calculatetopLineup(role, resultHero.hid, resultHero.ce, resultHero._id);
}
this.heroes = [];
// 更新role表
role = await RoleModel.incRoleInfo(this.roleId, { heroNum: this.incHeroNum, ce: this.incRoleCe }, { heroNumUpdatedAt: nowSeconds(), });
this.setRole(role);
// 更新roleCe表
await RoleCeModel.updateRoleCe(this.roleId, this.roleCe);
// 更新皮肤表
await SkinModel.insertSkins(this.roleId, this.roleName, this.skins)
// 更新guild表
if(role.hasGuild) {
this.guild = await GuildModel.updateCe(this.roleId, this.incRoleCe, true); // 公会更新战力
}
for(let { hid, ce } of this.resultHeroes) {
await PvpDefenseModel.updateCe(this.roleId, hid, ce); // 更新pvp防守阵战力
}
saveCeChangeLog(role, this.incRoleCe, role.ce, HERO_SYSTEM_TYPE.INIT, this.resultHeroes.map(cur => cur.hid));
}
public async updateRedisRank() {
let { serverId, roleId, resultHeroes, role } = this;
// 更新军团信息
if(this.guild) {
let r = new Rank(REDIS_KEY.GUILD_INFO, { guildCode: this.guild.code });
await r.generParamAndSet(REDIS_KEY.GUILD_INFO, { guildCode: this.guild.code }, { guild: this.guild });
}
// 武将数量
if(this.incHeroNum > 0) {
let r = new Rank(REDIS_KEY.HERO_NUM_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, role.heroNum, role.heroNumUpdatedAt, role);
}
// 最强阵容
let r = new Rank(REDIS_KEY.TOP_LINEUP_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, reduceCe(role.topLineupCe), 0, role);
// 最强武将
for(let hero of resultHeroes) {
let r2 = new Rank(REDIS_KEY.TOP_HERO_RANK, { serverId });
await r2.setRankWithHeroInfo(roleId, hero.hid, hero.ce, 0, hero);
let r4 = new Rank(REDIS_KEY.HERO_RANK, { serverId, hid: hero.hid });
await r4.setRankWithHeroInfo(roleId, hero.hid, hero.ce, 0, hero);
}
// 总战力
let r3 = new Rank(REDIS_KEY.SUM_CE_RANK, { serverId });
await r3.setRankWithRoleInfo(roleId, reduceCe(role.ce), 0, role);
// 更新最强五人阵容信息
let r5 = new Rank(REDIS_KEY.TOP_LINEUP_INFO, { serverId });
await r5.generParamAndSet(REDIS_KEY.TOP_LINEUP_INFO, { roleId }, { role });
}
public async pushMessage(sid: string) {
let role = await this.getRole();
let uids = [{ uid: this.roleId, sid }];
pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: role.ce, heros: this.resultHeroes.map(({ hid, ce }) => ({ hid, ce, incHeroCe: ce})), topLineupCe: role.topLineupCe}), uids);
pinus.app.get('channelService').pushMessageByUids('onHeroSkinChange', resResult(STATUS.SUCCESS, this.getSkinPushMsg()), uids);
pinus.app.get('channelService').pushMessageByUids('onHeroUpdate', resResult(STATUS.SUCCESS, { heroes: this.getResultHeroes() }), uids);
checkTaskInCreateHero(this.serverId, this.roleId, sid, this.incHeroNum, this.resultHeroes);
await unlockFigure(sid, this.roleId, this.figureConditions);
}
private getSkinPushMsg() {
let skinPushMessages: {heros: {skins: HeroSkin[], hid: number}[], skins: {id: number, hid: number, inc: number, reason: number }[]} = { heros: [], skins:[] }; // 皮肤推送信息
for(let { hid, skins } of this.resultHeroes) {
skinPushMessages.heros.push({ hid, skins });
}
for(let { id, hid } of this.skins) {
skinPushMessages.skins.push({ id, hid, inc: 1, reason: ITEM_CHANGE_REASON.GET_HERO_UNLOCK_SKIN })
}
return skinPushMessages;
}
public getResultHeroes() {
return this.resultHeroes;
}
public getShowHeroes() {
return this.resultHeroes.map(cur => {
let hero = new HeroShowParam(cur);
return { ...hero, ce: reduceCe(cur.ce)}
});
}
}
/** /**
* 创建多个武将 * 创建多个武将
@@ -191,7 +22,7 @@ export class CreateHeroes {
* @param serverId * @param serverId
* @param heroInfo * @param heroInfo
*/ */
export async function createHeroes(roleId: string, roleName: string, sid: string, serverId: number, heroInfo: CreateHeroParam[]) { export async function createHeroes(roleId: string, roleName: string, sid: string, serverId: number, heroInfo: CreateHeroParam[], initRoleInfos?: RoleUpdate) {
let hids = heroInfo.map(cur => cur.hid); let hids = heroInfo.map(cur => cur.hid);
let userHeroesMap = await HeroModel.findMapByHidRange(hids, roleId); let userHeroesMap = await HeroModel.findMapByHidRange(hids, roleId);
@@ -211,24 +42,60 @@ export class CreateHeroes {
} }
} }
let resultHeroes: HeroType[] = [], resultItems: RewardInter[] = [], heroes: HeroShowParam[] = []; let resultHeroes: HeroType[] = [], resultItems: RewardInter[] = [], showHeroes: HeroShowParam[] = [];
let figureConditions: { type: FIGURE_UNLOCK_CONDITION, paramHid: number }[] = [];
let incHeroNum = 0;
let skins: SkinUpdate[] = [];
if (createHids.length > 0) { if (createHids.length > 0) {
let createHero = new CreateHeroes(roleId, roleName, serverId); let heroInfos = new Map<number, HeroUpdate>();
await createHero.createHeroes(createHids); for(let hid of createHids) {
await createHero.pushMessage(sid); let initSkin = SkinModel.getInitInfo(hid);
await createHero.updateRedisRank(); skins.push(initSkin); // 初始皮肤
heroes = createHero.getShowHeroes(); let seqId = await CounterModel.getNewCounter(COUNTER.HID) || -1;
resultHeroes = createHero.getResultHeroes(); let initHero = HeroModel.getInitInfo(hid, { seqId, roleId, roleName, skins: [new HeroSkin(initSkin)] });
heroInfos.set(hid, initHero);
figureConditions.push({ type: FIGURE_UNLOCK_CONDITION.GET_HERO, paramHid: hid });
incHeroNum ++;
}
await unlockFigure(sid, roleId, figureConditions);
let roleUpdata: RoleUpdate = { heroNumUpdatedAt: nowSeconds() };
if(initRoleInfos) {
roleUpdata = { ...initRoleInfos, ...roleUpdata }
}
let { heroes } = await calculateCes(HERO_SYSTEM_TYPE.INIT, roleId, serverId, sid, heroInfos, roleUpdata, { heroNum: incHeroNum });
for(let hero of heroes) {
showHeroes.push(new HeroShowParam(hero));
resultHeroes.push(hero);
}
let uids = [{ uid: roleId, sid }];
await SkinModel.insertSkins(roleId, roleName, skins);
pinus.app.get('channelService').pushMessageByUids('onHeroSkinChange', resResult(STATUS.SUCCESS, getSkinPushMsg(resultHeroes, skins)), uids);
pinus.app.get('channelService').pushMessageByUids('onHeroUpdate', resResult(STATUS.SUCCESS, { heroes }), uids);
} }
if (pieces.length > 0) { if (pieces.length > 0) {
let goods = await addItems(roleId, roleName, sid, pieces, ITEM_CHANGE_REASON.HERO_TRANSFER_PIECE); let goods = await addItems(roleId, roleName, sid, pieces, ITEM_CHANGE_REASON.HERO_TRANSFER_PIECE);
resultItems = goods; resultItems = goods;
} }
return { heroes, resultHeroes, goods: resultItems } return { heroes: showHeroes, resultHeroes, goods: resultItems }
} }
export async function createHero(roleId: string, roleName: string, sid: string, serverId: number, heroInfo: CreateHeroParam) { export async function createHero(roleId: string, roleName: string, sid: string, serverId: number, heroInfo: CreateHeroParam) {
let result = await createHeroes(roleId, roleName, sid, serverId, [heroInfo]); let result = await createHeroes(roleId, roleName, sid, serverId, [heroInfo]);
return result; return result;
} }
function getSkinPushMsg(resultHeroes: HeroType[], skins: SkinUpdate[]) {
let skinPushMessages: {heros: {skins: HeroSkin[], hid: number}[], skins: {id: number, hid: number, inc: number, reason: number }[]} = { heros: [], skins:[] }; // 皮肤推送信息
for(let { hid, skins } of resultHeroes) {
skinPushMessages.heros.push({ hid, skins });
}
for(let { id, hid } of skins) {
skinPushMessages.skins.push({ id, hid, inc: 1, reason: ITEM_CHANGE_REASON.GET_HERO_UNLOCK_SKIN })
}
return skinPushMessages;
}
game-server/app/services/role/rewardService.ts
+4 -6
View File
@@ -22,11 +22,9 @@ import { reportTAEvent, reportTAUserSet } from '../sdkService';
import { saveCoinChangeLog, saveFigureInfoLog, saveGoldChangeLog, saveItemChangeLog } from '../../pubUtils/logUtil'; import { saveCoinChangeLog, saveFigureInfoLog, saveGoldChangeLog, saveItemChangeLog } from '../../pubUtils/logUtil';
import { JewelModel, JewelType, jewelUpdate, RandSe } from '../../db/Jewel'; import { JewelModel, JewelType, jewelUpdate, RandSe } from '../../db/Jewel';
import { updateEplaces } from '../equipService'; import { updateEplaces } from '../equipService';
import { checkPopUpConditionInCreateHero } from '../activity/popUpShopService';
import { CreateHeroes } from './createHero';
import { combineItems, getCoinEventProperties, getGoldEventProperties, sortItems } from './util'; import { combineItems, getCoinEventProperties, getGoldEventProperties, sortItems } from './util';
import { nowSeconds } from '../../pubUtils/timeUtil'; import { nowSeconds } from '../../pubUtils/timeUtil';
import { calculateCe } from '../playerCeService'; import { calculateCeWithHero } from '../playerCeService';
@@ -71,7 +69,7 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
heroMap.get(jewel.hid).jewels.push(jewel); heroMap.get(jewel.hid).jewels.push(jewel);
} }
} }
for(let [_hid, {hero, jewels} ] of heroMap) { for(let [hid, {hero, jewels} ] of heroMap) {
// 脱下天晶石 // 脱下天晶石
let update = new Map<number, Partial<EPlace>>(); let update = new Map<number, Partial<EPlace>>();
for(let jewel of jewels) { for(let jewel of jewels) {
@@ -82,7 +80,7 @@ export async function handleCost(roleId: string, sid: string, goods: Array<ItemI
} }
} }
let { newEplace } = updateEplaces(hero.ePlace, update); let { newEplace } = updateEplaces(hero.ePlace, update);
await calculateCe(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, role.serverId, sid, { ePlace: newEplace }, {}, { ePlaceIds: [...update.keys()] }); await calculateCeWithHero(HERO_SYSTEM_TYPE.EQUIP_STRENGTH, roleId, role.serverId, sid, hid, { ePlace: newEplace }, { ePlaceIds: [...update.keys()] });
} }
@@ -360,7 +358,7 @@ export async function addSkin(roleId: string, roleName: string, sid: string, ski
if(skin.hid && !hero) hero = await HeroModel.findByHidAndRole(skin.hid, roleId); if(skin.hid && !hero) hero = await HeroModel.findByHidAndRole(skin.hid, roleId);
let condition = { type: FIGURE_UNLOCK_CONDITION.GET_SKIN, paramSkinId: skinId }; let condition = { type: FIGURE_UNLOCK_CONDITION.GET_SKIN, paramSkinId: skinId };
await unlockFigure(sid, roleId, [condition]); // 解锁头像 await unlockFigure(sid, roleId, [condition]); // 解锁头像
await calculateCe(HERO_SYSTEM_TYPE.ADD_SKIN, roleId, hero.serverId, sid, {}, {}, { skinId }); // 全局加成 await calculateCeWithHero(HERO_SYSTEM_TYPE.ADD_SKIN, roleId, hero.serverId, sid, skin.hid, {}, { skinId }); // 全局加成
if (hero) { // 有武将的，将皮肤链接到武将上 if (hero) { // 有武将的，将皮肤链接到武将上
let curSkin = hero.skins.find(cur => cur.id == skinId); let curSkin = hero.skins.find(cur => cur.id == skinId);
game-server/config/serverProtos.ts
+15 -15
View File
@@ -64,21 +64,21 @@ module.exports = {
'required uInt32 code': 2, 'required uInt32 code': 2,
'required Data data': 3 'required Data data': 3
}, },
'onPlayerCeUpdate': { // 'onPlayerCeUpdate': {
'message Data': { // 'message Data': {
"message Hero": { // "message Hero": {
'required uInt32 hid': 1, // 'required uInt32 hid': 1,
'required uInt32 ce': 2, // 'required uInt32 ce': 2,
'required sInt32 incHeroCe': 3, // 'required sInt32 incHeroCe': 3,
}, // },
'required sInt32 ce': 1, // 'required sInt32 ce': 1,
'repeated Hero heros': 2, // 'repeated Hero heros': 2,
'required uInt32 topLineupCe': 3 // 'required uInt32 topLineupCe': 3
}, // },
'required string msg': 1, // 'required string msg': 1,
'required uInt32 code': 2, // 'required uInt32 code': 2,
'required Data data': 3 // 'required Data data': 3
}, // },
'onPlayerDataChange': { 'onPlayerDataChange': {
'message Data': { 'message Data': {
'optional uInt32 coin': 1, 'optional uInt32 coin': 1,
shared/db/Hero.ts
+16 -16
View File
@@ -281,22 +281,22 @@ export default class Hero extends BaseModel {
return update return update
} }
public static async createHero(heroInfo: HeroUpdate, lean = true) { // public static async createHero(heroInfo: HeroUpdate, lean = true) {
const seqId = await CounterModel.getNewCounter(COUNTER.HID) || -1; // const seqId = await CounterModel.getNewCounter(COUNTER.HID) || -1;
const update = this.getInitInfo(heroInfo.hid, { ...heroInfo, seqId }); // const update = this.getInitInfo(heroInfo.hid, { ...heroInfo, seqId });
const hero: HeroType = await HeroModel.findOneAndUpdate({ roleId: heroInfo.roleId, hid: heroInfo.hid }, update, { upsert: true, new: true }).lean(lean); // const hero: HeroType = await HeroModel.findOneAndUpdate({ roleId: heroInfo.roleId, hid: heroInfo.hid }, update, { upsert: true, new: true }).lean(lean);
return hero; // return hero;
} // }
public static async insertHeroes(roleId: string, roleName: string, serverId: number, heroInfos: HeroUpdate[]) { // public static async insertHeroes(roleId: string, roleName: string, serverId: number, heroInfos: HeroUpdate[]) {
let insertInfos: HeroUpdate[] = []; // let insertInfos: HeroUpdate[] = [];
for(let hero of heroInfos) { // for(let hero of heroInfos) {
const seqId = await CounterModel.getNewCounter(COUNTER.HID) || -1; // const seqId = await CounterModel.getNewCounter(COUNTER.HID) || -1;
insertInfos.push({ ...hero, seqId, roleId, roleName, serverId }) // insertInfos.push({ ...hero, seqId, roleId, roleName, serverId })
} // }
await HeroModel.insertMany(insertInfos); // await HeroModel.insertMany(insertInfos);
return <HeroType[]>insertInfos; // return <HeroType[]>insertInfos;
} // }
public static async sumHeroCe(roleId: string) { public static async sumHeroCe(roleId: string) {
let ce: Array<{ ce: number }> = await HeroModel.aggregate([ let ce: Array<{ ce: number }> = await HeroModel.aggregate([
@@ -323,7 +323,7 @@ export default class Hero extends BaseModel {
public static async updateHeroInfo(roleId: string, hid: number, heroUpdate: HeroUpdate, select?: string, getters = false) { public static async updateHeroInfo(roleId: string, hid: number, heroUpdate: HeroUpdate, select?: string, getters = false) {
delete heroUpdate._id; delete heroUpdate._id;
let result: HeroType = await HeroModel.findOneAndUpdate({ roleId, hid }, { $set: heroUpdate }, { new: true }).select(select).lean({ getters }); let result: HeroType = await HeroModel.findOneAndUpdate({ roleId, hid }, { $set: heroUpdate }, { new: true, upsert: true }).select(select).lean({ getters });
return result; return result;
} }
shared/db/RoleCe.ts
+4 -4
View File
@@ -5,7 +5,7 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
export class AttrCell { export class AttrCell {
@prop({ required: true }) @prop({ required: true })
attrId: number; // 属性id attrId: number; // 属性id
@prop({ required: true }) @prop({ required: true, type: Number })
values: number[]; // 战力公式中的全局加成的数据，查表后的结果 values: number[]; // 战力公式中的全局加成的数据，查表后的结果
} }
@@ -35,7 +35,7 @@ export class EquipAttr {
} }
// 百家学宫加成 // 百家学宫加成
class SchoolAttr { export class SchoolAttr {
@prop({ required: true }) @prop({ required: true })
hid: number; // 武将id hid: number; // 武将id
@prop({ required: true }) @prop({ required: true })
@@ -76,13 +76,13 @@ export default class RoleCe extends BaseModel {
equipAttrs: EquipAttr[] equipAttrs: EquipAttr[]
@prop({ required: true, type: SchoolAttr, _id: false }) @prop({ required: true, type: SchoolAttr, _id: false })
schoolAttr: SchoolAttr[]; schoolAttrs: SchoolAttr[];
@prop({ required: true, type: ScrollAttr, _id: false }) @prop({ required: true, type: ScrollAttr, _id: false })
scrollAttrs: ScrollAttr[]; scrollAttrs: ScrollAttr[];
public static async findByRoleId(roleId: string) { public static async findByRoleId(roleId: string) {
let result: RoleCeType = await RoleCeModel.findOneAndUpdate({ roleId }).lean(); let result: RoleCeType = await RoleCeModel.findOne({ roleId }).lean();
return result; return result;
} }
shared/pubUtils/playerCe.ts
-1
View File
@@ -4,7 +4,6 @@
import { HERO_SYSTEM_TYPE, ABI_TYPE, HERO_CE_RATIO, LINEUP_NUM, TALENT_RELATION_TYPE } from '../consts'; import { HERO_SYSTEM_TYPE, ABI_TYPE, HERO_CE_RATIO, LINEUP_NUM, TALENT_RELATION_TYPE } from '../consts';
import { cal, calculatetopLineup, deepCopy, getAllAttrStage, reduceCe } from './util';
import { HeroModel, HeroType, HeroUpdate, CeAttrData, EPlace, Stone, Talent } from '../db/Hero'; import { HeroModel, HeroType, HeroUpdate, CeAttrData, EPlace, Stone, Talent } from '../db/Hero';
import { RoleModel, RoleType, RoleUpdate, CeAttrDataRole } from '../db/Role'; import { RoleModel, RoleType, RoleUpdate, CeAttrDataRole } from '../db/Role';
import { AttributeCal } from '../domain/roleField/attribute'; import { AttributeCal } from '../domain/roleField/attribute';
shared/pubUtils/util.ts
+45 -45
View File
@@ -788,50 +788,50 @@ export function addToMap<T>(map: Map<T, number>, id: T, value: number) {
} }
} }
/** // /**
* 计算最强阵容战力 // * 计算最强阵容战力
* @param role // * @param role
* @param hid // * @param hid
* @param ce // * @param ce
* @param heroId // * @param heroId
*/ // */
export async function calculatetopLineup(role: RoleType, hid?: number, ce?: number, heroId?: string) { // export async function calculatetopLineup(role: RoleType, hid?: number, ce?: number, heroId?: string) {
let topLineup = role?.topLineup || new Array(); // let topLineup = role?.topLineup || new Array();
if(!hid) { // 直接重新排 // if(!hid) { // 直接重新排
let heroes = await HeroModel.getTopHero(role.roleId, LINEUP_NUM); // let heroes = await HeroModel.getTopHero(role.roleId, LINEUP_NUM);
topLineup = heroes.map(cur => { return { hid: cur.hid, ce: cur.ce, hero: cur._id } }); // topLineup = heroes.map(cur => { return { hid: cur.hid, ce: cur.ce, hero: cur._id } });
} else { // } else {
topLineup.sort((a, b) => { return b.ce - a.ce }); // 0-6，最大-最小 // topLineup.sort((a, b) => { return b.ce - a.ce }); // 0-6，最大-最小
let index = topLineup.findIndex(cur => cur.hid == hid); // let index = topLineup.findIndex(cur => cur.hid == hid);
if(index != -1 && !heroId) { // if(index != -1 && !heroId) {
let heroes = await HeroModel.getTopHero(role.roleId, LINEUP_NUM); // let heroes = await HeroModel.getTopHero(role.roleId, LINEUP_NUM);
topLineup = heroes.map(cur => { return { hid: cur.hid, ce: cur.ce, hero: cur._id } }); // topLineup = heroes.map(cur => { return { hid: cur.hid, ce: cur.ce, hero: cur._id } });
} else { // } else {
if (index == -1) { // 不在最强列表 // if (index == -1) { // 不在最强列表
if (topLineup.length < LINEUP_NUM) { // 不满6人 // if (topLineup.length < LINEUP_NUM) { // 不满6人
topLineup.push({ hid, ce, hero: heroId }); // topLineup.push({ hid, ce, hero: heroId });
} else if (topLineup.length == LINEUP_NUM) { // } else if (topLineup.length == LINEUP_NUM) {
if (ce > topLineup[topLineup.length - 1].ce) { // 跻身最强6人 // if (ce > topLineup[topLineup.length - 1].ce) { // 跻身最强6人
topLineup.pop(); // topLineup.pop();
topLineup.push({ hid, ce, hero: heroId }); // topLineup.push({ hid, ce, hero: heroId });
} // }
} else { // } else {
topLineup.splice(LINEUP_NUM, topLineup.length - LINEUP_NUM); // topLineup.splice(LINEUP_NUM, topLineup.length - LINEUP_NUM);
} // }
} else { // 原来就是最强6人 // } else { // 原来就是最强6人
if (ce < topLineup[topLineup.length - 1].ce) { // 滑出最强 // if (ce < topLineup[topLineup.length - 1].ce) { // 滑出最强
let heroes = await HeroModel.getTopHero(role.roleId, LINEUP_NUM); // let heroes = await HeroModel.getTopHero(role.roleId, LINEUP_NUM);
topLineup = heroes.map(cur => { return { hid: cur.hid, ce: cur.ce, hero: cur._id } }); // topLineup = heroes.map(cur => { return { hid: cur.hid, ce: cur.ce, hero: cur._id } });
} else { // } else {
topLineup[index].ce = ce; // topLineup[index].ce = ce;
} // }
} // }
} // }
} // }
let topLineupCe = topLineup.reduce((pre, cur) => { // let topLineupCe = topLineup.reduce((pre, cur) => {
return pre + cur.ce // return pre + cur.ce
}, 0); // }, 0);
return { topLineup, topLineupCe }; // return { topLineup, topLineupCe };
} // }