This commit is contained in:
xy
2026-03-13 01:38:40 +00:00
parent e6e4f88257
commit 28855885cd
311 changed files with 89544 additions and 94350 deletions
@@ -1,358 +1,359 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, TASK_TYPE } from "../../../consts";
import { ArtifactModel, ArtifactModelType, ArtifactModelUpdate } from "../../../db/Artifact";
import { HeroModel } from "../../../db/Hero";
import { ArtifactParam } from "../../../domain/roleField/hero";
import { gameData, getArtifactByGidAndType, getArtifactStageZero, getArtifactWithQuality, getDicArtifactLvByPlanId, getNextArtifact } from "../../../pubUtils/data";
import { ARTIFACT, BAG } from "../../../pubUtils/dicParam";
import { ItemInter, RewardInter } from "../../../pubUtils/interface";
import { resResult, parseGoodStr, arrToMap, genCode } from "../../../pubUtils/util";
import { checkArtifactCanCompose, getRebuildConsume, hasArtifactStrength } from "../../../services/equipService";
import { calculateCeWithHero } from "../../../services/playerCeService";
import { CheckMeterial } from "../../../services/role/checkMaterial";
import { addItems, handleCost } from "../../../services/role/rewardService";
import { combineItems } from "../../../services/role/util";
import { checkTask } from "../../../services/task/taskService";
export default function (app: Application) {
new HandlerService(app, {});
return new ArtifactHandler(app);
}
export class ArtifactHandler {
constructor(private app: Application) {
}
public async putOn(msg: { seqId: number, hid: number, isExtendLv: boolean }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, hid, isExtendLv } = msg;
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
let chosenArtifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!chosenArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
if(chosenArtifact.lv > 0) isExtendLv = false;
let artifacts: ArtifactModelType[] = [];
let artifactOfHero = hero.artifact? await ArtifactModel.findbySeqId(roleId, hero.artifact): null; // 原本自己的天晶石
let targetLv = artifactOfHero?.lv, returnCoin: RewardInter[] = [];
let dicChosenArtifact = getArtifactWithQuality(chosenArtifact.artifactId);
if(!dicChosenArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(isExtendLv && targetLv > dicChosenArtifact.maxLv) {
for(let lv = dicChosenArtifact.maxLv + 1; lv <= targetLv; lv++) {
let dicArtifactLv = getDicArtifactLvByPlanId(dicChosenArtifact.lvAttrPlan, lv);
if(!dicArtifactLv) break;
returnCoin.push(...dicArtifactLv.consumes);
}
targetLv = dicChosenArtifact.maxLv;
};
if(artifactOfHero) { // 更新自己的天晶石
artifactOfHero = await ArtifactModel.putOnOrOff(roleId, artifactOfHero.seqId, 0, isExtendLv? 0: undefined);
if(artifactOfHero) artifacts.push(artifactOfHero);
}
if(chosenArtifact.hid != 0) {
let heroOfChosenArtifact = await HeroModel.findByHidAndRole(chosenArtifact.hid, roleId); // 我想要的宝物的原持有者
if(heroOfChosenArtifact) {
await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_OFF_ARTIFACT, roleId, serverId, sid, heroOfChosenArtifact.hid, { artifact: 0 }); // 对方卸下
}
}
chosenArtifact = await ArtifactModel.putOnOrOff(roleId, seqId, hid, isExtendLv? targetLv: undefined);
if(chosenArtifact) artifacts.push(chosenArtifact);
await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_ARTIFACT, roleId, serverId, sid, hid, { artifact: seqId }, { artifact: chosenArtifact, job: hero.job, skinId: hero.skinId }); // 把我的换给他
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_QUALITY_EQUIP, { artifacts });
let goods = returnCoin.length > 0? await addItems(roleId, roleName, sid, combineItems(returnCoin), ITEM_CHANGE_REASON.ARTIFACT_LV_RETURN): undefined;
return resResult(STATUS.SUCCESS, { artifacts: artifacts.map(artifact => new ArtifactParam(artifact)), goods });
}
public async putOff(msg: { seqId: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId } = msg;
let chosenArtifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!chosenArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let heroOfChosenArtifact = await HeroModel.findByHidAndRole(chosenArtifact.hid, roleId); // 我想要的宝物的原持有者
if(!heroOfChosenArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_EQUIPED);
chosenArtifact = await ArtifactModel.putOnOrOff(roleId, seqId, 0);
let artifacts: ArtifactParam[] = [new ArtifactParam(chosenArtifact)];
await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_OFF_ARTIFACT, roleId, serverId, sid, heroOfChosenArtifact.hid, { artifact: 0 }); // 把我的换给他
return resResult(STATUS.SUCCESS, { artifacts });
}
public async lvUp(msg: { seqId: number, isOneClick: boolean }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, isOneClick } = msg;
let artifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!artifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicArtifact = getArtifactWithQuality(artifact.artifactId);
if(!dicArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(artifact.lv >= dicArtifact.maxLv) return resResult(STATUS.ARTIFACT_LV_MAX);
let toLv = isOneClick? artifact.lv + 5: artifact.lv + 1;
if(toLv > dicArtifact.maxLv) toLv = dicArtifact.maxLv;
let newLv = artifact.lv;
let check = new CheckMeterial(roleId);
for (let lv = artifact.lv + 1; lv <= toLv; lv++) {
let dicArtifactLv = getDicArtifactLvByPlanId(dicArtifact.lvAttrPlan, lv);
if(!dicArtifactLv) break;
let isEnough = await check.decrease(dicArtifactLv.consumes);
if(!isEnough) break; // 消耗不足
newLv = lv;
}
if(newLv == artifact.lv) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let consumes = check.getConsume();
let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.ARTIFACT_LV);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
artifact = await ArtifactModel.updateInfoBySeqId(roleId, seqId, { lv: newLv });
if(artifact.hid > 0) {
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_LV, roleId, serverId, sid, artifact.hid, {}, { artifact });
}
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_LV, { artifacts: [artifact] });
return resResult(STATUS.SUCCESS, { artifact: new ArtifactParam(artifact) });
}
public async compose(msg: { seqId: number, material: number[], generalItems: {id: number, count: number}[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, material = [], generalItems = [] } = msg;
let seqIds = [seqId, ...material];
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let artifactMap = arrToMap(artifacts, obj => obj.seqId);
let originArtifact = artifactMap.get(seqId);
if(!originArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicOriginArtifact = getArtifactWithQuality(originArtifact.artifactId);
if(!dicOriginArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicNextArtifact = getNextArtifact(originArtifact.artifactId);
if(!dicNextArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 狗粮处理
let remainCnt = dicNextArtifact.materialCnt, cost: ItemInter[] = [], delSeqIds: number[] = [];
for(let seqId of material) {
let artifact = artifactMap.get(seqId);
let res = checkArtifactCanCompose(originArtifact.artifactId, artifact);
if(res.code != 0) return resResult(res);
cost.push({ seqId, id: artifact.id });
delSeqIds.push(seqId);
remainCnt--;
}
// 通用道具
if(dicNextArtifact.materialGroup == 0 && remainCnt > 0) { // 可使用材料代替,不是必须同名的那种
let dicMaterialArtifactQuality = gameData.artifactQualityById.get(dicNextArtifact.materialId);
if(!dicMaterialArtifactQuality) return resResult(STATUS.DIC_DATA_NOT_FOUND);
for(let { id, count } of dicMaterialArtifactQuality.generalItem) {
let needCount = count * remainCnt;
let chosenItem = generalItems.find(cur => cur.id == id);
if(!chosenItem || chosenItem.count < needCount) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
cost.push({ id, count: needCount });
}
remainCnt = 0;
}
if(remainCnt > 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ARTIFACT_QUALITY);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { quality, qualityStage, artifactId, goodId } = dicNextArtifact;
originArtifact = await ArtifactModel.updateInfoBySeqId(roleId, seqId, { quality, qualityStage, artifactId, id: goodId });
if(originArtifact.hid > 0) {
let hero = await HeroModel.findByHidAndRole(originArtifact.hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_QUALITY, roleId, serverId, sid, originArtifact.hid, {}, { artifact: originArtifact, job: hero.job, skinId: hero.skinId });
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_QUALITY_EQUIP, { artifacts: [originArtifact] });
}
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_COMPOSE, { count: 1 });
return resResult(STATUS.SUCCESS, { delSeqIds, artifact: new ArtifactParam(originArtifact) });
}
public async composeAll(msg: {}, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let taskCount = 0;
const batchCode = genCode(10), delSeqIds: (number|string)[] = [];
for(let [_, { quality, canComposeAll }] of gameData.artifactQualityById) {
if(!canComposeAll) continue;
let artifacts = await ArtifactModel.findByQuality(roleId, quality);
let used: (number|string)[] = [], materials: ItemInter[] = [], target: ArtifactModelUpdate[] = [];
for(let artifact of artifacts) {
if(used.indexOf(artifact.seqId) > -1) continue;
let tmpUsed: (number|string)[] = [artifact.seqId];
let dicNextArtifact = getNextArtifact(artifact.artifactId);
if(!dicNextArtifact) continue;
let { materialCnt, goodId: nextGid, artifactId: nextArtId, quality: nextQuality, qualityStage: nextStage } = dicNextArtifact;
let canUseMaterial: ItemInter[] = [];
for(let i = 0; i < materialCnt; i++) {
for(let _artifact of artifacts) {
if(used.indexOf(_artifact.seqId) > -1 || tmpUsed.indexOf(_artifact.seqId) > -1) continue;
let res = checkArtifactCanCompose(artifact.artifactId, _artifact);
if(res.code != 0) continue;
canUseMaterial.push({ id: _artifact.id, seqId: _artifact.seqId });
tmpUsed.push(_artifact.seqId);
break;
}
}
if(materialCnt == canUseMaterial.length) {
used.push(...tmpUsed);
materials.push(...canUseMaterial);
delSeqIds.push(...canUseMaterial.map(cur => cur.seqId));
target.push({ seqId: artifact.seqId, id: nextGid, artifactId: nextArtId, quality: nextQuality, qualityStage: nextStage });
taskCount++;
}
}
let result = await handleCost(roleId, sid, materials, ITEM_CHANGE_REASON.ARTIFACT_QUALITY);
if (!result) continue;
for(let { seqId, quality, qualityStage, artifactId, id} of target) {
await ArtifactModel.updateInfoBySeqId(roleId, seqId, { quality, qualityStage, artifactId, id, batchCode });
}
}
let artifacts = await ArtifactModel.findByBatchCode(batchCode);
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_COMPOSE, { count: taskCount });
return resResult(STATUS.SUCCESS, { delSeqIds, artifacts: artifacts.map(artifact => new ArtifactParam(artifact))});
}
public async transfer(msg: { seqId: number, type: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, type } = msg;
let artifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!artifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicArtifact = gameData.artifact.get(artifact.artifactId);
if(!dicArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(dicArtifact.type == type) return resResult(STATUS.ARTIFACT_TYPE_SAME);
let dicTargetArtifact = getArtifactByGidAndType(dicArtifact.goodId, type);
if(!dicTargetArtifact) return resResult(STATUS.ARTIFACT_TYPE_ERR);
let consume = parseGoodStr(ARTIFACT.TRANSFER_COST);
let result = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.ARTIFACT_TRANSFER);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { artifactId, goodId } = dicTargetArtifact;
artifact = await ArtifactModel.updateInfoBySeqId(roleId, seqId, { artifactId, id: goodId });
if(artifact.hid > 0) {
let hero = await HeroModel.findByHidAndRole(artifact.hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_TRANSFER, roleId, serverId, sid, artifact.hid, {}, { artifact, job: hero.job, skinId: hero.skinId });
}
return resResult(STATUS.SUCCESS, { artifact: new ArtifactParam(artifact) });
}
public async previewRebuild(msg: { seqIds: number[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { seqIds } = msg;
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let consumes = getRebuildConsume(artifacts);
return resResult(STATUS.SUCCESS, { consumes });
}
public async rebuild(msg: { seqIds: number[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let serverId: number = session.get('serverId');
let sid: string = session.get('sid');
let { seqIds } = msg;
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let rebuildConsumes = getRebuildConsume(artifacts);
if(rebuildConsumes.length <= 0) return resResult(STATUS.ARTIFACT_HAS_NO_STRENGTH);
let consume = parseGoodStr(ARTIFACT.REBUILD_COST);
let result = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.ARTIFACT_REBUILD);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let returnArtifact: ArtifactParam[] = [];
for(let artifact of artifacts) {
let dicArtifactZero = getArtifactStageZero(artifact.artifactId);
if(!dicArtifactZero) continue;
let { artifactId, goodId, quality, qualityStage } = dicArtifactZero;
let result = await ArtifactModel.updateInfoBySeqId(roleId, artifact.seqId, { artifactId, id: goodId, quality, qualityStage, lv: 0 });
if(result && result.hid > 0) {
let hero = await HeroModel.findByHidAndRole(result.hid, roleId);
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_REBUILD, roleId, serverId, sid, result.hid, {}, { artifact: result, skinId: hero.skinId, job: hero.job });
}
returnArtifact.push(new ArtifactParam(result));
}
let goods = await addItems(roleId, roleName, sid, rebuildConsumes, ITEM_CHANGE_REASON.ARTIFACT_REBUILD);
return resResult(STATUS.SUCCESS, { artifacts: returnArtifact, goods });
}
public async decompose(msg: { seqIds: number[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let roleName: string = session.get('roleName');
let { seqIds } = msg;
if(seqIds.length > BAG.BAG_ARTIFACT_DECOMPOSE_UPLIMITED) {
return resResult(STATUS.EQUIP_DECOMPOSE_IS_UPLIMIT);
}
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let cost: ItemInter[] = [], add: ItemInter[] = [], delSeqIds: (number|string)[] = [];
for(let artifact of artifacts) {
if(artifact.hid > 0 || hasArtifactStrength(artifact)) return resResult(STATUS.ARTIFACT_CANNOT_DECOMPOSE);
let dicArtifact = getArtifactWithQuality(artifact.artifactId);
if(!dicArtifact || !dicArtifact.canDecompose) return resResult(STATUS.ARTIFACT_CANNOT_DECOMPOSE);
let dicZeroArtifact = getArtifactStageZero(artifact.artifactId);
if(!dicZeroArtifact) continue;
add.push(...dicZeroArtifact.generalItem);
cost.push({ seqId: artifact.seqId, id: artifact.id, count: 1 });
delSeqIds.push(artifact.seqId);
}
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.EQUIP_DECOMPOSE); // 删掉装备
if(!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let result = await addItems(roleId, roleName, sid, add, ITEM_CHANGE_REASON.EQUIP_DECOMPOSE);
return resResult(STATUS.SUCCESS, { delSeqIds, goods: combineItems(result) });
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, TASK_TYPE } from "../../../consts";
import { ArtifactModel, ArtifactModelType, ArtifactModelUpdate } from "@db/Artifact";
import { HeroModel } from "@db/Hero";
import { ArtifactParam } from "@domain/roleField/hero";
import { gameData, getArtifactByGidAndType, getArtifactStageZero, getArtifactWithQuality, getDicArtifactLvByPlanId, getNextArtifact } from "@pubUtils/data";
import { ARTIFACT, BAG } from "@pubUtils/dicParam";
import { ItemInter, RewardInter } from "@pubUtils/interface";
import { resResult, parseGoodStr, arrToMap, genCode } from "@pubUtils/util";
import { checkArtifactCanCompose, getRebuildConsume, hasArtifactStrength } from "../../../services/equipService";
import { calculateCeWithHero } from "../../../services/playerCeService";
import { CheckMeterial } from "../../../services/role/checkMaterial";
import { addItems, handleCost } from "../../../services/role/rewardService";
import { combineItems } from "../../../services/role/util";
import { checkTask } from "../../../services/task/taskService";
export default function (app: Application) {
new HandlerService(app, {});
return new ArtifactHandler(app);
}
export class ArtifactHandler {
constructor(private app: Application) {
}
public async putOn(msg: { seqId: number, hid: number, isExtendLv: boolean }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, hid, isExtendLv } = msg;
let hero = await HeroModel.findByHidAndRole(hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
let chosenArtifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!chosenArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
if(chosenArtifact.lv > 0) isExtendLv = false;
let artifacts: ArtifactModelType[] = [];
let artifactOfHero = hero.artifact? await ArtifactModel.findbySeqId(roleId, hero.artifact): null; // 原本自己的天晶石
let targetLv = artifactOfHero?.lv, returnCoin: RewardInter[] = [];
let dicChosenArtifact = getArtifactWithQuality(chosenArtifact.artifactId);
if(!dicChosenArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(isExtendLv && targetLv > dicChosenArtifact.maxLv) {
for(let lv = dicChosenArtifact.maxLv + 1; lv <= targetLv; lv++) {
let dicArtifactLv = getDicArtifactLvByPlanId(dicChosenArtifact.lvAttrPlan, lv);
if(!dicArtifactLv) break;
returnCoin.push(...dicArtifactLv.consumes);
}
targetLv = dicChosenArtifact.maxLv;
};
if(artifactOfHero) { // 更新自己的天晶石
artifactOfHero = await ArtifactModel.putOnOrOff(roleId, artifactOfHero.seqId, 0, isExtendLv? 0: undefined);
if(artifactOfHero) artifacts.push(artifactOfHero);
}
if(chosenArtifact.hid != 0) {
let heroOfChosenArtifact = await HeroModel.findByHidAndRole(chosenArtifact.hid, roleId); // 我想要的宝物的原持有者
if(heroOfChosenArtifact) {
await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_OFF_ARTIFACT, roleId, serverId, sid, heroOfChosenArtifact.hid, { artifact: 0 }); // 对方卸下
}
}
chosenArtifact = await ArtifactModel.putOnOrOff(roleId, seqId, hid, isExtendLv? targetLv: undefined);
if(chosenArtifact) artifacts.push(chosenArtifact);
await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_ARTIFACT, roleId, serverId, sid, hid, { artifact: seqId }, { artifact: chosenArtifact, job: hero.job, skinId: hero.skinId }); // 把我的换给他
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_QUALITY_EQUIP, { artifacts });
let goods = returnCoin.length > 0? await addItems(roleId, roleName, sid, combineItems(returnCoin), ITEM_CHANGE_REASON.ARTIFACT_LV_RETURN): undefined;
return resResult(STATUS.SUCCESS, { artifacts: artifacts.map(artifact => new ArtifactParam(artifact)), goods });
}
public async putOff(msg: { seqId: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId } = msg;
let chosenArtifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!chosenArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let heroOfChosenArtifact = await HeroModel.findByHidAndRole(chosenArtifact.hid, roleId); // 我想要的宝物的原持有者
if(!heroOfChosenArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_EQUIPED);
chosenArtifact = await ArtifactModel.putOnOrOff(roleId, seqId, 0);
let artifacts: ArtifactParam[] = [new ArtifactParam(chosenArtifact)];
await calculateCeWithHero(HERO_SYSTEM_TYPE.PUT_OFF_ARTIFACT, roleId, serverId, sid, heroOfChosenArtifact.hid, { artifact: 0 }); // 把我的换给他
return resResult(STATUS.SUCCESS, { artifacts });
}
public async lvUp(msg: { seqId: number, isOneClick: boolean }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, isOneClick } = msg;
let artifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!artifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicArtifact = getArtifactWithQuality(artifact.artifactId);
if(!dicArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(artifact.lv >= dicArtifact.maxLv) return resResult(STATUS.ARTIFACT_LV_MAX);
let toLv = isOneClick? artifact.lv + 5: artifact.lv + 1;
if(toLv > dicArtifact.maxLv) toLv = dicArtifact.maxLv;
let newLv = artifact.lv;
let check = new CheckMeterial(roleId);
for (let lv = artifact.lv + 1; lv <= toLv; lv++) {
let dicArtifactLv = getDicArtifactLvByPlanId(dicArtifact.lvAttrPlan, lv);
if(!dicArtifactLv) break;
let isEnough = await check.decrease(dicArtifactLv.consumes);
if(!isEnough) break; // 消耗不足
newLv = lv;
}
if(newLv == artifact.lv) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let consumes = check.getConsume();
let result = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.ARTIFACT_LV);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
artifact = await ArtifactModel.updateInfoBySeqId(roleId, seqId, { lv: newLv });
if(artifact.hid > 0) {
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_LV, roleId, serverId, sid, artifact.hid, {}, { artifact });
}
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_LV, { artifacts: [artifact] });
return resResult(STATUS.SUCCESS, { artifact: new ArtifactParam(artifact) });
}
public async compose(msg: { seqId: number, material: number[], generalItems: {id: number, count: number}[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, material = [], generalItems = [] } = msg;
let seqIds = [seqId, ...material];
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let artifactMap = arrToMap(artifacts, obj => obj.seqId);
let originArtifact = artifactMap.get(seqId);
if(!originArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicOriginArtifact = getArtifactWithQuality(originArtifact.artifactId);
if(!dicOriginArtifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicNextArtifact = getNextArtifact(originArtifact.artifactId);
if(!dicNextArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 狗粮处理
let remainCnt = dicNextArtifact.materialCnt, cost: ItemInter[] = [], delSeqIds: number[] = [];
for(let seqId of material) {
let artifact = artifactMap.get(seqId);
let res = checkArtifactCanCompose(originArtifact.artifactId, artifact);
if(res.code != 0) return resResult(res);
cost.push({ seqId, id: artifact.id });
delSeqIds.push(seqId);
remainCnt--;
}
// 通用道具
if(dicNextArtifact.materialGroup == 0 && remainCnt > 0) { // 可使用材料代替,不是必须同名的那种
let dicMaterialArtifactQuality = gameData.artifactQualityById.get(dicNextArtifact.materialId);
if(!dicMaterialArtifactQuality) return resResult(STATUS.DIC_DATA_NOT_FOUND);
for(let { id, count } of dicMaterialArtifactQuality.generalItem) {
let needCount = count * remainCnt;
let chosenItem = generalItems.find(cur => cur.id == id);
if(!chosenItem || chosenItem.count < needCount) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
cost.push({ id, count: needCount });
}
remainCnt = 0;
}
if(remainCnt > 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ARTIFACT_QUALITY);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { quality, qualityStage, artifactId, goodId } = dicNextArtifact;
originArtifact = await ArtifactModel.updateInfoBySeqId(roleId, seqId, { quality, qualityStage, artifactId, id: goodId });
if(originArtifact.hid > 0) {
let hero = await HeroModel.findByHidAndRole(originArtifact.hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_QUALITY, roleId, serverId, sid, originArtifact.hid, {}, { artifact: originArtifact, job: hero.job, skinId: hero.skinId });
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_QUALITY_EQUIP, { artifacts: [originArtifact] });
}
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_COMPOSE, { count: 1 });
return resResult(STATUS.SUCCESS, { delSeqIds, artifact: new ArtifactParam(originArtifact) });
}
public async composeAll(msg: {}, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let taskCount = 0;
const batchCode = genCode(10), delSeqIds: (number|string)[] = [];
for(let [_, { quality, canComposeAll }] of gameData.artifactQualityById) {
if(!canComposeAll) continue;
let artifacts = await ArtifactModel.findByQuality(roleId, quality);
let used: (number|string)[] = [], materials: ItemInter[] = [], target: ArtifactModelUpdate[] = [];
for(let artifact of artifacts) {
if(used.indexOf(artifact.seqId) > -1) continue;
let tmpUsed: (number|string)[] = [artifact.seqId];
let dicNextArtifact = getNextArtifact(artifact.artifactId);
if(!dicNextArtifact) continue;
let { materialCnt, goodId: nextGid, artifactId: nextArtId, quality: nextQuality, qualityStage: nextStage } = dicNextArtifact;
let canUseMaterial: ItemInter[] = [];
for(let i = 0; i < materialCnt; i++) {
for(let _artifact of artifacts) {
if(used.indexOf(_artifact.seqId) > -1 || tmpUsed.indexOf(_artifact.seqId) > -1) continue;
let res = checkArtifactCanCompose(artifact.artifactId, _artifact);
if(res.code != 0) continue;
canUseMaterial.push({ id: _artifact.id, seqId: _artifact.seqId });
tmpUsed.push(_artifact.seqId);
break;
}
}
if(materialCnt == canUseMaterial.length) {
used.push(...tmpUsed);
materials.push(...canUseMaterial);
delSeqIds.push(...canUseMaterial.map(cur => cur.seqId));
target.push({ seqId: artifact.seqId, id: nextGid, artifactId: nextArtId, quality: nextQuality, qualityStage: nextStage });
taskCount++;
}
}
let result = await handleCost(roleId, sid, materials, ITEM_CHANGE_REASON.ARTIFACT_QUALITY);
if (!result) continue;
for(let { seqId, quality, qualityStage, artifactId, id} of target) {
await ArtifactModel.updateInfoBySeqId(roleId, seqId, { quality, qualityStage, artifactId, id, batchCode });
}
}
let artifacts = await ArtifactModel.findByBatchCode(batchCode);
await checkTask(serverId, roleId, sid, TASK_TYPE.ARTIFACT_COMPOSE, { count: taskCount });
return resResult(STATUS.SUCCESS, { delSeqIds, artifacts: artifacts.map(artifact => new ArtifactParam(artifact))});
}
public async transfer(msg: { seqId: number, type: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { seqId, type } = msg;
let artifact = await ArtifactModel.findbySeqId(roleId, seqId);
if(!artifact) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let dicArtifact = gameData.artifact.get(artifact.artifactId);
if(!dicArtifact) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(dicArtifact.type == type) return resResult(STATUS.ARTIFACT_TYPE_SAME);
let dicTargetArtifact = getArtifactByGidAndType(dicArtifact.goodId, type);
if(!dicTargetArtifact) return resResult(STATUS.ARTIFACT_TYPE_ERR);
let consume = parseGoodStr(ARTIFACT.TRANSFER_COST);
let result = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.ARTIFACT_TRANSFER);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { artifactId, goodId } = dicTargetArtifact;
artifact = await ArtifactModel.updateInfoBySeqId(roleId, seqId, { artifactId, id: goodId });
if(artifact.hid > 0) {
let hero = await HeroModel.findByHidAndRole(artifact.hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_FIND);
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_TRANSFER, roleId, serverId, sid, artifact.hid, {}, { artifact, job: hero.job, skinId: hero.skinId });
}
return resResult(STATUS.SUCCESS, { artifact: new ArtifactParam(artifact) });
}
public async previewRebuild(msg: { seqIds: number[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { seqIds } = msg;
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let consumes = getRebuildConsume(artifacts);
return resResult(STATUS.SUCCESS, { consumes });
}
public async rebuild(msg: { seqIds: number[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let serverId: number = session.get('serverId');
let sid: string = session.get('sid');
let { seqIds } = msg;
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let rebuildConsumes = getRebuildConsume(artifacts);
if(rebuildConsumes.length <= 0) return resResult(STATUS.ARTIFACT_HAS_NO_STRENGTH);
let consume = parseGoodStr(ARTIFACT.REBUILD_COST);
let result = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.ARTIFACT_REBUILD);
if (!result) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let returnArtifact: ArtifactParam[] = [];
for(let artifact of artifacts) {
let dicArtifactZero = getArtifactStageZero(artifact.artifactId);
if(!dicArtifactZero) continue;
let { artifactId, goodId, quality, qualityStage } = dicArtifactZero;
let result = await ArtifactModel.updateInfoBySeqId(roleId, artifact.seqId, { artifactId, id: goodId, quality, qualityStage, lv: 0 });
if(result && result.hid > 0) {
let hero = await HeroModel.findByHidAndRole(result.hid, roleId);
await calculateCeWithHero(HERO_SYSTEM_TYPE.ARTIFACT_REBUILD, roleId, serverId, sid, result.hid, {}, { artifact: result, skinId: hero.skinId, job: hero.job });
}
returnArtifact.push(new ArtifactParam(result));
}
let goods = await addItems(roleId, roleName, sid, rebuildConsumes, ITEM_CHANGE_REASON.ARTIFACT_REBUILD);
return resResult(STATUS.SUCCESS, { artifacts: returnArtifact, goods });
}
public async decompose(msg: { seqIds: number[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let roleName: string = session.get('roleName');
let { seqIds } = msg;
if(seqIds.length > BAG.BAG_ARTIFACT_DECOMPOSE_UPLIMITED) {
return resResult(STATUS.EQUIP_DECOMPOSE_IS_UPLIMIT);
}
let artifacts = await ArtifactModel.findbySeqIds(roleId, seqIds);
if (artifacts.length < seqIds.length) return resResult(STATUS.ARTIFACT_IS_NOT_FIND);
let cost: ItemInter[] = [], add: ItemInter[] = [], delSeqIds: (number|string)[] = [];
for(let artifact of artifacts) {
if(artifact.hid > 0 || hasArtifactStrength(artifact)) return resResult(STATUS.ARTIFACT_CANNOT_DECOMPOSE);
let dicArtifact = getArtifactWithQuality(artifact.artifactId);
if(!dicArtifact || !dicArtifact.canDecompose) return resResult(STATUS.ARTIFACT_CANNOT_DECOMPOSE);
let dicZeroArtifact = getArtifactStageZero(artifact.artifactId);
if(!dicZeroArtifact) continue;
add.push(...dicZeroArtifact.generalItem);
cost.push({ seqId: artifact.seqId, id: artifact.id, count: 1 });
delSeqIds.push(artifact.seqId);
}
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.EQUIP_DECOMPOSE); // 删掉装备
if(!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let result = await addItems(roleId, roleName, sid, add, ITEM_CHANGE_REASON.EQUIP_DECOMPOSE);
return resResult(STATUS.SUCCESS, { delSeqIds, goods: combineItems(result) });
}
}
@@ -1,183 +1,184 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, TASK_TYPE } from "../../../consts";
import { gameData, getDicAuthorBookSub } from "../../../pubUtils/data";
import { RewardInter } from "../../../pubUtils/interface";
import { resResult } from "../../../pubUtils/util";
import { calculateCeWithRole } from "../../../services/playerCeService";
import { CheckMeterial } from "../../../services/role/checkMaterial";
import { addItems, handleCost } from "../../../services/role/rewardService";
import { combineItems } from "../../../services/role/util";
import { AuthorBookModel } from "../../../db/AuthorBook";
import { checkAuthorBookLimit, replaceAuthorBooks } from "../../../services/roleService";
import { checkTask } from "../../../services/task/taskService";
export default function (app: Application) {
new HandlerService(app, {});
return new AuthorsBookHandler(app);
}
export class AuthorsBookHandler {
constructor(private app: Application) {
}
public async starUp(msg: { bookId: number, subId: number, star: number, useItem: boolean }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const { bookId, subId, star, useItem } = msg;
let allAuthorBooks = await AuthorBookModel.findByRoleId(roleId);
let authorBookData = allAuthorBooks.find(authorBook => authorBook.bookId == bookId);
let starInData = authorBookData?.authors?.find(cur => cur.subId == subId)?.star??0;
if(star != starInData) return resResult(STATUS.ACCESS_BUSY);
let dicAuthorsBookSub = getDicAuthorBookSub(bookId, subId, star + 1);
if(!dicAuthorsBookSub) return resResult(STATUS.AUTHOR_BOOK_SUB_MAX);
// 是否解锁(进度解锁)
if(!checkAuthorBookLimit(allAuthorBooks, bookId)) return resResult(STATUS.AUTHOR_BOOK_LOCK);
// 英灵是否够
let check = new CheckMeterial(roleId);
let isEnough = await check.decreaseItemsContinue(dicAuthorsBookSub.spirits);
let useItemCnt = 0;
if(useItem) { // 使用英灵石代替
if(!isEnough) {
let notEnoughItems = check.getNotEnoughItems();
let replaceItems: RewardInter[] = [];
for(let [ id, count ] of notEnoughItems) {
let dicSpirit = gameData.spirit.get(id);
if(!dicSpirit) return resResult(STATUS.DIC_DATA_NOT_FOUND); // 应该是表填错,正常情况不可能出现
for(let item of dicSpirit.composeItem) {
replaceItems.push({ id: item.id, count: item.count * count });
useItemCnt += item.count * count;
}
}
isEnough = await check.decreaseItemsContinue(replaceItems);
}
}
if(!isEnough) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let consumes = check.getConsume();
let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.AUTHOR_BOOK_STAR_UP);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 升星
authorBookData = await AuthorBookModel.upStar(roleId, bookId, subId, star, dicAuthorsBookSub.value, gameData.authorBookSubs.get(bookId)||[]);
if(!authorBookData) {
// 防并发问题
await addItems(roleId, roleName, sid, consumes, ITEM_CHANGE_REASON.AUTHOR_BOOK_STAR_RETURN);
return resResult(STATUS.ACCESS_BUSY);
}
// 计算战力更新
await calculateCeWithRole(HERO_SYSTEM_TYPE.AUTHOR_BOOK_STAR, roleId, serverId, sid, {}, { authorBooks: replaceAuthorBooks(allAuthorBooks, authorBookData), bookId, subId });
let curAuthorBook = authorBookData.authors?.find(cur => cur.subId == subId);
let maxProgress = gameData.authorBookMaxProgress.get(bookId)??0;
await checkTask(serverId, roleId, sid, TASK_TYPE.FUND_AUTHOR, { authorProgress: await AuthorBookModel.findProgressByRoleId(roleId) });
return resResult(STATUS.SUCCESS, {
bookId,
subId,
star: curAuthorBook?.star??0,
progress: authorBookData.progress,
maxProgress,
useItemCnt
});
}
// 重置条目
public async resetAuthor(msg: { bookId: number, subId: number, star: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const { bookId, subId, star } = msg;
let allAuthorBooks = await AuthorBookModel.findByRoleId(roleId);
let authorBookData = allAuthorBooks.find(authorBook => authorBook.bookId == bookId);
if(!authorBookData) return resResult(STATUS.ACCESS_BUSY)
let starInData = authorBookData?.authors?.find(cur => cur.subId == subId)?.star??0;
if(star != starInData) return resResult(STATUS.ACCESS_BUSY);
let progress = 0, spirits: RewardInter[] = [];
for(let i = 1; i <= star; i++) {
let dicAuthorsBookSub = getDicAuthorBookSub(bookId, subId, i);
if(!dicAuthorsBookSub) return resResult(STATUS.DIC_DATA_NOT_FOUND);
progress += dicAuthorsBookSub.value;
spirits.push(...dicAuthorsBookSub.spirits);
}
// 重置诸子列传
authorBookData = await AuthorBookModel.resetSub(roleId, bookId, subId, star, -progress);
if(!authorBookData) return resResult(STATUS.ACCESS_BUSY);
let goods = await addItems(roleId, roleName, sid, combineItems(spirits), ITEM_CHANGE_REASON.AUTHOR_BOOK_SUB_RESET);
// 计算战力更新
await calculateCeWithRole(HERO_SYSTEM_TYPE.AUTHOR_BOOK_SUB_RESET, roleId, serverId, sid, {}, { authorBooks: replaceAuthorBooks(allAuthorBooks, authorBookData), bookId, subId });
let curAuthorBook = authorBookData.authors?.find(cur => cur.subId == subId);
let maxProgress = gameData.authorBookMaxProgress.get(bookId)??0;
await checkTask(serverId, roleId, sid, TASK_TYPE.FUND_AUTHOR, { authorProgress: await AuthorBookModel.findProgressByRoleId(roleId) });
return resResult(STATUS.SUCCESS, {
bookId,
subId,
star: curAuthorBook?.star??0,
progress: authorBookData.progress,
maxProgress,
goods
});
}
// 买英灵
public async buySpirit(msg: { id: number, count: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let roleName: string = session.get('roleName');
const { id, count } = msg;
let dicSpirit = gameData.spirit.get(id);
if(!dicSpirit) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let consumes = dicSpirit.composeItem.map(cur => ({ id: cur.id, count: cur.count * count }));
let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.BUY_SPIRIT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let reward = [{ id, count }];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BUY_SPIRIT);
return resResult(STATUS.SUCCESS, { goods });
}
public async decomposeSpirit(msg: { spirits: { id: number, count: number }[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let roleName: string = session.get('roleName');
const { spirits = [] } = msg;
let rewards: RewardInter[] = [];
for(let { id, count } of spirits) {
let dicSpirit = gameData.spirit.get(id);
if(!dicSpirit) return resResult(STATUS.DIC_DATA_NOT_FOUND);
for(let item of dicSpirit.decomposeItem) {
rewards.push({ id: item.id, count: item.count * count });
}
}
let consumes = spirits;
let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.DECOMPOSE_SPIRIT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.DECOMPOSE_SPIRIT);
return resResult(STATUS.SUCCESS, { goods });
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, TASK_TYPE } from "../../../consts";
import { gameData, getDicAuthorBookSub } from "@pubUtils/data";
import { RewardInter } from "@pubUtils/interface";
import { resResult } from "@pubUtils/util";
import { calculateCeWithRole } from "../../../services/playerCeService";
import { CheckMeterial } from "../../../services/role/checkMaterial";
import { addItems, handleCost } from "../../../services/role/rewardService";
import { combineItems } from "../../../services/role/util";
import { AuthorBookModel } from "@db/AuthorBook";
import { checkAuthorBookLimit, replaceAuthorBooks } from "../../../services/roleService";
import { checkTask } from "../../../services/task/taskService";
export default function (app: Application) {
new HandlerService(app, {});
return new AuthorsBookHandler(app);
}
export class AuthorsBookHandler {
constructor(private app: Application) {
}
public async starUp(msg: { bookId: number, subId: number, star: number, useItem: boolean }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const { bookId, subId, star, useItem } = msg;
let allAuthorBooks = await AuthorBookModel.findByRoleId(roleId);
let authorBookData = allAuthorBooks.find(authorBook => authorBook.bookId == bookId);
let starInData = authorBookData?.authors?.find(cur => cur.subId == subId)?.star??0;
if(star != starInData) return resResult(STATUS.ACCESS_BUSY);
let dicAuthorsBookSub = getDicAuthorBookSub(bookId, subId, star + 1);
if(!dicAuthorsBookSub) return resResult(STATUS.AUTHOR_BOOK_SUB_MAX);
// 是否解锁(进度解锁)
if(!checkAuthorBookLimit(allAuthorBooks, bookId)) return resResult(STATUS.AUTHOR_BOOK_LOCK);
// 英灵是否够
let check = new CheckMeterial(roleId);
let isEnough = await check.decreaseItemsContinue(dicAuthorsBookSub.spirits);
let useItemCnt = 0;
if(useItem) { // 使用英灵石代替
if(!isEnough) {
let notEnoughItems = check.getNotEnoughItems();
let replaceItems: RewardInter[] = [];
for(let [ id, count ] of notEnoughItems) {
let dicSpirit = gameData.spirit.get(id);
if(!dicSpirit) return resResult(STATUS.DIC_DATA_NOT_FOUND); // 应该是表填错,正常情况不可能出现
for(let item of dicSpirit.composeItem) {
replaceItems.push({ id: item.id, count: item.count * count });
useItemCnt += item.count * count;
}
}
isEnough = await check.decreaseItemsContinue(replaceItems);
}
}
if(!isEnough) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let consumes = check.getConsume();
let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.AUTHOR_BOOK_STAR_UP);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 升星
authorBookData = await AuthorBookModel.upStar(roleId, bookId, subId, star, dicAuthorsBookSub.value, gameData.authorBookSubs.get(bookId)||[]);
if(!authorBookData) {
// 防并发问题
await addItems(roleId, roleName, sid, consumes, ITEM_CHANGE_REASON.AUTHOR_BOOK_STAR_RETURN);
return resResult(STATUS.ACCESS_BUSY);
}
// 计算战力更新
await calculateCeWithRole(HERO_SYSTEM_TYPE.AUTHOR_BOOK_STAR, roleId, serverId, sid, {}, { authorBooks: replaceAuthorBooks(allAuthorBooks, authorBookData), bookId, subId });
let curAuthorBook = authorBookData.authors?.find(cur => cur.subId == subId);
let maxProgress = gameData.authorBookMaxProgress.get(bookId)??0;
await checkTask(serverId, roleId, sid, TASK_TYPE.FUND_AUTHOR, { authorProgress: await AuthorBookModel.findProgressByRoleId(roleId) });
return resResult(STATUS.SUCCESS, {
bookId,
subId,
star: curAuthorBook?.star??0,
progress: authorBookData.progress,
maxProgress,
useItemCnt
});
}
// 重置条目
public async resetAuthor(msg: { bookId: number, subId: number, star: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const { bookId, subId, star } = msg;
let allAuthorBooks = await AuthorBookModel.findByRoleId(roleId);
let authorBookData = allAuthorBooks.find(authorBook => authorBook.bookId == bookId);
if(!authorBookData) return resResult(STATUS.ACCESS_BUSY)
let starInData = authorBookData?.authors?.find(cur => cur.subId == subId)?.star??0;
if(star != starInData) return resResult(STATUS.ACCESS_BUSY);
let progress = 0, spirits: RewardInter[] = [];
for(let i = 1; i <= star; i++) {
let dicAuthorsBookSub = getDicAuthorBookSub(bookId, subId, i);
if(!dicAuthorsBookSub) return resResult(STATUS.DIC_DATA_NOT_FOUND);
progress += dicAuthorsBookSub.value;
spirits.push(...dicAuthorsBookSub.spirits);
}
// 重置诸子列传
authorBookData = await AuthorBookModel.resetSub(roleId, bookId, subId, star, -progress);
if(!authorBookData) return resResult(STATUS.ACCESS_BUSY);
let goods = await addItems(roleId, roleName, sid, combineItems(spirits), ITEM_CHANGE_REASON.AUTHOR_BOOK_SUB_RESET);
// 计算战力更新
await calculateCeWithRole(HERO_SYSTEM_TYPE.AUTHOR_BOOK_SUB_RESET, roleId, serverId, sid, {}, { authorBooks: replaceAuthorBooks(allAuthorBooks, authorBookData), bookId, subId });
let curAuthorBook = authorBookData.authors?.find(cur => cur.subId == subId);
let maxProgress = gameData.authorBookMaxProgress.get(bookId)??0;
await checkTask(serverId, roleId, sid, TASK_TYPE.FUND_AUTHOR, { authorProgress: await AuthorBookModel.findProgressByRoleId(roleId) });
return resResult(STATUS.SUCCESS, {
bookId,
subId,
star: curAuthorBook?.star??0,
progress: authorBookData.progress,
maxProgress,
goods
});
}
// 买英灵
public async buySpirit(msg: { id: number, count: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let roleName: string = session.get('roleName');
const { id, count } = msg;
let dicSpirit = gameData.spirit.get(id);
if(!dicSpirit) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let consumes = dicSpirit.composeItem.map(cur => ({ id: cur.id, count: cur.count * count }));
let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.BUY_SPIRIT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let reward = [{ id, count }];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.BUY_SPIRIT);
return resResult(STATUS.SUCCESS, { goods });
}
public async decomposeSpirit(msg: { spirits: { id: number, count: number }[] }, session: BackendSession) {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let roleName: string = session.get('roleName');
const { spirits = [] } = msg;
let rewards: RewardInter[] = [];
for(let { id, count } of spirits) {
let dicSpirit = gameData.spirit.get(id);
if(!dicSpirit) return resResult(STATUS.DIC_DATA_NOT_FOUND);
for(let item of dicSpirit.decomposeItem) {
rewards.push({ id: item.id, count: item.count * count });
}
}
let consumes = spirits;
let costResult = await handleCost(roleId, sid, consumes, ITEM_CHANGE_REASON.DECOMPOSE_SPIRIT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.DECOMPOSE_SPIRIT);
return resResult(STATUS.SUCCESS, { goods });
}
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -1,308 +1,309 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, CONSUME_TYPE, DEBUG_MAGIC_WORD, GIFT_GENERATE_TYPE, ITEM_CHANGE_REASON, GIFT_TYPE } from "../../../consts";
import { RewardInter } from "../../../pubUtils/interface";
import { getRandSingleEelm, resResult } from "../../../pubUtils/util";
import { addItems, handleCost } from "../../../services/role/rewardService";
import { RoleModel } from "../../../db/Role";
import { gameData } from "../../../pubUtils/data";
import { ITID } from "../../../consts/constModules/itemConst";
import { useGiftPackage } from "../../../services/activity/giftPackageService";
import { getAp, setAp, setApBuyTimes } from "../../../services/actionPointService";
import { ActionPointModel } from "../../../db/ActionPoint";
import { GiftCodeDetailModel } from "../../../db/GiftCodeDetail";
import { GiftCodeType, GiftCodeModel } from "../../../db/GiftCode";
import { nowSeconds } from "../../../pubUtils/timeUtil";
import { AP } from "../../../pubUtils/dicParam";
import { GiftPackageFloorModel } from "../../../db/GiftPackageFloor";
import { UserGiftCodeDetailModel } from "../../../db/UserGiftCodeDetail";
import { combineItems } from "../../../services/role/util";
export default function (app: Application) {
new HandlerService(app, {});
return new ItemHandler(app);
}
export class ItemHandler {
constructor(private app: Application) {
}
// 道具的使用
public async useItem(msg: { id: number, selected: Array<number>, count: number }, session: BackendSession) {
let { id, selected, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const guildCode = session.get('guildCode');
let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }], ITEM_CHANGE_REASON.USE_GIFT_PACKAGE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.GIFT_PACKAGE) {
return resResult(STATUS.NOT_CONSUME_GOODS);
}
let giftID = dicGoods.gift;
if (!giftID) {
return resResult(STATUS.NOT_GIFTPACKAGE);
}
let result = await useGiftPackage(roleId, roleName, sid, serverId, guildCode, giftID, selected, count);
return result;
}
// 获取礼包保底情况
public async getGiftPackageFloor(msg: { id: number }, session: BackendSession) {
let { id } = msg;
const roleId = session.get('roleId');
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.GIFT_PACKAGE) {
return resResult(STATUS.NOT_CONSUME_GOODS);
}
let giftID = dicGoods.gift;
if (!giftID) {
return resResult(STATUS.NOT_GIFTPACKAGE);
}
let giftPackageData = gameData.giftPackage.get(giftID);
if (!giftPackageData) {
return resResult(STATUS.NOT_GIFTPACKAGE);
}
let result = await GiftPackageFloorModel.findByGiftPackageId(roleId, giftPackageData.id, 'floors giftPackageId');
return resResult(STATUS.SUCCESS, result);
}
// 使用体力道具
public async useApItem(msg: { id: number, count: number }, session: BackendSession) {
let { id, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const ip = session.get('ip');
const serverId = session.get('serverId');
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.DIC_DATA_NOT_FOUND);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.AP) {
return resResult(STATUS.ROLE_METERIAL_ERROR);
}
let role = await RoleModel.findByRoleId(roleId, 'lv');
let { ap, isOver } = await getAp(roleId, ip, role.lv);
if (isOver) return resResult(STATUS.AP_IS_FULL);
if(ap + dicGoods.value * count > AP.AP_SAVE_MAX) {
return resResult(STATUS.AP_IS_FULL);
}
let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }], ITEM_CHANGE_REASON.USE_MEAT);
if (!consumeResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let apJson = await setAp(serverId, roleId, ip, role.lv, dicGoods.value * count, sid, ITEM_CHANGE_REASON.USE_MEAT);
return resResult(STATUS.SUCCESS, {
apJson
});
}
// 购买体力道具
public async buyApItem(msg: { id: number, count: number }, session: BackendSession) {
let { id, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const ip: string = session.get('ip');
if (count <= 0) return resResult(STATUS.WRONG_PARMS);
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.DIC_DATA_NOT_FOUND);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.AP) {
return resResult(STATUS.ROLE_METERIAL_ERROR);
}
let role = await RoleModel.findByRoleId(roleId, 'lv');
let { buyTimes = 0 } = await getAp(roleId, ip, role.lv);
if (buyTimes + count > gameData.apMaxBuyTimes.max) return resResult(STATUS.AP_BUY_TIMES_LACK);
let cost: RewardInter[] = [];
for (let i = 0; i < count; i++) {
let curCost = gameData.apBuy.get(++buyTimes);
if (curCost) cost = cost.concat(curCost);
}
let consumeResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.BUY_MEAT);
if (!consumeResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let goods = await addItems(roleId, roleName, sid, [{ id, count }], ITEM_CHANGE_REASON.BUY_MEAT);
let apJson = await setApBuyTimes(roleId, ip, role.lv, sid, count);
return resResult(STATUS.SUCCESS, {
goods, apJson
});
}
// 兑换礼包码
public async useGiftCode(msg: { code: string }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const channel: string = session.get('channel');
const { code } = msg;
let giftCodeDetail = await GiftCodeDetailModel.findByCode(code);
if(!giftCodeDetail) {
return resResult(STATUS.GIFT_CODE_NOT_FOUND);
}
let giftCode = await GiftCodeModel.findByGiftId(giftCodeDetail.giftId);
if(!giftCode) {
return resResult(STATUS.GIFT_CODE_NOT_FOUND);
}
if(giftCode.type != GIFT_TYPE.GAME && giftCode.type != GIFT_TYPE.DEFAULT) return resResult(STATUS.GIFT_TYPE_ERR);
if(giftCode.generateType == GIFT_GENERATE_TYPE.ONE_TO_ONE) { // 一人一条,单条不能被多人使用
if(giftCodeDetail.usedNum > 0) return resResult(STATUS.GIFT_CODE_USED_NUM_MAX);
}
if(!giftCode.isEnable) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
if (giftCode.beginTime > nowSeconds()) return resResult(STATUS.GIFT_CODE_NOT_START);
if (giftCode.endTime < nowSeconds()) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
if(giftCode.channel.indexOf('all') == -1 && giftCode.channel.indexOf(channel) == -1) {
return resResult(STATUS.GIFT_CODE_CHANNEL_ERR);
}
let checkHasUse = await GiftCodeDetailModel.checkHasUsed(roleId, giftCodeDetail.giftId)
if(checkHasUse) {
return resResult(STATUS.YOU_HAVE_USED_THIS_CODE);
}
let checkHasUse2 = await UserGiftCodeDetailModel.checkHasUsed(roleId, giftCodeDetail.giftId)
if(checkHasUse2) {
return resResult(STATUS.YOU_HAVE_USED_THIS_CODE);
}
await UserGiftCodeDetailModel.record(roleId, roleName, serverId, giftCodeDetail.giftId, code);
await GiftCodeDetailModel.increaseUsedNum(code);
await GiftCodeModel.increaseUsedNum(giftCode.id);
let goods = await addItems(roleId, roleName, sid, giftCode.goods, ITEM_CHANGE_REASON.USE_GIFT_CODE);
return resResult(STATUS.SUCCESS, { goods });
}
public async getAp(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
public async getApByLv(msg: { lv: number }, session: BackendSession) {
const { lv } = msg;
let roleId = session.get('roleId');
let ip = session.get('ip');
let { lvRecords = [] } = await ActionPointModel.getAp(roleId);
let lvRecord = lvRecords.find(cur => cur.lv == lv);
let ap = 0, apBefore = 0;
if(!lvRecord) {
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await getAp(roleId, ip, role.lv);
ap = apJson.ap;
apBefore = apJson.ap;
} else {
({ ap, apBefore } = lvRecord);
}
return resResult(STATUS.SUCCESS, { ap, apBefore });
}
public async exchangeSpirit(msg: { origin: { id: number, count: number }[] }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { origin = [] } = msg;
let originQuality = 0, allCount = 0;
for (let { id, count } of origin) {
let dicGoods = gameData.goods.get(id);
let dicItid = ITID.get(dicGoods?.itid);
if (!dicItid || dicItid.type != CONSUME_TYPE.SPIRIT_STONE)
return resResult(STATUS.ACCESS_BUSY);
if (originQuality == 0) originQuality = dicGoods.quality;
if (dicGoods.quality != originQuality) return resResult(STATUS.SPIRIT_QUALITY_NOT_SAME);
allCount += count;
}
let dicSpiritCompose = gameData.spiritCompose.get(originQuality);
if (!dicSpiritCompose) return resResult(STATUS.SPIRIT_QUALITY_NOT_FOUND);
let { goalQuality, materialNum } = dicSpiritCompose;
let num = Math.floor(allCount/materialNum);
if (allCount > num * materialNum) return resResult(STATUS.SPIRIT_QUALITY_NOT_INTERGER);
let pool = gameData.spiritByQuality.get(goalQuality);
if (!pool || pool.length <= 0) return resResult(STATUS.TARGET_SPIRIT_QUALITY_NOT_FOUND);
let costResult = await handleCost(roleId, sid, origin, ITEM_CHANGE_REASON.EXCHANGE_SPIRIT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewards: RewardInter[] = [];
for (let i = 0; i < num; i++) {
let gid = getRandSingleEelm(pool);
rewards.push({ id: gid, count: 1 });
}
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.EXCHANGE_SPIRIT);
return resResult(STATUS.SUCCESS, { goods });
}
public async debugIncAp(msg: { magicWord: string, ap: number }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const roleId = session.get('roleId');
const sid = session.get('sid');
const ip = session.get('ip');
const serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await setAp(serverId, roleId, ip, role.lv, msg.ap, sid, ITEM_CHANGE_REASON.DEBUG);
if (!apJson) return resResult(STATUS.BATTLE_ACTION_POINT_LACK)
return resResult(STATUS.SUCCESS, { apJson });
}
public async debugResetBuyTimes(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
await ActionPointModel.resetBuyTimes(roleId);
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { STATUS, CONSUME_TYPE, DEBUG_MAGIC_WORD, GIFT_GENERATE_TYPE, ITEM_CHANGE_REASON, GIFT_TYPE } from "../../../consts";
import { RewardInter } from "@pubUtils/interface";
import { getRandSingleEelm, resResult } from "@pubUtils/util";
import { addItems, handleCost } from "../../../services/role/rewardService";
import { RoleModel } from "@db/Role";
import { gameData } from "@pubUtils/data";
import { ITID } from "@consts/constModules/itemConst";
import { useGiftPackage } from "../../../services/activity/giftPackageService";
import { getAp, setAp, setApBuyTimes } from "../../../services/actionPointService";
import { ActionPointModel } from "@db/ActionPoint";
import { GiftCodeDetailModel } from "@db/GiftCodeDetail";
import { GiftCodeType, GiftCodeModel } from "@db/GiftCode";
import { nowSeconds } from "@pubUtils/timeUtil";
import { AP } from "@pubUtils/dicParam";
import { GiftPackageFloorModel } from "@db/GiftPackageFloor";
import { UserGiftCodeDetailModel } from "@db/UserGiftCodeDetail";
import { combineItems } from "../../../services/role/util";
export default function (app: Application) {
new HandlerService(app, {});
return new ItemHandler(app);
}
export class ItemHandler {
constructor(private app: Application) {
}
// 道具的使用
public async useItem(msg: { id: number, selected: Array<number>, count: number }, session: BackendSession) {
let { id, selected, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const guildCode = session.get('guildCode');
let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }], ITEM_CHANGE_REASON.USE_GIFT_PACKAGE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.GIFT_PACKAGE) {
return resResult(STATUS.NOT_CONSUME_GOODS);
}
let giftID = dicGoods.gift;
if (!giftID) {
return resResult(STATUS.NOT_GIFTPACKAGE);
}
let result = await useGiftPackage(roleId, roleName, sid, serverId, guildCode, giftID, selected, count);
return result;
}
// 获取礼包保底情况
public async getGiftPackageFloor(msg: { id: number }, session: BackendSession) {
let { id } = msg;
const roleId = session.get('roleId');
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.GIFT_PACKAGE) {
return resResult(STATUS.NOT_CONSUME_GOODS);
}
let giftID = dicGoods.gift;
if (!giftID) {
return resResult(STATUS.NOT_GIFTPACKAGE);
}
let giftPackageData = gameData.giftPackage.get(giftID);
if (!giftPackageData) {
return resResult(STATUS.NOT_GIFTPACKAGE);
}
let result = await GiftPackageFloorModel.findByGiftPackageId(roleId, giftPackageData.id, 'floors giftPackageId');
return resResult(STATUS.SUCCESS, result);
}
// 使用体力道具
public async useApItem(msg: { id: number, count: number }, session: BackendSession) {
let { id, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const ip = session.get('ip');
const serverId = session.get('serverId');
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.DIC_DATA_NOT_FOUND);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.AP) {
return resResult(STATUS.ROLE_METERIAL_ERROR);
}
let role = await RoleModel.findByRoleId(roleId, 'lv');
let { ap, isOver } = await getAp(roleId, ip, role.lv);
if (isOver) return resResult(STATUS.AP_IS_FULL);
if(ap + dicGoods.value * count > AP.AP_SAVE_MAX) {
return resResult(STATUS.AP_IS_FULL);
}
let consumeResult = await handleCost(roleId, sid, [{ id: id, count: count }], ITEM_CHANGE_REASON.USE_MEAT);
if (!consumeResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let apJson = await setAp(serverId, roleId, ip, role.lv, dicGoods.value * count, sid, ITEM_CHANGE_REASON.USE_MEAT);
return resResult(STATUS.SUCCESS, {
apJson
});
}
// 购买体力道具
public async buyApItem(msg: { id: number, count: number }, session: BackendSession) {
let { id, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const ip: string = session.get('ip');
if (count <= 0) return resResult(STATUS.WRONG_PARMS);
let dicGoods = gameData.goods.get(id);
if (!dicGoods) {
return resResult(STATUS.DIC_DATA_NOT_FOUND);
}
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.AP) {
return resResult(STATUS.ROLE_METERIAL_ERROR);
}
let role = await RoleModel.findByRoleId(roleId, 'lv');
let { buyTimes = 0 } = await getAp(roleId, ip, role.lv);
if (buyTimes + count > gameData.apMaxBuyTimes.max) return resResult(STATUS.AP_BUY_TIMES_LACK);
let cost: RewardInter[] = [];
for (let i = 0; i < count; i++) {
let curCost = gameData.apBuy.get(++buyTimes);
if (curCost) cost = cost.concat(curCost);
}
let consumeResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.BUY_MEAT);
if (!consumeResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let goods = await addItems(roleId, roleName, sid, [{ id, count }], ITEM_CHANGE_REASON.BUY_MEAT);
let apJson = await setApBuyTimes(roleId, ip, role.lv, sid, count);
return resResult(STATUS.SUCCESS, {
goods, apJson
});
}
// 兑换礼包码
public async useGiftCode(msg: { code: string }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const channel: string = session.get('channel');
const { code } = msg;
let giftCodeDetail = await GiftCodeDetailModel.findByCode(code);
if(!giftCodeDetail) {
return resResult(STATUS.GIFT_CODE_NOT_FOUND);
}
let giftCode = await GiftCodeModel.findByGiftId(giftCodeDetail.giftId);
if(!giftCode) {
return resResult(STATUS.GIFT_CODE_NOT_FOUND);
}
if(giftCode.type != GIFT_TYPE.GAME && giftCode.type != GIFT_TYPE.DEFAULT) return resResult(STATUS.GIFT_TYPE_ERR);
if(giftCode.generateType == GIFT_GENERATE_TYPE.ONE_TO_ONE) { // 一人一条,单条不能被多人使用
if(giftCodeDetail.usedNum > 0) return resResult(STATUS.GIFT_CODE_USED_NUM_MAX);
}
if(!giftCode.isEnable) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
if (giftCode.beginTime > nowSeconds()) return resResult(STATUS.GIFT_CODE_NOT_START);
if (giftCode.endTime < nowSeconds()) return resResult(STATUS.GIFT_CODE_HAS_EXPIRED);
if(giftCode.channel.indexOf('all') == -1 && giftCode.channel.indexOf(channel) == -1) {
return resResult(STATUS.GIFT_CODE_CHANNEL_ERR);
}
let checkHasUse = await GiftCodeDetailModel.checkHasUsed(roleId, giftCodeDetail.giftId)
if(checkHasUse) {
return resResult(STATUS.YOU_HAVE_USED_THIS_CODE);
}
let checkHasUse2 = await UserGiftCodeDetailModel.checkHasUsed(roleId, giftCodeDetail.giftId)
if(checkHasUse2) {
return resResult(STATUS.YOU_HAVE_USED_THIS_CODE);
}
await UserGiftCodeDetailModel.record(roleId, roleName, serverId, giftCodeDetail.giftId, code);
await GiftCodeDetailModel.increaseUsedNum(code);
await GiftCodeModel.increaseUsedNum(giftCode.id);
let goods = await addItems(roleId, roleName, sid, giftCode.goods, ITEM_CHANGE_REASON.USE_GIFT_CODE);
return resResult(STATUS.SUCCESS, { goods });
}
public async getAp(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
public async getApByLv(msg: { lv: number }, session: BackendSession) {
const { lv } = msg;
let roleId = session.get('roleId');
let ip = session.get('ip');
let { lvRecords = [] } = await ActionPointModel.getAp(roleId);
let lvRecord = lvRecords.find(cur => cur.lv == lv);
let ap = 0, apBefore = 0;
if(!lvRecord) {
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await getAp(roleId, ip, role.lv);
ap = apJson.ap;
apBefore = apJson.ap;
} else {
({ ap, apBefore } = lvRecord);
}
return resResult(STATUS.SUCCESS, { ap, apBefore });
}
public async exchangeSpirit(msg: { origin: { id: number, count: number }[] }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { origin = [] } = msg;
let originQuality = 0, allCount = 0;
for (let { id, count } of origin) {
let dicGoods = gameData.goods.get(id);
let dicItid = ITID.get(dicGoods?.itid);
if (!dicItid || dicItid.type != CONSUME_TYPE.SPIRIT_STONE)
return resResult(STATUS.ACCESS_BUSY);
if (originQuality == 0) originQuality = dicGoods.quality;
if (dicGoods.quality != originQuality) return resResult(STATUS.SPIRIT_QUALITY_NOT_SAME);
allCount += count;
}
let dicSpiritCompose = gameData.spiritCompose.get(originQuality);
if (!dicSpiritCompose) return resResult(STATUS.SPIRIT_QUALITY_NOT_FOUND);
let { goalQuality, materialNum } = dicSpiritCompose;
let num = Math.floor(allCount/materialNum);
if (allCount > num * materialNum) return resResult(STATUS.SPIRIT_QUALITY_NOT_INTERGER);
let pool = gameData.spiritByQuality.get(goalQuality);
if (!pool || pool.length <= 0) return resResult(STATUS.TARGET_SPIRIT_QUALITY_NOT_FOUND);
let costResult = await handleCost(roleId, sid, origin, ITEM_CHANGE_REASON.EXCHANGE_SPIRIT);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewards: RewardInter[] = [];
for (let i = 0; i < num; i++) {
let gid = getRandSingleEelm(pool);
rewards.push({ id: gid, count: 1 });
}
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.EXCHANGE_SPIRIT);
return resResult(STATUS.SUCCESS, { goods });
}
public async debugIncAp(msg: { magicWord: string, ap: number }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
const roleId = session.get('roleId');
const sid = session.get('sid');
const ip = session.get('ip');
const serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'lv');
let apJson = await setAp(serverId, roleId, ip, role.lv, msg.ap, sid, ITEM_CHANGE_REASON.DEBUG);
if (!apJson) return resResult(STATUS.BATTLE_ACTION_POINT_LACK)
return resResult(STATUS.SUCCESS, { apJson });
}
public async debugResetBuyTimes(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let roleId = session.get('roleId');
let ip = session.get('ip');
let role = await RoleModel.findByRoleId(roleId, 'lv');
await ActionPointModel.resetBuyTimes(roleId);
let apJson = await getAp(roleId, ip, role.lv);
return resResult(STATUS.SUCCESS, { apJson });
}
}
@@ -1,188 +1,189 @@
import {Application, BackendSession, ChannelService} from 'pinus';
import { MailModel, MailType } from '../../../db/Mail';
import { GroupMailModel, GroupMailType } from '../../../db/GroupMail';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { MAIL_STATUS, GM_MAIL_TYPE } from '../../../consts/constModules/mailConst';
import { addItems } from '../../../services/role/rewardService';
import { checkMailGoods, getMails } from '../../../services/mailService';
import { ServerMailModel, ServerMailType } from '../../../db/ServerMail';
import { MailParam } from '../../../domain/roleField/mail';
import { ItemInter, RewardInter } from '../../../pubUtils/interface';
import { RoleModel } from '../../../db/Role';
import { gameData } from '../../../pubUtils/data';
import { ITEM_CHANGE_REASON, ITID, RECEIVE_MAIL_TYPE } from '../../../consts';
import { BAG } from '../../../pubUtils/dicParam';
import { saveMailLog } from '../../../pubUtils/logUtil';
export default function(app: Application) {
return new MailHandler(app);
}
export class MailHandler {
constructor(private app: Application) {
}
public async getMails(msg:{}, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const list = await getMails(roleId, serverId);
return resResult(STATUS.SUCCESS, { list });
}
public async refrshMails(msg:{}) {
}
public async readMail(msg: { id: string, mailType: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { id, mailType } = msg;
let mails = [];
if (mailType == GM_MAIL_TYPE.SINGLE) {
let mail = await MailModel.getMailById(id);
if(mail && mail.status == MAIL_STATUS.CREATE) {
mail = await MailModel.updateStatusWithCondition(id, MAIL_STATUS.READ);
mails.push({ id, status: MAIL_STATUS.READ, mailType });
}
} else if (mailType == GM_MAIL_TYPE.GROUP) {
let mail = await GroupMailModel.getMailById(id);
if(mail) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(myStatus && myStatus.status == MAIL_STATUS.CREATE) {
mail = await GroupMailModel.updateStatusWithCondition(id, roleId, MAIL_STATUS.READ);
mails.push({ id, status: MAIL_STATUS.READ, mailType });
}
}
} else if (mailType == GM_MAIL_TYPE.SERVER) {
let mail = await ServerMailModel.getMailById(id);
if(mail) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(!myStatus || myStatus.status == MAIL_STATUS.CREATE) {
mail = await ServerMailModel.updateStatusWithCondition(id, roleId, MAIL_STATUS.READ);
mails.push({ id, status: MAIL_STATUS.READ, mailType });
}
}
}
// if (!mail)
// return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails });
}
public async delMails(msg: { id: string, mailType: number, type: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let serverId: number = session.get('serverId');
let { id, type, mailType } = msg;
if (type == 1) {//单个删除
let mail: MailType|GroupMailType|ServerMailType;
if (mailType == GM_MAIL_TYPE.SINGLE) {
mail = await MailModel.delMailById(id);
} else if (mailType == GM_MAIL_TYPE.GROUP) {
mail = await GroupMailModel.delMailById(id, roleId);
} else if (mailType == GM_MAIL_TYPE.SERVER) {
mail = await ServerMailModel.delMailById(id, roleId);
}
if (!mail) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails: [{ id: mail._id, mailType, status: MAIL_STATUS.DELETE}] });
} else {//一键删除
let singlemails = await MailModel.delMailsByRoleId(roleId);
let groupMails = await GroupMailModel.delMailsByRoleId(roleId);
let servermails = await ServerMailModel.delMailsByRoleId(roleId, serverId);
let mails: { id: string, mailType: GM_MAIL_TYPE, status: MAIL_STATUS }[] = [];
for(let mail of singlemails) {
mails.push({ id: mail._id, mailType: GM_MAIL_TYPE.SINGLE, status: MAIL_STATUS.DELETE });
}
for(let mail of groupMails) {
mails.push({ id: mail._id, mailType: GM_MAIL_TYPE.GROUP, status: MAIL_STATUS.DELETE });
}
for(let mail of servermails) {
mails.push({ id: mail._id, mailType: GM_MAIL_TYPE.SERVER, status: MAIL_STATUS.DELETE });
}
return resResult(STATUS.SUCCESS, { mails });
}
}
public async getMailRewards(msg: { id: string, mailType: number, type: RECEIVE_MAIL_TYPE }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { id, type, mailType } = msg;
let { jewelCount } = await RoleModel.findByRoleId(roleId, 'jewelCount');
let originMails: {mailType: GM_MAIL_TYPE, mail: MailType|GroupMailType|ServerMailType}[] = []
if (type == RECEIVE_MAIL_TYPE.SINGLE) {//单个领取
let mail: MailType|GroupMailType|ServerMailType;
if (mailType == GM_MAIL_TYPE.SINGLE) {
mail = await MailModel.getMailById(id);
if (!mail) return resResult(STATUS.WRONG_PARMS);
if(mail.status != MAIL_STATUS.READ && mail.status != MAIL_STATUS.CREATE) return resResult(STATUS.WRONG_PARMS);
} else if (mailType == GM_MAIL_TYPE.GROUP) {
mail = await GroupMailModel.getMailById(id);
if (!mail) return resResult(STATUS.WRONG_PARMS);
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(!myStatus) return resResult(STATUS.WRONG_PARMS);
if(myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) return resResult(STATUS.WRONG_PARMS);
} else if (mailType == GM_MAIL_TYPE.SERVER) {
mail = await ServerMailModel.getMailById(id);
if (!mail) return resResult(STATUS.WRONG_PARMS);
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(myStatus && myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) return resResult(STATUS.WRONG_PARMS);
}
originMails.push({ mailType, mail });
} else {//一键领取
let singlemails = await MailModel.findRewardsMails(roleId);
for(let mail of singlemails) {
if(mail.status != MAIL_STATUS.READ && mail.status != MAIL_STATUS.CREATE) continue;
originMails.push({ mailType: GM_MAIL_TYPE.SINGLE, mail });
}
let groupMails = await GroupMailModel.findRewardsMails(roleId);
for(let mail of groupMails) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(!myStatus) continue;
if(myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) continue;
originMails.push({ mailType: GM_MAIL_TYPE.GROUP, mail })
}
let servermails = await ServerMailModel.findRewardsMails(serverId, roleId);
for(let mail of servermails) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(myStatus && myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) continue;
originMails.push({ mailType: GM_MAIL_TYPE.SERVER, mail })
}
}
let mailGoods: ItemInter[] = [], mails: MailParam[] = [];
for(let { mail, mailType } of originMails) {
let { isEquipOver, jewelCount: newEquipCount } = checkMailGoods(mail, jewelCount);
if(isEquipOver) {
if(type == RECEIVE_MAIL_TYPE.SINGLE) {
return resResult(STATUS.EQUIP_IS_OVER);
} else {
continue; // 如果有装备数量超过,那么一键领取这条邮件就不领了
}
}
jewelCount = newEquipCount;
if(mailType == GM_MAIL_TYPE.SINGLE) {
mail = await MailModel.updateStatusWithCondition(mail._id, MAIL_STATUS.RECEIVED);
} else if (mailType == GM_MAIL_TYPE.GROUP) {
mail = await GroupMailModel.updateStatusWithCondition(mail._id, roleId, MAIL_STATUS.RECEIVED);
} else if (mailType == GM_MAIL_TYPE.SERVER) {
mail = await ServerMailModel.updateStatusWithCondition(mail._id, roleId, MAIL_STATUS.RECEIVED, <ServerMailType>mail);
}
if(!mail) return resResult(STATUS.MAIL_HAS_RECEIVE);
let mailObj = new MailParam(mailType, mail, roleId);
mailGoods.push(...mailObj.goods);
mails.push(mailObj);
}
let resGoods = await addItems(roleId, roleName, sid, mailGoods, ITEM_CHANGE_REASON.MAIL);
saveMailLog(session, mails);
return resResult(STATUS.SUCCESS, { mails, goods: resGoods });
}
}
import {Application, BackendSession, ChannelService} from 'pinus';
import { MailModel, MailType } from '@db/Mail';
import { GroupMailModel, GroupMailType } from '@db/GroupMail';
import { resResult } from '@pubUtils/util';
import { STATUS } from '@consts/statusCode';
import { MAIL_STATUS, GM_MAIL_TYPE } from '@consts/constModules/mailConst';
import { addItems } from '../../../services/role/rewardService';
import { checkMailGoods, getMails } from '../../../services/mailService';
import { ServerMailModel, ServerMailType } from '@db/ServerMail';
import { MailParam } from '@domain/roleField/mail';
import { ItemInter, RewardInter } from '@pubUtils/interface';
import { RoleModel } from '@db/Role';
import { gameData } from '@pubUtils/data';
import { ITEM_CHANGE_REASON, ITID, RECEIVE_MAIL_TYPE } from '../../../consts';
import { BAG } from '@pubUtils/dicParam';
import { saveMailLog } from '@pubUtils/logUtil';
export default function(app: Application) {
return new MailHandler(app);
}
export class MailHandler {
constructor(private app: Application) {
}
public async getMails(msg:{}, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const list = await getMails(roleId, serverId);
return resResult(STATUS.SUCCESS, { list });
}
public async refrshMails(msg:{}) {
}
public async readMail(msg: { id: string, mailType: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let { id, mailType } = msg;
let mails = [];
if (mailType == GM_MAIL_TYPE.SINGLE) {
let mail = await MailModel.getMailById(id);
if(mail && mail.status == MAIL_STATUS.CREATE) {
mail = await MailModel.updateStatusWithCondition(id, MAIL_STATUS.READ);
mails.push({ id, status: MAIL_STATUS.READ, mailType });
}
} else if (mailType == GM_MAIL_TYPE.GROUP) {
let mail = await GroupMailModel.getMailById(id);
if(mail) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(myStatus && myStatus.status == MAIL_STATUS.CREATE) {
mail = await GroupMailModel.updateStatusWithCondition(id, roleId, MAIL_STATUS.READ);
mails.push({ id, status: MAIL_STATUS.READ, mailType });
}
}
} else if (mailType == GM_MAIL_TYPE.SERVER) {
let mail = await ServerMailModel.getMailById(id);
if(mail) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(!myStatus || myStatus.status == MAIL_STATUS.CREATE) {
mail = await ServerMailModel.updateStatusWithCondition(id, roleId, MAIL_STATUS.READ);
mails.push({ id, status: MAIL_STATUS.READ, mailType });
}
}
}
// if (!mail)
// return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails });
}
public async delMails(msg: { id: string, mailType: number, type: number }, session: BackendSession) {
let roleId: string = session.get('roleId');
let serverId: number = session.get('serverId');
let { id, type, mailType } = msg;
if (type == 1) {//单个删除
let mail: MailType|GroupMailType|ServerMailType;
if (mailType == GM_MAIL_TYPE.SINGLE) {
mail = await MailModel.delMailById(id);
} else if (mailType == GM_MAIL_TYPE.GROUP) {
mail = await GroupMailModel.delMailById(id, roleId);
} else if (mailType == GM_MAIL_TYPE.SERVER) {
mail = await ServerMailModel.delMailById(id, roleId);
}
if (!mail) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, { mails: [{ id: mail._id, mailType, status: MAIL_STATUS.DELETE}] });
} else {//一键删除
let singlemails = await MailModel.delMailsByRoleId(roleId);
let groupMails = await GroupMailModel.delMailsByRoleId(roleId);
let servermails = await ServerMailModel.delMailsByRoleId(roleId, serverId);
let mails: { id: string, mailType: GM_MAIL_TYPE, status: MAIL_STATUS }[] = [];
for(let mail of singlemails) {
mails.push({ id: mail._id, mailType: GM_MAIL_TYPE.SINGLE, status: MAIL_STATUS.DELETE });
}
for(let mail of groupMails) {
mails.push({ id: mail._id, mailType: GM_MAIL_TYPE.GROUP, status: MAIL_STATUS.DELETE });
}
for(let mail of servermails) {
mails.push({ id: mail._id, mailType: GM_MAIL_TYPE.SERVER, status: MAIL_STATUS.DELETE });
}
return resResult(STATUS.SUCCESS, { mails });
}
}
public async getMailRewards(msg: { id: string, mailType: number, type: RECEIVE_MAIL_TYPE }, session: BackendSession) {
let roleId: string = session.get('roleId');
let roleName: string = session.get('roleName');
let sid: string = session.get('sid');
let serverId: number = session.get('serverId');
let { id, type, mailType } = msg;
let { jewelCount } = await RoleModel.findByRoleId(roleId, 'jewelCount');
let originMails: {mailType: GM_MAIL_TYPE, mail: MailType|GroupMailType|ServerMailType}[] = []
if (type == RECEIVE_MAIL_TYPE.SINGLE) {//单个领取
let mail: MailType|GroupMailType|ServerMailType;
if (mailType == GM_MAIL_TYPE.SINGLE) {
mail = await MailModel.getMailById(id);
if (!mail) return resResult(STATUS.WRONG_PARMS);
if(mail.status != MAIL_STATUS.READ && mail.status != MAIL_STATUS.CREATE) return resResult(STATUS.WRONG_PARMS);
} else if (mailType == GM_MAIL_TYPE.GROUP) {
mail = await GroupMailModel.getMailById(id);
if (!mail) return resResult(STATUS.WRONG_PARMS);
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(!myStatus) return resResult(STATUS.WRONG_PARMS);
if(myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) return resResult(STATUS.WRONG_PARMS);
} else if (mailType == GM_MAIL_TYPE.SERVER) {
mail = await ServerMailModel.getMailById(id);
if (!mail) return resResult(STATUS.WRONG_PARMS);
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(myStatus && myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) return resResult(STATUS.WRONG_PARMS);
}
originMails.push({ mailType, mail });
} else {//一键领取
let singlemails = await MailModel.findRewardsMails(roleId);
for(let mail of singlemails) {
if(mail.status != MAIL_STATUS.READ && mail.status != MAIL_STATUS.CREATE) continue;
originMails.push({ mailType: GM_MAIL_TYPE.SINGLE, mail });
}
let groupMails = await GroupMailModel.findRewardsMails(roleId);
for(let mail of groupMails) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(!myStatus) continue;
if(myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) continue;
originMails.push({ mailType: GM_MAIL_TYPE.GROUP, mail })
}
let servermails = await ServerMailModel.findRewardsMails(serverId, roleId);
for(let mail of servermails) {
let myStatus = mail.roleStatus.find(cur => cur.roleId == roleId);
if(myStatus && myStatus.status != MAIL_STATUS.READ && myStatus.status != MAIL_STATUS.CREATE) continue;
originMails.push({ mailType: GM_MAIL_TYPE.SERVER, mail })
}
}
let mailGoods: ItemInter[] = [], mails: MailParam[] = [];
for(let { mail, mailType } of originMails) {
let { isEquipOver, jewelCount: newEquipCount } = checkMailGoods(mail, jewelCount);
if(isEquipOver) {
if(type == RECEIVE_MAIL_TYPE.SINGLE) {
return resResult(STATUS.EQUIP_IS_OVER);
} else {
continue; // 如果有装备数量超过,那么一键领取这条邮件就不领了
}
}
jewelCount = newEquipCount;
if(mailType == GM_MAIL_TYPE.SINGLE) {
mail = await MailModel.updateStatusWithCondition(mail._id, MAIL_STATUS.RECEIVED);
} else if (mailType == GM_MAIL_TYPE.GROUP) {
mail = await GroupMailModel.updateStatusWithCondition(mail._id, roleId, MAIL_STATUS.RECEIVED);
} else if (mailType == GM_MAIL_TYPE.SERVER) {
mail = await ServerMailModel.updateStatusWithCondition(mail._id, roleId, MAIL_STATUS.RECEIVED, <ServerMailType>mail);
}
if(!mail) return resResult(STATUS.MAIL_HAS_RECEIVE);
let mailObj = new MailParam(mailType, mail, roleId);
mailGoods.push(...mailObj.goods);
mails.push(mailObj);
}
let resGoods = await addItems(roleId, roleName, sid, mailGoods, ITEM_CHANGE_REASON.MAIL);
saveMailLog(session, mails);
return resResult(STATUS.SUCCESS, { mails, goods: resGoods });
}
}
@@ -1,154 +1,155 @@
import { Application, BackendSession, HandlerService, pinus, } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { STATUS, getRedisKeyByRankType, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS, ITEM_CHANGE_REASON, REDIS_KEY } from "../../../consts";
import {RoleModel} from "../../../db/Role";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildModel } from "../../../db/Guild";
import { Rank, getGeneralRank, getRankFirstReward, getRankInHandler } from "../../../services/rankService";
import { gameData } from "../../../pubUtils/data";
import { addItems } from "../../../services/role/rewardService";
import { RewardInter } from "../../../pubUtils/interface";
import { RankFirstType } from "../../../db/RankFirst";
export default function (app: Application) {
new HandlerService(app, {});
return new RoleHandler(app);
}
export class RoleHandler {
constructor(private app: Application) {
}
async getGeneralRank(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
if (!role) return resResult(STATUS.WRONG_PARMS);
let ranks = await getGeneralRank(role, serverId);
return resResult(STATUS.SUCCESS, { ranks });
}
async getRankReward(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
if (!role) return resResult(STATUS.WRONG_PARMS);
let ranks = await getRankFirstReward(role, serverId);
return resResult(STATUS.SUCCESS, { ranks });
}
async getRank(msg: { type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let guildCode = session.get('guildCode');
let { type } = msg;
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId }, session);
return resResult(STATUS.SUCCESS, { type, ...result });
}
// 查看活跃排行榜
async getGuildRank(msg: { type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId')
let { type } = msg;
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId });
const myUserGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
let { ranks, myRank } = await r.getRankListWithMyRank({ guildCode: myUserGuild?.guildCode || '' });
if (!myRank) {
let guild = await GuildModel.findByCode(myUserGuild.guildCode, serverId, GUILD_SELECT.RANK);
if (type == RANK_TYPE.GUILD_LV) {
myRank = await r.generMyRankWithGuild(guild.code, guild.lv, guild.lvUpdateTime, guild);
} else if (type == RANK_TYPE.GUILD_ACTIVE) {
myRank = await r.generMyRankWithGuild(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
}
}
return resResult(STATUS.SUCCESS, { type, ranks, myRank });
}
// 查看单个武将排行榜
async getHeroRank(msg: { type: number, hid: number }, session: BackendSession) {
let serverId = session.get('serverId')
let { type, hid } = msg;
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId, hid });
let ranks = await r.getRankByRange(200, 0);
return resResult(STATUS.SUCCESS, {
type, hid, ranks
});
}
async receiveReward(msg: { type: number, id: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { type, id } = msg;
let ids: number[] = [];
if (id == 0) {
gameData.generalRankReward.forEach((dic, id) => {
if (dic.rankId == type) {
ids.push(id);
}
});
} else {
ids.push(id);
}
let rewards: RewardInter[] = [];
let canReceiveId: number[] = [];
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
for (let id of ids) {
let dicReward = gameData.generalRankReward.get(id);
if (!dicReward || dicReward.rankId != type) continue;
let rankFirst: RankFirstType = pinus.app.get('rankFirstRewards').get(serverId)?.get(id);
// console.log('*******', pinus.app.get('rankFirstRewards'), rankFirst);
if (!rankFirst) continue;
if (role.rankReceived.includes(id)) continue;
let reward = dicReward.reward;
rewards = rewards.concat(reward);
canReceiveId.push(id);
}
role = await RoleModel.receiveRankReward(roleId, canReceiveId);
if (canReceiveId.length <= 0) return resResult(STATUS.REWARD_CONDITION_NOT_REACH);
let rewardStatus = canReceiveId.map(id => {
return { id, type, status: RANK_FIRST_REWARD_STATUS.RECEIVED }
})
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.RANK_REWARD);
return resResult(STATUS.SUCCESS, {
rewards: rewardStatus,
goods
})
}
}
import { Application, BackendSession, HandlerService, pinus, } from "pinus";
import { resResult } from "@pubUtils/util";
import { STATUS, getRedisKeyByRankType, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS, ITEM_CHANGE_REASON, REDIS_KEY } from "../../../consts";
import {RoleModel} from "@db/Role";
import { UserGuildModel } from "@db/UserGuild";
import { GuildModel } from "@db/Guild";
import { Rank, getGeneralRank, getRankFirstReward, getRankInHandler } from "../../../services/rankService";
import { gameData } from "@pubUtils/data";
import { addItems } from "../../../services/role/rewardService";
import { RewardInter } from "@pubUtils/interface";
import { RankFirstType } from "@db/RankFirst";
export default function (app: Application) {
new HandlerService(app, {});
return new RoleHandler(app);
}
export class RoleHandler {
constructor(private app: Application) {
}
async getGeneralRank(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
if (!role) return resResult(STATUS.WRONG_PARMS);
let ranks = await getGeneralRank(role, serverId);
return resResult(STATUS.SUCCESS, { ranks });
}
async getRankReward(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
if (!role) return resResult(STATUS.WRONG_PARMS);
let ranks = await getRankFirstReward(role, serverId);
return resResult(STATUS.SUCCESS, { ranks });
}
async getRank(msg: { type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let guildCode = session.get('guildCode');
let { type } = msg;
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId }, session);
return resResult(STATUS.SUCCESS, { type, ...result });
}
// 查看活跃排行榜
async getGuildRank(msg: { type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId')
let { type } = msg;
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId });
const myUserGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
let { ranks, myRank } = await r.getRankListWithMyRank({ guildCode: myUserGuild?.guildCode || '' });
if (!myRank) {
let guild = await GuildModel.findByCode(myUserGuild.guildCode, serverId, GUILD_SELECT.RANK);
if (type == RANK_TYPE.GUILD_LV) {
myRank = await r.generMyRankWithGuild(guild.code, guild.lv, guild.lvUpdateTime, guild);
} else if (type == RANK_TYPE.GUILD_ACTIVE) {
myRank = await r.generMyRankWithGuild(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
}
}
return resResult(STATUS.SUCCESS, { type, ranks, myRank });
}
// 查看单个武将排行榜
async getHeroRank(msg: { type: number, hid: number }, session: BackendSession) {
let serverId = session.get('serverId')
let { type, hid } = msg;
let redisKey = getRedisKeyByRankType(type);
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let r = new Rank(redisKey, { serverId, hid });
let ranks = await r.getRankByRange(200, 0);
return resResult(STATUS.SUCCESS, {
type, hid, ranks
});
}
async receiveReward(msg: { type: number, id: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { type, id } = msg;
let ids: number[] = [];
if (id == 0) {
gameData.generalRankReward.forEach((dic, id) => {
if (dic.rankId == type) {
ids.push(id);
}
});
} else {
ids.push(id);
}
let rewards: RewardInter[] = [];
let canReceiveId: number[] = [];
let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
for (let id of ids) {
let dicReward = gameData.generalRankReward.get(id);
if (!dicReward || dicReward.rankId != type) continue;
let rankFirst: RankFirstType = pinus.app.get('rankFirstRewards').get(serverId)?.get(id);
// console.log('*******', pinus.app.get('rankFirstRewards'), rankFirst);
if (!rankFirst) continue;
if (role.rankReceived.includes(id)) continue;
let reward = dicReward.reward;
rewards = rewards.concat(reward);
canReceiveId.push(id);
}
role = await RoleModel.receiveRankReward(roleId, canReceiveId);
if (canReceiveId.length <= 0) return resResult(STATUS.REWARD_CONDITION_NOT_REACH);
let rewardStatus = canReceiveId.map(id => {
return { id, type, status: RANK_FIRST_REWARD_STATUS.RECEIVED }
})
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.RANK_REWARD);
return resResult(STATUS.SUCCESS, {
rewards: rewardStatus,
goods
})
}
}
@@ -1,193 +1,194 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getInitEplace, getJewelDataMap, getResonanceDataMap, refreshResonanceData } from '../../../services/role/resonanceService';
import { resResult } from '../../../pubUtils/util'
import { HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, LINEUP_NUM, RESONANCE, STATUS } from '../../../consts';
import { ResonanceModel } from '../../../db/Resonance';
import { gameData } from '../../../pubUtils/data';
import { RoleModel } from '../../../db/Role';
import { handleCost } from '../../../services/role/rewardService';
import { HeroModel } from '../../../db/Hero';
import { ArtifactModel, ArtifactModelType } from '../../../db/Artifact';
import { calculateCeWithHero } from '../../../services/playerCeService';
import { HeroParam } from '../../../domain/roleField/hero';
import { pick } from 'underscore';
import { ResonanceHistoryModel } from '../../../db/ResonanceHistory';
export default function (app: Application) {
new HandlerService(app, {});
return new HeroHandler(app);
}
export class HeroHandler {
constructor(private app: Application) {
}
/**
* 获取最新数据(会刷新)
* @param msg
* @param session
* @returns
*/
async getData(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
const resonances = await refreshResonanceData(roleId, serverId, sid);
return resResult(STATUS.SUCCESS, resonances)
}
/**
* 解锁阵位
* @param msg
* @param session
* @returns
*/
async unlockPosition(msg: { position: number }, session: BackendSession) {
const { position } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let dbResonance = await ResonanceModel.findByPosition(roleId, position);
if (dbResonance) return resResult(STATUS.RESONANCE_POSITION_LOCK);
const dicResonance = gameData.resonance.get(position);
if (!dicResonance) return resResult(STATUS.RESONANCE_POSITION_NOT_FOUND);
const role = await RoleModel.findByRoleId(roleId);
if (!role || !role.lv || role.lv < (dicResonance?.openLimit || 0)) return resResult(STATUS.RESONANCE_POSITION_LV_NOT_ENOUGH);
let costResult = await handleCost(roleId, sid, dicResonance.openConsume, ITEM_CHANGE_REASON.RESONANCE_LOCK_POSITION);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await ResonanceModel.updateByPosition(roleId, position, {});
if (!result || !result.position) return resResult(STATUS.RESONANCE_POSITION_LOCK_FAIL);
return resResult(STATUS.SUCCESS, { position: result.position });
}
/**
* 武将上阵
* @param msg
* @param session
* @returns
*/
async heroPutPosition(msg: { position: number, hid: number }, session: BackendSession) {
const { position, hid } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
// if (!await getStartLimt(roleId)) return resResult(STATUS.RESONANCE_NO_START);
let { dbResonanceMap } = await getResonanceDataMap(roleId);
let dbRole = await RoleModel.findByRoleId(roleId);
if (dbResonanceMap.size + LINEUP_NUM >= (dbRole?.heroNum || 0)) return resResult(STATUS.RESONANCE_PUT_NOT_POSITION)
let dbResonance = await ResonanceModel.findByPosition(roleId, position);
if (!dbResonance) return resResult(STATUS.RESONANCE_POSITION_UNLOCK);
if (dbResonance.hid) return resResult(STATUS.RESONANCE_POSITION_EXIST_HID);
let dbHeroes = await HeroModel.findByHidAndRole(hid, roleId);
if (!dbHeroes) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);
let { lv = 1, exp = 0, job = 0, jobStage = 0, skinId, skins = [], connections = [], ePlace = [], seqId, ce } = dbHeroes;
//检测养成维度
if (lv > 1) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_LV);
// if (jobStage) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_JOBSTAGE);
if (skins.find(cur => (cur?.usedTalentPoint || 0) > 0)) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_TALENT);
if (connections.length > 0) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_CONNECT);
// if (ePlace.length > 0) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_EQUIP);
if (ePlace.length > 0) {
for (let obj of ePlace) {
let newEplace = await getInitEplace(obj.id, skinId);
if (obj.lv != newEplace.lv || obj.quality != newEplace.quality || obj.qualityStage != newEplace.qualityStage ||
obj.star != newEplace.star || obj.starStage != newEplace.starStage || obj.jewel != newEplace.jewel) {
return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_EQUIP);
}
for (let st of obj.stones) {
if (st.stone != (newEplace.stones.find(cur => cur.id == st.id)?.stone || 0)) {
return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_EQUIP);
}
}
}
}
let result = await ResonanceModel.updateByPosition(roleId, position, { hid, seqId, lv, exp, job, jobStage, skinId, skins, connections, ePlace, ce });
if (!result) return resResult(STATUS.RESONANCE_PUT_POSITION_FAIL);
const resonances = await refreshResonanceData(roleId, serverId, sid);
return resResult(STATUS.SUCCESS, resonances)
}
/**
* 武将下阵
* @param msg
* @param session
* @returns
*/
async heroOffPosition(msg: { position: number, hid: number }, session: BackendSession) {
const { position, hid } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
let dbResonance = await ResonanceModel.findByPositionAndHid(roleId, position, hid);
if (!dbResonance) return resResult(STATUS.RESONANCE_NOT_PUT_POSITION);
let dbHero = await HeroModel.findByHidAndRole(hid, roleId);
if (!dbHero) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);
let { lv = 1, exp = 0, job = 0, jobStage = 0, skinId, skins = [], connections = [], ePlace = [], seqId } = dbResonance;
for (let obj of dbHero.skins) {
let newSkin = skins.find(cur => cur.id == obj.id);
if (newSkin) {
obj.skinId = newSkin.skinId;
obj.enable = newSkin.enable;
obj.talent = newSkin.talent;
obj.usedTalentPoint = newSkin.usedTalentPoint;
}
}
for (let obj of dbHero.ePlace) {
let tempEPlace = ePlace.find(cur => cur.id == obj.id);
if (!tempEPlace && (!RESONANCE.JEWEL || !RESONANCE.STONE) && (obj.jewel || obj.stones.find(cur => cur.stone != 0))) {
ePlace.push({ ...await getInitEplace(obj.id, skinId) });
tempEPlace = ePlace.find(cur => cur.id == obj.id);
}
if (!RESONANCE.JEWEL && obj.jewel) {
tempEPlace.jewel = obj.jewel;
}
if (!RESONANCE.STONE && obj.stones.find(cur => cur.stone != 0)) {
tempEPlace.stones = obj.stones;
}
}
let heroResult = await HeroModel.updateHeroInfo(roleId, hid, { lv, exp, job, jobStage, skinId, skins: dbHero.skins, connections, ePlace });
if (!heroResult) return resResult(STATUS.RESONANCE_OFF_POSITION_FAIL);
// 重新计算战力
let dbJewelMap = await getJewelDataMap([heroResult]);
let artifact = await ArtifactModel.findbySeqId(roleId, seqId);
let artifacts: ArtifactModelType[] = [];
if (artifact) {
artifacts = [artifact]
}
let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.RESONANCE_CAL, roleId, serverId, sid, hid, heroResult, { jewels: [...dbJewelMap.values()], heroes: [heroResult], artifacts });
await ResonanceModel.deletePosition(roleId, position);
let result = await ResonanceModel.updateByPosition(roleId, position, {});
if (!result || result.hid) return resResult(STATUS.RESONANCE_OFF_POSITION_FAIL);
await ResonanceHistoryModel.updateByPosition(roleId, position, { ...dbResonance });
const resonances = await refreshResonanceData(roleId, serverId, sid);
return resResult(STATUS.SUCCESS, {
curHero: { isResonance: false, ...pick(new HeroParam(curHero), ['hid', 'seqId', 'lv', 'exp', 'job', 'jobStage', 'skinId', 'skins', 'talent', 'usedTalentPoint', 'totalTalentPoint', 'connections', 'ePlace', 'ce']) },
...resonances,
})
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getInitEplace, getJewelDataMap, getResonanceDataMap, refreshResonanceData } from '../../../services/role/resonanceService';
import { resResult } from '@pubUtils/util'
import { HERO_SYSTEM_TYPE, ITEM_CHANGE_REASON, LINEUP_NUM, RESONANCE, STATUS } from '../../../consts';
import { ResonanceModel } from '@db/Resonance';
import { gameData } from '@pubUtils/data';
import { RoleModel } from '@db/Role';
import { handleCost } from '../../../services/role/rewardService';
import { HeroModel } from '@db/Hero';
import { ArtifactModel, ArtifactModelType } from '@db/Artifact';
import { calculateCeWithHero } from '../../../services/playerCeService';
import { HeroParam } from '@domain/roleField/hero';
import { pick } from 'underscore';
import { ResonanceHistoryModel } from '@db/ResonanceHistory';
export default function (app: Application) {
new HandlerService(app, {});
return new HeroHandler(app);
}
export class HeroHandler {
constructor(private app: Application) {
}
/**
* 获取最新数据(会刷新)
* @param msg
* @param session
* @returns
*/
async getData(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
const resonances = await refreshResonanceData(roleId, serverId, sid);
return resResult(STATUS.SUCCESS, resonances)
}
/**
* 解锁阵位
* @param msg
* @param session
* @returns
*/
async unlockPosition(msg: { position: number }, session: BackendSession) {
const { position } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let dbResonance = await ResonanceModel.findByPosition(roleId, position);
if (dbResonance) return resResult(STATUS.RESONANCE_POSITION_LOCK);
const dicResonance = gameData.resonance.get(position);
if (!dicResonance) return resResult(STATUS.RESONANCE_POSITION_NOT_FOUND);
const role = await RoleModel.findByRoleId(roleId);
if (!role || !role.lv || role.lv < (dicResonance?.openLimit || 0)) return resResult(STATUS.RESONANCE_POSITION_LV_NOT_ENOUGH);
let costResult = await handleCost(roleId, sid, dicResonance.openConsume, ITEM_CHANGE_REASON.RESONANCE_LOCK_POSITION);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await ResonanceModel.updateByPosition(roleId, position, {});
if (!result || !result.position) return resResult(STATUS.RESONANCE_POSITION_LOCK_FAIL);
return resResult(STATUS.SUCCESS, { position: result.position });
}
/**
* 武将上阵
* @param msg
* @param session
* @returns
*/
async heroPutPosition(msg: { position: number, hid: number }, session: BackendSession) {
const { position, hid } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
// if (!await getStartLimt(roleId)) return resResult(STATUS.RESONANCE_NO_START);
let { dbResonanceMap } = await getResonanceDataMap(roleId);
let dbRole = await RoleModel.findByRoleId(roleId);
if (dbResonanceMap.size + LINEUP_NUM >= (dbRole?.heroNum || 0)) return resResult(STATUS.RESONANCE_PUT_NOT_POSITION)
let dbResonance = await ResonanceModel.findByPosition(roleId, position);
if (!dbResonance) return resResult(STATUS.RESONANCE_POSITION_UNLOCK);
if (dbResonance.hid) return resResult(STATUS.RESONANCE_POSITION_EXIST_HID);
let dbHeroes = await HeroModel.findByHidAndRole(hid, roleId);
if (!dbHeroes) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);
let { lv = 1, exp = 0, job = 0, jobStage = 0, skinId, skins = [], connections = [], ePlace = [], seqId, ce } = dbHeroes;
//检测养成维度
if (lv > 1) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_LV);
// if (jobStage) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_JOBSTAGE);
if (skins.find(cur => (cur?.usedTalentPoint || 0) > 0)) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_TALENT);
if (connections.length > 0) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_CONNECT);
// if (ePlace.length > 0) return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_EQUIP);
if (ePlace.length > 0) {
for (let obj of ePlace) {
let newEplace = await getInitEplace(obj.id, skinId);
if (obj.lv != newEplace.lv || obj.quality != newEplace.quality || obj.qualityStage != newEplace.qualityStage ||
obj.star != newEplace.star || obj.starStage != newEplace.starStage || obj.jewel != newEplace.jewel) {
return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_EQUIP);
}
for (let st of obj.stones) {
if (st.stone != (newEplace.stones.find(cur => cur.id == st.id)?.stone || 0)) {
return resResult(STATUS.RESONANCE_PUT_POSITION_EXIST_EQUIP);
}
}
}
}
let result = await ResonanceModel.updateByPosition(roleId, position, { hid, seqId, lv, exp, job, jobStage, skinId, skins, connections, ePlace, ce });
if (!result) return resResult(STATUS.RESONANCE_PUT_POSITION_FAIL);
const resonances = await refreshResonanceData(roleId, serverId, sid);
return resResult(STATUS.SUCCESS, resonances)
}
/**
* 武将下阵
* @param msg
* @param session
* @returns
*/
async heroOffPosition(msg: { position: number, hid: number }, session: BackendSession) {
const { position, hid } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
let dbResonance = await ResonanceModel.findByPositionAndHid(roleId, position, hid);
if (!dbResonance) return resResult(STATUS.RESONANCE_NOT_PUT_POSITION);
let dbHero = await HeroModel.findByHidAndRole(hid, roleId);
if (!dbHero) return resResult(STATUS.ROLE_HERO_NOT_EXISTS);
let { lv = 1, exp = 0, job = 0, jobStage = 0, skinId, skins = [], connections = [], ePlace = [], seqId } = dbResonance;
for (let obj of dbHero.skins) {
let newSkin = skins.find(cur => cur.id == obj.id);
if (newSkin) {
obj.skinId = newSkin.skinId;
obj.enable = newSkin.enable;
obj.talent = newSkin.talent;
obj.usedTalentPoint = newSkin.usedTalentPoint;
}
}
for (let obj of dbHero.ePlace) {
let tempEPlace = ePlace.find(cur => cur.id == obj.id);
if (!tempEPlace && (!RESONANCE.JEWEL || !RESONANCE.STONE) && (obj.jewel || obj.stones.find(cur => cur.stone != 0))) {
ePlace.push({ ...await getInitEplace(obj.id, skinId) });
tempEPlace = ePlace.find(cur => cur.id == obj.id);
}
if (!RESONANCE.JEWEL && obj.jewel) {
tempEPlace.jewel = obj.jewel;
}
if (!RESONANCE.STONE && obj.stones.find(cur => cur.stone != 0)) {
tempEPlace.stones = obj.stones;
}
}
let heroResult = await HeroModel.updateHeroInfo(roleId, hid, { lv, exp, job, jobStage, skinId, skins: dbHero.skins, connections, ePlace });
if (!heroResult) return resResult(STATUS.RESONANCE_OFF_POSITION_FAIL);
// 重新计算战力
let dbJewelMap = await getJewelDataMap([heroResult]);
let artifact = await ArtifactModel.findbySeqId(roleId, seqId);
let artifacts: ArtifactModelType[] = [];
if (artifact) {
artifacts = [artifact]
}
let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.RESONANCE_CAL, roleId, serverId, sid, hid, heroResult, { jewels: [...dbJewelMap.values()], heroes: [heroResult], artifacts });
await ResonanceModel.deletePosition(roleId, position);
let result = await ResonanceModel.updateByPosition(roleId, position, {});
if (!result || result.hid) return resResult(STATUS.RESONANCE_OFF_POSITION_FAIL);
await ResonanceHistoryModel.updateByPosition(roleId, position, { ...dbResonance });
const resonances = await refreshResonanceData(roleId, serverId, sid);
return resResult(STATUS.SUCCESS, {
curHero: { isResonance: false, ...pick(new HeroParam(curHero), ['hid', 'seqId', 'lv', 'exp', 'job', 'jobStage', 'skinId', 'skins', 'talent', 'usedTalentPoint', 'totalTalentPoint', 'connections', 'ePlace', 'ce']) },
...resonances,
})
}
}
File diff suppressed because it is too large Load Diff
@@ -1,254 +1,255 @@
import { Application, BackendSession, pinus } from "pinus";
import { gameData, hasShopType } from "../../../pubUtils/data";
import { arrToMap, parseGoodStr, resResult } from "../../../pubUtils/util";
import { STATUS, GUILD_STRUCTURE, ITID, CONSUME_TYPE, HERO_QUALITY_TYPE, HERO_GROW_MAX, ITEM_CHANGE_REASON } from "../../../consts";
import { UserShopModel } from "../../../db/UserShop";
import { handleCost, addItems } from "../../../services/role/rewardService";
import { SHOP } from "../../../pubUtils/dicParam";
import { HeroModel, HeroType } from "../../../db/Hero";
import { checkShopInPurchase, getShopDicById, getShopListByType, getShopPrice } from "../../../services/shopService";
import { RewardInter, recycleSoulFastPara } from "../../../pubUtils/interface";
import { UserShopTypeModel } from "../../../db/UserShopType";
import { nowSeconds } from "../../../pubUtils/timeUtil";
import { isGoodsHidden, isHeroHidden } from "../../../services/dataService";
import { RoleModel } from './../../../db/Role';
import { calUpSixColorsResidueFragment } from "../../../services/role/checkMaterial";
import { ItemModel } from "../../../db/Item";
export default function (app: Application) {
return new ShopHandler(app);
}
export class ShopHandler {
constructor(private app: Application) {
}
// 获得商品列表
async getShopList(msg: { shop: number, type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let { shop, type } = msg;
if (!hasShopType(shop, type)) {
return resResult(STATUS.WRONG_PARMS);
}
const result = await getShopListByType(shop, type, roleId, serverId);
return resResult(STATUS.SUCCESS, result);
}
// 读取红点
async readShop(msg: { shop: number, type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let { shop, type } = msg;
if (!hasShopType(shop, type)) {
return resResult(STATUS.WRONG_PARMS);
}
await UserShopTypeModel.read(roleId, shop, type);
return resResult(STATUS.SUCCESS);
}
// 购买商品
async purchase(msg: { activityId: number, shopItemId: number, count: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let serverId = session.get('serverId');
let seasonNum = pinus.app.get('pvpSeasonNum');
let { activityId = 0, shopItemId, count } = msg;
let dicShopItem = await getShopDicById(activityId, shopItemId, roleId, serverId);
if (!dicShopItem) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicShopItem['productID'] && dicShopItem['productID'] != '&') return resResult(STATUS.CAN_NOT_PURCHASE);
if (dicShopItem['beginTime'] && dicShopItem['beginTime'] > nowSeconds()) return resResult(STATUS.SHOP_CLOSED);
if (dicShopItem['endTime'] && dicShopItem['endTime'] < nowSeconds()) return resResult(STATUS.SHOP_CLOSED);
let userShop = await UserShopModel.findByRoleAndItem(roleId, dicShopItem, seasonNum);
let checkResult = await checkShopInPurchase(session, activityId, count, userShop?.count || 0, dicShopItem);
if (checkResult.code != STATUS.SUCCESS.code) {
return resResult(checkResult);
}
// 总计可买次数(从配置表读取)
const totalCanBuyTimes = dicShopItem.purchaseLimit;
if (!totalCanBuyTimes || totalCanBuyTimes <= 0) {
return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
}
// 消耗
let cost = getShopPrice(dicShopItem.money, count, userShop?.count || 0, dicShopItem.price);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.SHOP_PURCHASE);
if (!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
// 次数
userShop = await UserShopModel.purchase(roleId, roleName, activityId, dicShopItem, count, seasonNum);
if (!userShop || (userShop && userShop.count > totalCanBuyTimes)) {
// rollback 消耗
let role = await RoleModel.findByRoleId(roleId);
addItems(roleId, role.roleName, sid, cost, ITEM_CHANGE_REASON.SHOP_PURCHASE);
// rollback 购买次数
await UserShopModel.updateCount(roleId, dicShopItem, -count, seasonNum)
return resResult(STATUS.BUY_COUNT_OVER);
}
// 获得
let reward = [{
id: dicShopItem.goodId,
count: count * (dicShopItem.num || 1)
}];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.SHOP_PURCHASE);
return resResult(STATUS.SUCCESS, {
shopItemId, count,
goods
});
}
// 将魂回收
async recycleSoul(msg: { goodsId: number, count: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { goodsId, count } = msg;
if (isGoodsHidden(goodsId)) return resResult(STATUS.ITEM_IS_HIDDEN);
let dicGoods = gameData.goods.get(goodsId);
if (!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.SOUL) {
return resResult(STATUS.ITEM_NOT_SOUL);
}
let hero = await HeroModel.findByHidAndRole(dicGoods.hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_MAX);
if (hero.colorStar != HERO_GROW_MAX.COLORSTAR) {
let residueFragment = await calUpSixColorsResidueFragment(roleId, hero, dicGoods.hid);
if (!residueFragment || count > residueFragment) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// return resResult(STATUS.HERO_NOT_MAX);
}
// 检查自己的数量
let cost = [{
id: goodsId, count
}];
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.RECYCLE_SOUL);
if (!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let reward: RewardInter[] = [];
switch (dicGoods.quality) {
case HERO_QUALITY_TYPE.BLUE:
reward = parseGoodStr(SHOP.HERO_SOUL_BULE); break;
case HERO_QUALITY_TYPE.PURPLE:
reward = parseGoodStr(SHOP.HERO_SOUL_PURPLE); break;
case HERO_QUALITY_TYPE.GOLD:
reward = parseGoodStr(SHOP.HERO_SOUL_GOLDEN); break;
case HERO_QUALITY_TYPE.UR:
reward = parseGoodStr(SHOP.HERO_SOUL_UR); break;
}
// 增加货币
let goods = await addItems(roleId, roleName, sid, reward.map(cur => { return { id: cur.id, count: cur.count * count } }), ITEM_CHANGE_REASON.RECYCLE_SOUL);
return resResult(STATUS.SUCCESS, {
goodsId, count,
goods
});
}
/**
* 将魂一键回收
* @param msg
* @param session
* @returns
*/
async recycleSoulFast(msg: { recycleSoulFastPara: recycleSoulFastPara[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { recycleSoulFastPara } = msg;
// 检测参数,防止hid重复
let checkHid = new Map<number, number>();
for (let { hid, count } of recycleSoulFastPara) {
if (checkHid.get(hid)) return resResult(STATUS.WRONG_PARMS);
checkHid.set(hid, 1);
}
// 从db获取所有武将数据
const dbHeros = await HeroModel.findByHidsAndRole(roleId, recycleSoulFastPara.map(obj => obj.hid)) as HeroType[];
let heroesMap = new Map<number, HeroType>();
let items = []
for (const val of dbHeros) {
let hid = val.hid
heroesMap.set(hid, val);
let dicHero = gameData.hero.get(hid);
if (!dicHero || !dicHero.pieceId) continue;
items.push(dicHero.pieceId);
}
// 从db获取相关碎片道具数据
if (!items || items.length == 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
const dbItems = await ItemModel.findbyRoleAndIds(roleId, items);
if (!dbItems || dbItems.length == 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
const itemsMap = arrToMap(dbItems, obj => obj.id);
let allAddItem = [];
let allCostItem = [];
for (let { hid, count } of recycleSoulFastPara) {
let residueFragment = 0;
let goodsId = gameData.hero.get(hid)?.pieceId || 0;
const curItemCount = itemsMap.get(goodsId)?.count || 0;
if (curItemCount <= 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let hero = heroesMap.get(hid);
if (!hero) return resResult(STATUS.HERO_IS_HIDDEN);
if (hero.colorStar != HERO_GROW_MAX.COLORSTAR) {
residueFragment = await calUpSixColorsResidueFragment(roleId, hero, hid, curItemCount);
if (!residueFragment || count > residueFragment) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
allCostItem.push({ id: goodsId, count: count });
let dicGoods = gameData.goods.get(goodsId);
if (!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND)
let reward: RewardInter[] = [];
switch (dicGoods.quality) {
case HERO_QUALITY_TYPE.BLUE:
reward = parseGoodStr(SHOP.HERO_SOUL_BULE); break;
case HERO_QUALITY_TYPE.PURPLE:
reward = parseGoodStr(SHOP.HERO_SOUL_PURPLE); break;
case HERO_QUALITY_TYPE.GOLD:
reward = parseGoodStr(SHOP.HERO_SOUL_GOLDEN); break;
case HERO_QUALITY_TYPE.UR:
reward = parseGoodStr(SHOP.HERO_SOUL_UR); break;
}
allAddItem.push(...reward.map(cur => { return { id: cur.id, count: cur.count * count } }));
}
let costResult = await handleCost(roleId, sid, allCostItem, ITEM_CHANGE_REASON.RECYCLE_SOUL);
if (!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
// 增加货币
let goods = await addItems(roleId, roleName, sid, allAddItem, ITEM_CHANGE_REASON.RECYCLE_SOUL);
return resResult(STATUS.SUCCESS, { goods });
}
// !测试接口。 去除限购次数
async debugClearPurchaseLimit(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
await UserShopModel.deleteAccount(roleId);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, pinus } from "pinus";
import { gameData, hasShopType } from "@pubUtils/data";
import { arrToMap, parseGoodStr, resResult } from "@pubUtils/util";
import { STATUS, GUILD_STRUCTURE, ITID, CONSUME_TYPE, HERO_QUALITY_TYPE, HERO_GROW_MAX, ITEM_CHANGE_REASON } from "../../../consts";
import { UserShopModel } from "@db/UserShop";
import { handleCost, addItems } from "../../../services/role/rewardService";
import { SHOP } from "@pubUtils/dicParam";
import { HeroModel, HeroType } from "@db/Hero";
import { checkShopInPurchase, getShopDicById, getShopListByType, getShopPrice } from "../../../services/shopService";
import { RewardInter, recycleSoulFastPara } from "@pubUtils/interface";
import { UserShopTypeModel } from "@db/UserShopType";
import { nowSeconds } from "@pubUtils/timeUtil";
import { isGoodsHidden, isHeroHidden } from "../../../services/dataService";
import { RoleModel } from './../../../db/Role';
import { calUpSixColorsResidueFragment } from "../../../services/role/checkMaterial";
import { ItemModel } from "@db/Item";
export default function (app: Application) {
return new ShopHandler(app);
}
export class ShopHandler {
constructor(private app: Application) {
}
// 获得商品列表
async getShopList(msg: { shop: number, type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let { shop, type } = msg;
if (!hasShopType(shop, type)) {
return resResult(STATUS.WRONG_PARMS);
}
const result = await getShopListByType(shop, type, roleId, serverId);
return resResult(STATUS.SUCCESS, result);
}
// 读取红点
async readShop(msg: { shop: number, type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let { shop, type } = msg;
if (!hasShopType(shop, type)) {
return resResult(STATUS.WRONG_PARMS);
}
await UserShopTypeModel.read(roleId, shop, type);
return resResult(STATUS.SUCCESS);
}
// 购买商品
async purchase(msg: { activityId: number, shopItemId: number, count: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let serverId = session.get('serverId');
let seasonNum = pinus.app.get('pvpSeasonNum');
let { activityId = 0, shopItemId, count } = msg;
let dicShopItem = await getShopDicById(activityId, shopItemId, roleId, serverId);
if (!dicShopItem) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicShopItem['productID'] && dicShopItem['productID'] != '&') return resResult(STATUS.CAN_NOT_PURCHASE);
if (dicShopItem['beginTime'] && dicShopItem['beginTime'] > nowSeconds()) return resResult(STATUS.SHOP_CLOSED);
if (dicShopItem['endTime'] && dicShopItem['endTime'] < nowSeconds()) return resResult(STATUS.SHOP_CLOSED);
let userShop = await UserShopModel.findByRoleAndItem(roleId, dicShopItem, seasonNum);
let checkResult = await checkShopInPurchase(session, activityId, count, userShop?.count || 0, dicShopItem);
if (checkResult.code != STATUS.SUCCESS.code) {
return resResult(checkResult);
}
// 总计可买次数(从配置表读取)
const totalCanBuyTimes = dicShopItem.purchaseLimit;
if (!totalCanBuyTimes || totalCanBuyTimes <= 0) {
return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
}
// 消耗
let cost = getShopPrice(dicShopItem.money, count, userShop?.count || 0, dicShopItem.price);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.SHOP_PURCHASE);
if (!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
// 次数
userShop = await UserShopModel.purchase(roleId, roleName, activityId, dicShopItem, count, seasonNum);
if (!userShop || (userShop && userShop.count > totalCanBuyTimes)) {
// rollback 消耗
let role = await RoleModel.findByRoleId(roleId);
addItems(roleId, role.roleName, sid, cost, ITEM_CHANGE_REASON.SHOP_PURCHASE);
// rollback 购买次数
await UserShopModel.updateCount(roleId, dicShopItem, -count, seasonNum)
return resResult(STATUS.BUY_COUNT_OVER);
}
// 获得
let reward = [{
id: dicShopItem.goodId,
count: count * (dicShopItem.num || 1)
}];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.SHOP_PURCHASE);
return resResult(STATUS.SUCCESS, {
shopItemId, count,
goods
});
}
// 将魂回收
async recycleSoul(msg: { goodsId: number, count: number }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { goodsId, count } = msg;
if (isGoodsHidden(goodsId)) return resResult(STATUS.ITEM_IS_HIDDEN);
let dicGoods = gameData.goods.get(goodsId);
if (!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let dicItid = ITID.get(dicGoods.itid);
if (!dicItid) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if (dicItid.type != CONSUME_TYPE.SOUL) {
return resResult(STATUS.ITEM_NOT_SOUL);
}
let hero = await HeroModel.findByHidAndRole(dicGoods.hid, roleId);
if (!hero) return resResult(STATUS.HERO_NOT_MAX);
if (hero.colorStar != HERO_GROW_MAX.COLORSTAR) {
let residueFragment = await calUpSixColorsResidueFragment(roleId, hero, dicGoods.hid);
if (!residueFragment || count > residueFragment) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// return resResult(STATUS.HERO_NOT_MAX);
}
// 检查自己的数量
let cost = [{
id: goodsId, count
}];
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.RECYCLE_SOUL);
if (!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
let reward: RewardInter[] = [];
switch (dicGoods.quality) {
case HERO_QUALITY_TYPE.BLUE:
reward = parseGoodStr(SHOP.HERO_SOUL_BULE); break;
case HERO_QUALITY_TYPE.PURPLE:
reward = parseGoodStr(SHOP.HERO_SOUL_PURPLE); break;
case HERO_QUALITY_TYPE.GOLD:
reward = parseGoodStr(SHOP.HERO_SOUL_GOLDEN); break;
case HERO_QUALITY_TYPE.UR:
reward = parseGoodStr(SHOP.HERO_SOUL_UR); break;
}
// 增加货币
let goods = await addItems(roleId, roleName, sid, reward.map(cur => { return { id: cur.id, count: cur.count * count } }), ITEM_CHANGE_REASON.RECYCLE_SOUL);
return resResult(STATUS.SUCCESS, {
goodsId, count,
goods
});
}
/**
* 将魂一键回收
* @param msg
* @param session
* @returns
*/
async recycleSoulFast(msg: { recycleSoulFastPara: recycleSoulFastPara[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
let { recycleSoulFastPara } = msg;
// 检测参数,防止hid重复
let checkHid = new Map<number, number>();
for (let { hid, count } of recycleSoulFastPara) {
if (checkHid.get(hid)) return resResult(STATUS.WRONG_PARMS);
checkHid.set(hid, 1);
}
// 从db获取所有武将数据
const dbHeros = await HeroModel.findByHidsAndRole(roleId, recycleSoulFastPara.map(obj => obj.hid)) as HeroType[];
let heroesMap = new Map<number, HeroType>();
let items = []
for (const val of dbHeros) {
let hid = val.hid
heroesMap.set(hid, val);
let dicHero = gameData.hero.get(hid);
if (!dicHero || !dicHero.pieceId) continue;
items.push(dicHero.pieceId);
}
// 从db获取相关碎片道具数据
if (!items || items.length == 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
const dbItems = await ItemModel.findbyRoleAndIds(roleId, items);
if (!dbItems || dbItems.length == 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
const itemsMap = arrToMap(dbItems, obj => obj.id);
let allAddItem = [];
let allCostItem = [];
for (let { hid, count } of recycleSoulFastPara) {
let residueFragment = 0;
let goodsId = gameData.hero.get(hid)?.pieceId || 0;
const curItemCount = itemsMap.get(goodsId)?.count || 0;
if (curItemCount <= 0) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let hero = heroesMap.get(hid);
if (!hero) return resResult(STATUS.HERO_IS_HIDDEN);
if (hero.colorStar != HERO_GROW_MAX.COLORSTAR) {
residueFragment = await calUpSixColorsResidueFragment(roleId, hero, hid, curItemCount);
if (!residueFragment || count > residueFragment) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
allCostItem.push({ id: goodsId, count: count });
let dicGoods = gameData.goods.get(goodsId);
if (!dicGoods) return resResult(STATUS.DIC_DATA_NOT_FOUND)
let reward: RewardInter[] = [];
switch (dicGoods.quality) {
case HERO_QUALITY_TYPE.BLUE:
reward = parseGoodStr(SHOP.HERO_SOUL_BULE); break;
case HERO_QUALITY_TYPE.PURPLE:
reward = parseGoodStr(SHOP.HERO_SOUL_PURPLE); break;
case HERO_QUALITY_TYPE.GOLD:
reward = parseGoodStr(SHOP.HERO_SOUL_GOLDEN); break;
case HERO_QUALITY_TYPE.UR:
reward = parseGoodStr(SHOP.HERO_SOUL_UR); break;
}
allAddItem.push(...reward.map(cur => { return { id: cur.id, count: cur.count * count } }));
}
let costResult = await handleCost(roleId, sid, allCostItem, ITEM_CHANGE_REASON.RECYCLE_SOUL);
if (!costResult) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
// 增加货币
let goods = await addItems(roleId, roleName, sid, allAddItem, ITEM_CHANGE_REASON.RECYCLE_SOUL);
return resResult(STATUS.SUCCESS, { goods });
}
// !测试接口。 去除限购次数
async debugClearPurchaseLimit(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
await UserShopModel.deleteAccount(roleId);
return resResult(STATUS.SUCCESS);
}
}
@@ -1,340 +1,341 @@
import { Application, BackendSession, pinus, HandlerService, } from "pinus";
import { resResult, parseGoodStr, getRandSingleEelm } from "../../../pubUtils/util";
import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, ACTIVITY_TYPE, TASK_TYPE, PUSH_ROUTE } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { UserTaskRecModel } from "../../../db/UserTaskRec";
import { addItems } from "../../../services/role/rewardService";
import { UserTaskModel } from "../../../db/UserTask";
import { nowSeconds, getZeroPointD } from "../../../pubUtils/timeUtil";
import { DicDailyTask, DicAchievement, DicMainTask } from "../../../pubUtils/dictionary/DicTask";
import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/task/taskService";
import { TASK } from "../../../pubUtils/dicParam";
import { ActivityTaskPointModel, ActivityTaskPointModelType } from "../../../db/ActivityTaskPoint";
import { ItemInter, RewardInter } from "../../../pubUtils/interface";
import { RoleModel } from "../../../db/Role";
import { roleLevelup } from "../../../services/normalBattleService";
import _ = require("underscore");
import { addActvityTaskPoint } from "../../../services/activity/activityService";
import { CheckTask } from "../../../services/task/taskObj";
import { ServerlistModel } from "../../../db/Serverlist";
import { sendMessageToUserWithSuc } from "../../../services/pushService";
export default function (app: Application) {
new HandlerService(app, {});
return new ShopHandler(app);
}
export class ShopHandler {
constructor(private app: Application) {
}
public async getTaskList(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const res = await getCurTask(roleId, session);
return resResult(STATUS.SUCCESS, res);
}
public async getPvpTaskList(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const res = await getPvpTask(roleId);
return resResult(STATUS.SUCCESS, res);
}
// 领取主线任务、每日任务、成就单条任务
async receiveTask(msg: { type: number, id: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { type, id } = msg;
let dicTask = gameData.tasks.get(type).get(id);
let { group, taskType, taskReward, condition } = dicTask;
// 检查
let rec = await UserTaskRecModel.findByRoleAndGroup(roleId, type, taskType, group);
if (!rec) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
if (rec.count < condition) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
if (rec.received.includes(id)) return resResult(STATUS.TASK_HAS_RECEIVED);
// 领取记录
rec = await UserTaskRecModel.receiveTask(roleId, type, taskType, group, id);
// 每日、成就增加积分
let point = 0, weeklyPoint = 0, expItem: RewardInter;
if (type == TASK_FUN_TYPE.DAILY) { // 增加积分
let userTask = await UserTaskModel.findByRole(roleId);
let dic = <DicDailyTask>dicTask;
let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
if (curWeek > userTask.dailyTaskRefWeekly) {
userTask = await UserTaskModel.resetDailyScore(roleId, dic.point, curWeek);
} else {
userTask = await UserTaskModel.incInfo(roleId, { dailyTaskPoint: dic.point, dailyTaskPointWeekly: dic.point });
}
point = userTask.dailyTaskPoint;
weeklyPoint = userTask.dailyTaskPointWeekly;
expItem = { id: dic.exp.id, count: dic.exp.count };
//任务完成后关联活动的积分
await addActvityTaskPoint(type, dic.point, session );
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
let dic = <DicAchievement>dicTask;
let userTask = await UserTaskModel.incInfo(roleId, { achievementPoint: dic.point });
point = userTask.achievementPoint;
}
let goods = await addItems(roleId, roleName, sid, taskReward, ITEM_CHANGE_REASON.TASK_REWARD);
if (expItem && expItem.count > 0) {
await roleLevelup(KING_EXP_RATIO_TYPE.TASK, roleId, expItem.count, session);
goods.push(expItem);
}
return resResult(STATUS.SUCCESS, {
type, id, count: rec.count, received: rec.received.includes(id),
point, weeklyPoint,
goods
});
}
// 领取主线阶段奖励
async receiveMainStage(msg: { stage: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { stage } = msg;
let dicMainStage = gameData.mainTaskStage.get(stage);
if (!dicMainStage) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 检查
let userTask = await UserTaskModel.findByRole(roleId);
if (userTask.mainTaskStage != stage) {
return resResult(STATUS.WRONG_PARMS);
}
let recs = await UserTaskRecModel.getReceiveRec(roleId, TASK_FUN_TYPE.MAIN);
for (let id of dicMainStage.mainTaskId) {
let curRecs = recs.find(cur => cur.received.includes(id));
if (!curRecs) return resResult(STATUS.TASK_NOT_ALL_RECEIVED);
}
// 更新数据
userTask = await UserTaskModel.incInfo(roleId, { mainTaskStage: 1 });
let goods = await addItems(roleId, roleName, sid, dicMainStage.reward, ITEM_CHANGE_REASON.TASK_STAGE_REWARD);
let mainTask = await getMainTask(roleId, userTask);
return resResult(STATUS.SUCCESS, {
type: TASK_FUN_TYPE.MAIN,
...mainTask,
goods
});
}
// 领取每日活跃奖励
async receiveActiveReward(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
// 检查
let userTask = await UserTaskModel.findByRole(roleId);
let { dailyTaskPoint } = userTask;
if (dailyTaskPoint < TASK.DAILYTASK_POINT) {
return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
}
// 更新数据
userTask = await UserTaskModel.decreaseDailyPoint(roleId, TASK.DAILYTASK_POINT);
if (!userTask) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
let reward = parseGoodStr(TASK.DAILYTASK_POINT_REWARD);
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.TASK_ACTIVE_REWARD);
return resResult(STATUS.SUCCESS, {
type: TASK_FUN_TYPE.DAILY,
point: userTask.dailyTaskPoint,
goods
});
}
// 领取每日周宝箱
async receiveBox(msg: { type: number, id: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { type, id } = msg;
let userTask = await UserTaskModel.findByRole(roleId);
let dicTaskBox = gameData.taskBox.get(type)?.get(id);
if (!dicTaskBox) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let point = 0, weeklyPoint = 0, box: number[] = [];
// 每日、成就增加积分
if (type == TASK_FUN_TYPE.DAILY) { // 增加积分
let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
let shouldRefresh = false;
let { dailyTaskPointWeekly, dailyTaskBox, dailyTaskRefWeekly } = userTask;
if (curWeek > dailyTaskRefWeekly) {
shouldRefresh = true;
dailyTaskPointWeekly = 0;
dailyTaskBox = [];
}
if (dailyTaskPointWeekly < dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
if (dailyTaskBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);
userTask = await UserTaskModel.pushDailyBox(roleId, id, curWeek, shouldRefresh);
point = userTask.dailyTaskPoint;
box = userTask.dailyTaskBox;
weeklyPoint = userTask.dailyTaskPointWeekly;
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
let { achievementPoint, achievementBox } = userTask;
if (achievementPoint < dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
if (achievementBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);
userTask = await UserTaskModel.pushAchievementBox(roleId, id);
point = userTask.achievementPoint;
box = userTask.achievementBox;
} else {
return resResult(STATUS.WRONG_PARMS);
}
let goods = await addItems(roleId, roleName, sid, dicTaskBox.reward, ITEM_CHANGE_REASON.TASK_BOX_REWARD);
return resResult(STATUS.SUCCESS, {
type,
point, weeklyPoint, box,
goods
});
}
/**
* @description 随机完成某一个任务
* @param {{ type: number }} msg
* @param {BackendSession} session
* @memberof TaskHandler
*/
async debugCompleteRandTask(msg: { type: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
const { type } = msg
let tasks: (DicMainTask | DicDailyTask | DicAchievement)[] = [];
for (let [_id, task] of gameData.tasks.get(type)) {
tasks.push(task);
}
let task = getRandSingleEelm(tasks);
await checkTask(serverId, roleId, sid, task.taskType, { debugInfo: {condition: task.condition} });
return resResult(STATUS.SUCCESS, {
task
});
}
async debugRefTask(msg: { type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let { type } = msg
let userTask;
if (type == TASK_FUN_TYPE.DAILY) {
// 转移每日任务
await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.DAILY_TASK_REFRESH, { taskList: [] }, sid);
await refDailyTaskBox(roleId, sid, true);
userTask = await UserTaskModel.updateInfo(roleId, { dailyTaskPoint: 0 });
} else if (type == TASK_FUN_TYPE.MAIN) {
await UserTaskModel.updateInfo(roleId, { mainTaskStage: 1 });
userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
await UserTaskModel.updateInfo(roleId, { achievementBox: [], achievementPoint: 0 });
userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
} else if (type == TASK_FUN_TYPE.PVP) {
userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
}
let curTask = await getCurTask(roleId, session);;
return resResult(STATUS.SUCCESS, curTask);
}
async debugCompleteMainStage(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
// 检查
let userTask = await UserTaskModel.findByRole(roleId);
let stage = userTask.mainTaskStage;
let dicMainStage = gameData.mainTaskStage.get(stage);
if (!dicMainStage) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let recs = await UserTaskRecModel.getReceiveRec(roleId, TASK_FUN_TYPE.MAIN);
for (let id of dicMainStage.mainTaskId) {
let dicTask = gameData.tasks.get(TASK_FUN_TYPE.MAIN)?.get(id);
if (!dicTask) continue;
let curRecs = recs.find(cur => cur.received.includes(id));
if (!curRecs) {
await UserTaskRecModel.setTaskRec(roleId, TASK_FUN_TYPE.MAIN, dicTask.taskType, dicTask.group, dicTask.condition);
};
}
let mainTask = await getMainTask(roleId, userTask);
for (let t of mainTask.taskList) {
let dicTask = gameData.tasks.get(TASK_FUN_TYPE.MAIN)?.get(t.id);
await UserTaskRecModel.setTaskRec(roleId, TASK_FUN_TYPE.MAIN, dicTask.taskType, dicTask.group, dicTask.condition);
}
return resResult(STATUS.SUCCESS, { mainTask });
}
async debugIncPoint(msg: { type: number, point: number }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let { type, point: incPoint } = msg;
// 每日、成就增加积分
let point = 0, weeklyPoint = 0;
if (type == TASK_FUN_TYPE.DAILY) { // 增加积分
let userTask = await UserTaskModel.findByRole(roleId);
let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
if (curWeek > userTask.dailyTaskRefWeekly) {
userTask = await UserTaskModel.resetDailyScore(roleId, incPoint, curWeek);
} else {
userTask = await UserTaskModel.incInfo(roleId, { dailyTaskPoint: incPoint, dailyTaskPointWeekly: incPoint });
}
point = userTask.dailyTaskPoint;
weeklyPoint = userTask.dailyTaskPointWeekly;
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
let userTask = await UserTaskModel.incInfo(roleId, { achievementPoint: incPoint });
point = userTask.achievementPoint;
}
return resResult(STATUS.SUCCESS, {
type, point, weeklyPoint
});
}
async debugGetDicTask(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
// console.log('******', _.isEqual([1,2], [1,2,2]))
return resResult(STATUS.SUCCESS, { tasks: [...gameData.taskType]});
}
async test(msg: { magicWord: string }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let sid = session.get('sid');
let role = await RoleModel.findByRoleId(roleId);
let server = await ServerlistModel.findByServerId(serverId);
return resResult(STATUS.SUCCESS)
}
}
import { Application, BackendSession, pinus, HandlerService, } from "pinus";
import { resResult, parseGoodStr, getRandSingleEelm } from "@pubUtils/util";
import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, ACTIVITY_TYPE, TASK_TYPE, PUSH_ROUTE } from "../../../consts";
import { gameData } from "@pubUtils/data";
import { UserTaskRecModel } from "@db/UserTaskRec";
import { addItems } from "../../../services/role/rewardService";
import { UserTaskModel } from "@db/UserTask";
import { nowSeconds, getZeroPointD } from "@pubUtils/timeUtil";
import { DicDailyTask, DicAchievement, DicMainTask } from "@pubUtils/dictionary/DicTask";
import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/task/taskService";
import { TASK } from "@pubUtils/dicParam";
import { ActivityTaskPointModel, ActivityTaskPointModelType } from "@db/ActivityTaskPoint";
import { ItemInter, RewardInter } from "@pubUtils/interface";
import { RoleModel } from "@db/Role";
import { roleLevelup } from "../../../services/normalBattleService";
import _ = require("underscore");
import { addActvityTaskPoint } from "../../../services/activity/activityService";
import { CheckTask } from "../../../services/task/taskObj";
import { ServerlistModel } from "@db/Serverlist";
import { sendMessageToUserWithSuc } from "../../../services/pushService";
export default function (app: Application) {
new HandlerService(app, {});
return new ShopHandler(app);
}
export class ShopHandler {
constructor(private app: Application) {
}
public async getTaskList(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const res = await getCurTask(roleId, session);
return resResult(STATUS.SUCCESS, res);
}
public async getPvpTaskList(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const res = await getPvpTask(roleId);
return resResult(STATUS.SUCCESS, res);
}
// 领取主线任务、每日任务、成就单条任务
async receiveTask(msg: { type: number, id: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { type, id } = msg;
let dicTask = gameData.tasks.get(type).get(id);
let { group, taskType, taskReward, condition } = dicTask;
// 检查
let rec = await UserTaskRecModel.findByRoleAndGroup(roleId, type, taskType, group);
if (!rec) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
if (rec.count < condition) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
if (rec.received.includes(id)) return resResult(STATUS.TASK_HAS_RECEIVED);
// 领取记录
rec = await UserTaskRecModel.receiveTask(roleId, type, taskType, group, id);
// 每日、成就增加积分
let point = 0, weeklyPoint = 0, expItem: RewardInter;
if (type == TASK_FUN_TYPE.DAILY) { // 增加积分
let userTask = await UserTaskModel.findByRole(roleId);
let dic = <DicDailyTask>dicTask;
let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
if (curWeek > userTask.dailyTaskRefWeekly) {
userTask = await UserTaskModel.resetDailyScore(roleId, dic.point, curWeek);
} else {
userTask = await UserTaskModel.incInfo(roleId, { dailyTaskPoint: dic.point, dailyTaskPointWeekly: dic.point });
}
point = userTask.dailyTaskPoint;
weeklyPoint = userTask.dailyTaskPointWeekly;
expItem = { id: dic.exp.id, count: dic.exp.count };
//任务完成后关联活动的积分
await addActvityTaskPoint(type, dic.point, session );
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
let dic = <DicAchievement>dicTask;
let userTask = await UserTaskModel.incInfo(roleId, { achievementPoint: dic.point });
point = userTask.achievementPoint;
}
let goods = await addItems(roleId, roleName, sid, taskReward, ITEM_CHANGE_REASON.TASK_REWARD);
if (expItem && expItem.count > 0) {
await roleLevelup(KING_EXP_RATIO_TYPE.TASK, roleId, expItem.count, session);
goods.push(expItem);
}
return resResult(STATUS.SUCCESS, {
type, id, count: rec.count, received: rec.received.includes(id),
point, weeklyPoint,
goods
});
}
// 领取主线阶段奖励
async receiveMainStage(msg: { stage: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { stage } = msg;
let dicMainStage = gameData.mainTaskStage.get(stage);
if (!dicMainStage) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 检查
let userTask = await UserTaskModel.findByRole(roleId);
if (userTask.mainTaskStage != stage) {
return resResult(STATUS.WRONG_PARMS);
}
let recs = await UserTaskRecModel.getReceiveRec(roleId, TASK_FUN_TYPE.MAIN);
for (let id of dicMainStage.mainTaskId) {
let curRecs = recs.find(cur => cur.received.includes(id));
if (!curRecs) return resResult(STATUS.TASK_NOT_ALL_RECEIVED);
}
// 更新数据
userTask = await UserTaskModel.incInfo(roleId, { mainTaskStage: 1 });
let goods = await addItems(roleId, roleName, sid, dicMainStage.reward, ITEM_CHANGE_REASON.TASK_STAGE_REWARD);
let mainTask = await getMainTask(roleId, userTask);
return resResult(STATUS.SUCCESS, {
type: TASK_FUN_TYPE.MAIN,
...mainTask,
goods
});
}
// 领取每日活跃奖励
async receiveActiveReward(msg: {}, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
// 检查
let userTask = await UserTaskModel.findByRole(roleId);
let { dailyTaskPoint } = userTask;
if (dailyTaskPoint < TASK.DAILYTASK_POINT) {
return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
}
// 更新数据
userTask = await UserTaskModel.decreaseDailyPoint(roleId, TASK.DAILYTASK_POINT);
if (!userTask) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
let reward = parseGoodStr(TASK.DAILYTASK_POINT_REWARD);
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.TASK_ACTIVE_REWARD);
return resResult(STATUS.SUCCESS, {
type: TASK_FUN_TYPE.DAILY,
point: userTask.dailyTaskPoint,
goods
});
}
// 领取每日周宝箱
async receiveBox(msg: { type: number, id: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const { type, id } = msg;
let userTask = await UserTaskModel.findByRole(roleId);
let dicTaskBox = gameData.taskBox.get(type)?.get(id);
if (!dicTaskBox) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let point = 0, weeklyPoint = 0, box: number[] = [];
// 每日、成就增加积分
if (type == TASK_FUN_TYPE.DAILY) { // 增加积分
let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
let shouldRefresh = false;
let { dailyTaskPointWeekly, dailyTaskBox, dailyTaskRefWeekly } = userTask;
if (curWeek > dailyTaskRefWeekly) {
shouldRefresh = true;
dailyTaskPointWeekly = 0;
dailyTaskBox = [];
}
if (dailyTaskPointWeekly < dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
if (dailyTaskBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);
userTask = await UserTaskModel.pushDailyBox(roleId, id, curWeek, shouldRefresh);
point = userTask.dailyTaskPoint;
box = userTask.dailyTaskBox;
weeklyPoint = userTask.dailyTaskPointWeekly;
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
let { achievementPoint, achievementBox } = userTask;
if (achievementPoint < dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
if (achievementBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);
userTask = await UserTaskModel.pushAchievementBox(roleId, id);
point = userTask.achievementPoint;
box = userTask.achievementBox;
} else {
return resResult(STATUS.WRONG_PARMS);
}
let goods = await addItems(roleId, roleName, sid, dicTaskBox.reward, ITEM_CHANGE_REASON.TASK_BOX_REWARD);
return resResult(STATUS.SUCCESS, {
type,
point, weeklyPoint, box,
goods
});
}
/**
* @description 随机完成某一个任务
* @param {{ type: number }} msg
* @param {BackendSession} session
* @memberof TaskHandler
*/
async debugCompleteRandTask(msg: { type: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
const { type } = msg
let tasks: (DicMainTask | DicDailyTask | DicAchievement)[] = [];
for (let [_id, task] of gameData.tasks.get(type)) {
tasks.push(task);
}
let task = getRandSingleEelm(tasks);
await checkTask(serverId, roleId, sid, task.taskType, { debugInfo: {condition: task.condition} });
return resResult(STATUS.SUCCESS, {
task
});
}
async debugRefTask(msg: { type: number }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let { type } = msg
let userTask;
if (type == TASK_FUN_TYPE.DAILY) {
// 转移每日任务
await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
sendMessageToUserWithSuc(roleId, PUSH_ROUTE.DAILY_TASK_REFRESH, { taskList: [] }, sid);
await refDailyTaskBox(roleId, sid, true);
userTask = await UserTaskModel.updateInfo(roleId, { dailyTaskPoint: 0 });
} else if (type == TASK_FUN_TYPE.MAIN) {
await UserTaskModel.updateInfo(roleId, { mainTaskStage: 1 });
userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
await UserTaskModel.updateInfo(roleId, { achievementBox: [], achievementPoint: 0 });
userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
} else if (type == TASK_FUN_TYPE.PVP) {
userTask = await removeHistoryTask(roleId, type, new Date(nowSeconds() * 1000 + 86400000));
}
let curTask = await getCurTask(roleId, session);;
return resResult(STATUS.SUCCESS, curTask);
}
async debugCompleteMainStage(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
// 检查
let userTask = await UserTaskModel.findByRole(roleId);
let stage = userTask.mainTaskStage;
let dicMainStage = gameData.mainTaskStage.get(stage);
if (!dicMainStage) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let recs = await UserTaskRecModel.getReceiveRec(roleId, TASK_FUN_TYPE.MAIN);
for (let id of dicMainStage.mainTaskId) {
let dicTask = gameData.tasks.get(TASK_FUN_TYPE.MAIN)?.get(id);
if (!dicTask) continue;
let curRecs = recs.find(cur => cur.received.includes(id));
if (!curRecs) {
await UserTaskRecModel.setTaskRec(roleId, TASK_FUN_TYPE.MAIN, dicTask.taskType, dicTask.group, dicTask.condition);
};
}
let mainTask = await getMainTask(roleId, userTask);
for (let t of mainTask.taskList) {
let dicTask = gameData.tasks.get(TASK_FUN_TYPE.MAIN)?.get(t.id);
await UserTaskRecModel.setTaskRec(roleId, TASK_FUN_TYPE.MAIN, dicTask.taskType, dicTask.group, dicTask.condition);
}
return resResult(STATUS.SUCCESS, { mainTask });
}
async debugIncPoint(msg: { type: number, point: number }, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let { type, point: incPoint } = msg;
// 每日、成就增加积分
let point = 0, weeklyPoint = 0;
if (type == TASK_FUN_TYPE.DAILY) { // 增加积分
let userTask = await UserTaskModel.findByRole(roleId);
let curWeek = getZeroPointD(SHOP_REFRESH_TYPE.WEEKLY);
if (curWeek > userTask.dailyTaskRefWeekly) {
userTask = await UserTaskModel.resetDailyScore(roleId, incPoint, curWeek);
} else {
userTask = await UserTaskModel.incInfo(roleId, { dailyTaskPoint: incPoint, dailyTaskPointWeekly: incPoint });
}
point = userTask.dailyTaskPoint;
weeklyPoint = userTask.dailyTaskPointWeekly;
} else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
let userTask = await UserTaskModel.incInfo(roleId, { achievementPoint: incPoint });
point = userTask.achievementPoint;
}
return resResult(STATUS.SUCCESS, {
type, point, weeklyPoint
});
}
async debugGetDicTask(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
// console.log('******', _.isEqual([1,2], [1,2,2]))
return resResult(STATUS.SUCCESS, { tasks: [...gameData.taskType]});
}
async test(msg: { magicWord: string }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
let sid = session.get('sid');
let role = await RoleModel.findByRoleId(roleId);
let server = await ServerlistModel.findByServerId(serverId);
return resResult(STATUS.SUCCESS)
}
}
@@ -1,80 +1,81 @@
import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
import { STATUS, TEAM_TYPE } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { resResult } from "../../../pubUtils/util";
import { PVPConfigModel } from "../../../db/PvpConfig";
import { PvpSaveDataModel } from "../../../db/PvpSaveData";
import { LadderMatchModel } from "../../../db/LadderMatch";
import { GVGVestigeRankModel } from "../../../db/GVGVestigeRank";
import { GVGTeamModel } from "../../../db/GVGTeam";
import { PvpDefenseModel } from "../../../db/PvpDefense";
export default function (app: Application) {
new HandlerService(app, {});
return new TeamHandler(app);
}
export class TeamHandler {
channelService: ChannelService;
constructor(private app: Application) {
}
// 获取每个编队里的武将
async getTeamHeroes(msg: { }, session: BackendSession) {
const roleId = session.get('roleId');
const teams: { type: number, heroes: number[] }[] = [];
let pvpConfig = await PVPConfigModel.findCurPVPConfig();
if(pvpConfig) {
let saveDatas = await PvpSaveDataModel.findByRoleId(roleId);
let heroes: number[] = [];
for(let warId of (pvpConfig.warIds||[])) {
let dicWar = gameData.war.get(warId);
if(dicWar && dicWar.selectView == 1) {
let curSaveData = saveDatas.find(cur => cur.warId == warId);
let defenseHeroes = curSaveData?.heroes||[];
for(let { actorId } of defenseHeroes) heroes.push(actorId);
}
}
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if(pvpDefense && pvpDefense.attack) {
let attackHeroes = pvpDefense.attack.heroes||[];
for(let { actorId } of attackHeroes) heroes.push(actorId);
}
teams.push({ type: TEAM_TYPE.PVP, heroes });
}
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(ladderData && ladderData.defense) {
let heroes: number[] = [];
let defenseHeroes = ladderData.defense?.heroes||[];
for(let { actorId } of defenseHeroes) heroes.push(actorId);
teams.push({ type: TEAM_TYPE.LADDER, heroes });
}
let vestigeData = await GVGVestigeRankModel.findAllByRole(roleId);
if(vestigeData) {
let heroes: number[] = [];
for(let { lineup = [] } of vestigeData) {
for(let { actorId } of lineup) heroes.push(actorId);
}
teams.push({ type: TEAM_TYPE.VESTIGE, heroes });
}
let gvgBattleTeams = await GVGTeamModel.findByRole(roleId, '-_id lineup');
if(gvgBattleTeams) {
let heroes: number[] = [];
for(let { lineup = [] } of gvgBattleTeams) {
for(let { actorId } of lineup) heroes.push(actorId);
}
teams.push({ type: TEAM_TYPE.GVG_BATTLE, heroes });
}
return resResult(STATUS.SUCCESS, { teams });
}
}
import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
import { STATUS, TEAM_TYPE } from "../../../consts";
import { gameData } from "@pubUtils/data";
import { resResult } from "@pubUtils/util";
import { PVPConfigModel } from "@db/PvpConfig";
import { PvpSaveDataModel } from "@db/PvpSaveData";
import { LadderMatchModel } from "@db/LadderMatch";
import { GVGVestigeRankModel } from "@db/GVGVestigeRank";
import { GVGTeamModel } from "@db/GVGTeam";
import { PvpDefenseModel } from "@db/PvpDefense";
export default function (app: Application) {
new HandlerService(app, {});
return new TeamHandler(app);
}
export class TeamHandler {
channelService: ChannelService;
constructor(private app: Application) {
}
// 获取每个编队里的武将
async getTeamHeroes(msg: { }, session: BackendSession) {
const roleId = session.get('roleId');
const teams: { type: number, heroes: number[] }[] = [];
let pvpConfig = await PVPConfigModel.findCurPVPConfig();
if(pvpConfig) {
let saveDatas = await PvpSaveDataModel.findByRoleId(roleId);
let heroes: number[] = [];
for(let warId of (pvpConfig.warIds||[])) {
let dicWar = gameData.war.get(warId);
if(dicWar && dicWar.selectView == 1) {
let curSaveData = saveDatas.find(cur => cur.warId == warId);
let defenseHeroes = curSaveData?.heroes||[];
for(let { actorId } of defenseHeroes) heroes.push(actorId);
}
}
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if(pvpDefense && pvpDefense.attack) {
let attackHeroes = pvpDefense.attack.heroes||[];
for(let { actorId } of attackHeroes) heroes.push(actorId);
}
teams.push({ type: TEAM_TYPE.PVP, heroes });
}
let ladderData = await LadderMatchModel.findByRoleId(roleId);
if(ladderData && ladderData.defense) {
let heroes: number[] = [];
let defenseHeroes = ladderData.defense?.heroes||[];
for(let { actorId } of defenseHeroes) heroes.push(actorId);
teams.push({ type: TEAM_TYPE.LADDER, heroes });
}
let vestigeData = await GVGVestigeRankModel.findAllByRole(roleId);
if(vestigeData) {
let heroes: number[] = [];
for(let { lineup = [] } of vestigeData) {
for(let { actorId } of lineup) heroes.push(actorId);
}
teams.push({ type: TEAM_TYPE.VESTIGE, heroes });
}
let gvgBattleTeams = await GVGTeamModel.findByRole(roleId, '-_id lineup');
if(gvgBattleTeams) {
let heroes: number[] = [];
for(let { lineup = [] } of gvgBattleTeams) {
for(let { actorId } of lineup) heroes.push(actorId);
}
teams.push({ type: TEAM_TYPE.GVG_BATTLE, heroes });
}
return resResult(STATUS.SUCCESS, { teams });
}
}