185 lines
8.6 KiB
TypeScript
185 lines
8.6 KiB
TypeScript
import { RougelikeRecordDetailType } from '../../db/RougelikeRecordDetail';
|
|
import { COLLECTION_TYPE, PUSH_ROUTE, ROUGE_LIKE_CARD_TYPE } from '../../consts';
|
|
import { genCode } from '../../pubUtils/util';
|
|
import { Card, RougelikeCharaModel, RougelikeCharaPara, RougelikeCharaType } from '../../db/RougelikeChara';
|
|
import { RougelikeCardPara, RougelikeCardModel } from '../../db/RougelikeCard';
|
|
import { CommonCard, CommonChara } from '../../pubUtils/interface';
|
|
import { RougelikeCollectionModel } from '../../db/RougelikeCollection';
|
|
import { sendMessageToUserWithSuc } from '../pushService';
|
|
import { gameData } from '../../pubUtils/data';
|
|
import { clone } from 'underscore';
|
|
import { RougeEffect, getSlotUnlockPoint } from './rougeEffectService';
|
|
|
|
export class HandleAddCard {
|
|
roleId: string;
|
|
sid: string;
|
|
gameCode: string;
|
|
getLayer: number = 0;
|
|
getWay: number = 0;
|
|
addCharas: RougelikeCharaPara[] = []; // 需要更新的角色
|
|
addPassiveCards: RougelikeCardPara[] = []; // 需要更新的特性卡
|
|
addHolyCards: RougelikeCardPara[] = []; // 需要更新的圣物
|
|
addCoin: number = 0; // 需要增加的试炼币
|
|
|
|
constructor(roleId: string, sid: string, gameCode: string, recordDetail?: RougelikeRecordDetailType) {
|
|
this.roleId = roleId;
|
|
this.sid = sid;
|
|
this.gameCode = gameCode;
|
|
if (recordDetail) {
|
|
this.getLayer = recordDetail.layer;
|
|
this.getWay = recordDetail.nodeType;
|
|
}
|
|
}
|
|
|
|
private getCommonParam() {
|
|
let { roleId, gameCode, getLayer, getWay } = this;
|
|
return { roleId, gameCode, getLayer, getWay };
|
|
}
|
|
|
|
public pushChara(id: number, maxHp: number, passiveCardIds: number[]) {
|
|
let cards: Card[] = [];
|
|
for (let index = 0; index < passiveCardIds.length; index++) {
|
|
let cardId = passiveCardIds[index];
|
|
let cardCode = this.pushPassiveCard(cardId, id);
|
|
cards.push({ index, cardCode, cardId });
|
|
}
|
|
let charaCode = genCode(8);
|
|
this.addCharas.push({ ...this.getCommonParam(), cards, charaCode, charaId: id, maxHp, hp: maxHp, ap: 0, shield: 0, others: '', roundSkill: 0, apSkill: 0 });
|
|
return charaCode;
|
|
}
|
|
|
|
public pushCard(id: number, rewardType: ROUGE_LIKE_CARD_TYPE, charaId: number = 0) {
|
|
if (rewardType == ROUGE_LIKE_CARD_TYPE.PASSIVE) {
|
|
return this.pushPassiveCard(id, charaId);
|
|
} else if (rewardType == ROUGE_LIKE_CARD_TYPE.HOLY) {
|
|
return this.pushHolyCard(id);
|
|
}
|
|
}
|
|
|
|
public pushPassiveCard(id: number, charaId: number = 0) {
|
|
let cardCode = genCode(8);
|
|
this.addPassiveCards.push({
|
|
...this.getCommonParam(), cardCode, cardId: id, type: ROUGE_LIKE_CARD_TYPE.PASSIVE, lv: gameData.rougePassiveCard.get(id)?.lv || 0, charaId
|
|
});
|
|
return cardCode
|
|
}
|
|
|
|
public pushHolyCards(ids: number[]) {
|
|
for (let id of ids) this.pushHolyCard(id);
|
|
}
|
|
|
|
public pushHolyCard(id: number) {
|
|
let cardCode = genCode(8);
|
|
this.addHolyCards.push({
|
|
...this.getCommonParam(), cardCode, cardId: id, type: ROUGE_LIKE_CARD_TYPE.HOLY, useCount: 0
|
|
});
|
|
return cardCode
|
|
}
|
|
|
|
private getHolyUseCount(holyId: number) {
|
|
const holyCardData = gameData.rougeHolyCard.get(holyId);
|
|
return holyCardData?.useCount || 0;
|
|
}
|
|
|
|
public async save() {
|
|
let result: { addCharas?: CommonChara[], addCards?: CommonCard[] } = {};
|
|
if (this.addCharas.length > 0) {
|
|
let updateParams = this.addCharas || [];
|
|
let resultArrs = await RougelikeCharaModel.createCharas(updateParams);
|
|
this.addCharas = resultArrs;
|
|
result.addCharas = resultArrs.map(param => new CommonChara(param));
|
|
}
|
|
if (this.addPassiveCards.length > 0 || this.addHolyCards.length > 0) {
|
|
let updateParams = [...(this.addPassiveCards || []), ...(this.addHolyCards || [])];
|
|
// await RougelikeCardModel.bulkWriteUpdate(updateParams);
|
|
updateParams.map(async param => {
|
|
const { gameCode, cardCode } = param;
|
|
await RougelikeCardModel.updateByCode(gameCode, cardCode, { $set: param })
|
|
});
|
|
result.addCards = updateParams.map(param => new CommonCard(param));
|
|
}
|
|
let collections: { type: number, id: number, addNum?: number }[] = [];
|
|
for (let { cardId, type } of result.addCards || []) {
|
|
if (type == ROUGE_LIKE_CARD_TYPE.PASSIVE) {
|
|
collections.push({ type: COLLECTION_TYPE.PASSIVE_CARD, id: cardId });
|
|
}
|
|
if (type == ROUGE_LIKE_CARD_TYPE.HOLY) collections.push({ type: COLLECTION_TYPE.HOLY_CARD, id: cardId });
|
|
}
|
|
if (collections.length > 0) await addCollection(this.roleId, this.sid, this.gameCode, collections);
|
|
|
|
if (this.addCharas.length > 0) {
|
|
result.addCharas = await this.getCharasByHolyEffect();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// 处理获得角色卡时拥有圣物效果
|
|
public async getCharasByHolyEffect() {
|
|
let result = await getSlotUnlockPoint(this.roleId, this.gameCode, this.addCharas || []);
|
|
this.addCharas = result.dbCharas;
|
|
if (result.isUpdate) {
|
|
await RougelikeCharaModel.bulkWriteUpdate(this.addCharas || []);
|
|
}
|
|
return this.addCharas.map(param => new CommonChara(param));
|
|
}
|
|
|
|
// 处理圣物效果
|
|
public async getHolyEffect() {
|
|
let result: { addCharas?: CommonChara[], addCards?: CommonCard[] } = {};
|
|
let charasMap = (this.addCharas || []).reduce((result, cur) => { result.set(cur.charaCode, cur); return result; }, new Map<string, RougelikeCharaPara>());
|
|
let cardsMap = [...(this.addPassiveCards || []), ...(this.addHolyCards || [])].reduce((result, cur) => { result.set(cur.cardCode, cur); return result; }, new Map<string, RougelikeCardPara>());
|
|
if ((this.addHolyCards || []).length > 0) {
|
|
let rougeEffect = new RougeEffect(this.roleId, this.gameCode);
|
|
let holyIds = clone(this.addHolyCards.map(cur => { return { cardCode: cur.cardCode, cardId: cur.cardId, useCount: cur.useCount } }));
|
|
|
|
let { charas, cards } = await rougeEffect.getEffectImmediate(holyIds);
|
|
if (charas && charas.size > 0) {
|
|
await RougelikeCharaModel.bulkWriteUpdate([...charas.values()]);
|
|
charasMap = new Map([...charasMap, ...charas])
|
|
}
|
|
if (cards && cards.size > 0) {
|
|
await RougelikeCardModel.bulkWriteUpdate([...cards.values()])
|
|
cardsMap = new Map([...cardsMap, ...cards])
|
|
}
|
|
}
|
|
result.addCharas = [...charasMap.values()].map(param => new CommonChara(param));
|
|
result.addCards = [...cardsMap.values()].map(param => new CommonCard(param));
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
export function formateCharasOrCards(params: RougelikeCharaPara[] | RougelikeCardPara[], type: number) {
|
|
let result: { charas?: CommonChara[], cards?: CommonCard[] } = {};
|
|
if (!params || params.length == 0) return result;
|
|
const updateParams = params || [];
|
|
if (type == ROUGE_LIKE_CARD_TYPE.CHARA) result.charas = updateParams.map(param => new CommonChara(param));
|
|
else result.cards = updateParams.map(param => new CommonCard(param));
|
|
return result;
|
|
}
|
|
|
|
export async function addCollection(roleId: string, sid: string, gameCode: string, arr: { type: number, id: number, addNum?: number }[]) {
|
|
let collections: { type: number, id: number, num: number }[] = [], passiveCnt = 0;
|
|
for (let { type, id, addNum = 1 } of arr) {
|
|
if (type == COLLECTION_TYPE.PASSIVE_CARD_SUM) continue;
|
|
let collection = await RougelikeCollectionModel.addRec(roleId, type, id, gameCode, addNum);
|
|
if (!collection || collection.num > 1) continue;
|
|
if (collection.num == 1) passiveCnt++;
|
|
collections.push({ type, id, num: collection.num });
|
|
}
|
|
if (passiveCnt > 0) {
|
|
let collection = await RougelikeCollectionModel.addRec(roleId, COLLECTION_TYPE.PASSIVE_CARD_SUM, 0, gameCode, passiveCnt);
|
|
collections.push({ type: COLLECTION_TYPE.PASSIVE_CARD, id: 0, num: collection.num });
|
|
}
|
|
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ROUGE_COLLECT_UPDATE, { collections }, sid);
|
|
return collections;
|
|
}
|
|
|
|
export async function addSingleCollect(roleId: string, sid: string, gameCode: string, type: number, id: number) {
|
|
return await addCollection(roleId, sid, gameCode, [{ type, id }]);
|
|
}
|
|
|
|
export async function addSameTypeCollect(roleId: string, sid: string, gameCode: string, type: number, ids: number[]) {
|
|
return await addCollection(roleId, sid, gameCode, ids.map(id => ({ type, id })));
|
|
} |