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

武将：抽象武将创建接口

Browse Source
This commit is contained in:
luying
2021-04-23 19:32:02 +08:00
parent 2b246c4bc9
commit 0cd6939f5e
18 changed files with 213 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
game-server/app/servers/activity/handler/gachaHandler.ts
View File

@@ -1,16 +1,22 @@
import { Application, BackendSession } from "pinus";
import { resResult, getRandomWithWeight } from "../../../pubUtils/util";
import { STATUS, GACHA_ID } from "../../../consts";
import { resResult, getRandomWithWeight, getRandEelm } from "../../../pubUtils/util";
import { STATUS, GACHA_ID, HERO_QUALITY_TYPE, TASK_TYPE } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { GachaListReturn, GachaResult } from "../../../domain/activityField/gachaField";
import { GachaListReturn, GachaResult, GachaData } from "../../../domain/activityField/gachaField";
import { UserGachaModel } from "../../../db/UserGacha";
import { refreshGacha, getFloorResult, getResultFromContentId, transPiece } from "../../../services/gachaService";
import { refreshGacha, getFloorResult, getResultFromContentId } from "../../../services/gachaService";
import { RoleModel } from "../../../db/Role";
import { HeroModel, HeroUpdate } from "../../../db/Hero";
import { RewardInter } from "../../../pubUtils/interface";
import { handleCost, createHeroes, addItems } from "../../../services/rewardService";
import { getAfterDateByDay } from "../../../pubUtils/timeUtil";
import { UserGachaRecModel } from "../../../db/UserGachaRec";
import { ActivityModel } from "../../../db/Activity";
import { checkTask } from "../../../services/taskService";
import { RECRUIT } from "../../../pubUtils/dicParam";
import { getAllHeroByQuality } from "../../../services/gachaService";
import { transPiece } from "../../../pubUtils/itemUtils";
import { CreateHeroParam } from "../../../domain/roleField/hero";
export default function (app: Application) {
return new GachaHandler(app);
@@ -58,6 +64,7 @@ export class GachaHandler {
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
const serverId: number = session.get('serverId');
const funcs: number[] = session.get('funcs');
let { lv } = await RoleModel.findByRoleId(roleId);
@@ -71,7 +78,7 @@ export class GachaHandler {
let userHeroes = await HeroModel.findByRole(roleId);
let items: RewardInter[] = [], heroInfo: HeroUpdate[] = [], resultList: GachaResult[] = [];
let items: RewardInter[] = [], heroInfo: CreateHeroParam[] = [], resultList: GachaResult[] = [];
for(let i = 0; i < count; i++) {
// 按照一般概率抽出
let { dic: { id: base } } = getRandomWithWeight(dicGacha.percent);
@@ -113,16 +120,18 @@ export class GachaHandler {
if(!costResult) return resResult(STATUS.GACHA_COST_NOT_ENOUGH);
}
// 给东西
let heroes = await createHeroes(roleId, sid, serverId, heroInfo);
let { heroes, goods } = await createHeroes(roleId, roleName, sid, serverId, heroInfo);
await addItems(roleId, roleName, sid, items);
// 更新数据
point += count;
point = Math.floor(count/RECRUIT.RECRUIT_BONUS);
userGacha = await UserGachaModel.updateInfo(roleId, gachaId, activityId, {
freeCount, hope, floor, count, point
});
await UserGachaRecModel.createRec(roleId, gachaId, activityId, count, resultList);
// 任务
await checkTask(roleId, sid, funcs, TASK_TYPE.GASHA, count, true, {});
return resResult(STATUS.SUCCESS, {
gachaId, activityId,
freeCount, refFreeTime: getAfterDateByDay(refFreeTime, dicGacha.free.day), count, point, floor,
@@ -140,7 +149,19 @@ export class GachaHandler {
const { gachaId, hope } = msg;
const roleId: string = session.get('roleId');
return resResult(STATUS.SUCCESS);
for(let { hid } of hope) {
let dicHero = gameData.hero.get(hid);
if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(dicHero.quality != HERO_QUALITY_TYPE.GOLD) {
return resResult(STATUS.GACHA_HOPE_NOT_GOLD);
}
}
let userGacha = await UserGachaModel.updateInfo(roleId, gachaId, 0, { hope: hope.map(cur => { return {...cur, hasGet: false} }) })
return resResult(STATUS.SUCCESS, {
gachaId,
hope: userGacha.hope
});
}
/**
@@ -153,6 +174,23 @@ export class GachaHandler {
const { gachaId } = msg;
const roleId: string = session.get('roleId');
let userGacha = await UserGachaModel.findByRole(roleId, gachaId, 0);
if(userGacha.point < RECRUIT.RECRUIT_BONUS_RECRUIT) return resResult(STATUS.GACHA_TURNTABLE_POINT_NOT_ENOUGH)
let { dic: { quality } } = getRandomWithWeight(gameData.gachaTurntable);
// 根据品质查武将
let pool = getAllHeroByQuality(quality);
let hero = getRandEelm(pool);
let contentId = gameData.gachaContentHero.get(hero[0]);
let result = new GachaResult(contentId);
result.setHero(hero[0]);
// 获得或者转成碎片
// 扣除积分
// 记录
return resResult(STATUS.SUCCESS);
}
@@ -163,10 +201,33 @@ export class GachaHandler {
* @param {BackendSession} session
* @memberof GachaHandler
*/
async setPickHero(msg: { gachaId: number, pickHero: number }, session: BackendSession) {
const { gachaId, pickHero } = msg;
async setPickHero(msg: { gachaId: number, activityId: number, pickHero: number }, session: BackendSession) {
const { gachaId, activityId, pickHero } = msg;
const roleId: string = session.get('roleId');
if(gachaId != GACHA_ID.ASSIGN && gachaId != GACHA_ID.TIMELIMIT)
return resResult(STATUS.WRONG_PARMS);
let dicHero = gameData.hero.get(pickHero);
if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let heroes: number[] = [];
if(gachaId == GACHA_ID.TIMELIMIT) {
let activityData = await ActivityModel.findActivity(activityId, true);
if(!activityData) return resResult(STATUS.ACTIVITY_MISSING);
let gachaData = new GachaData(activityData);
heroes = gachaData.heroes;
if(!heroes.includes(pickHero)) {
return resResult(STATUS.GACHA_CAN_NOT_PICK)
}
}
let userGacha = await UserGachaModel.updateInfo(roleId, gachaId, activityId, { pickHero })
return resResult(STATUS.SUCCESS, {
gachaId,
heroes,
pickHero: userGacha.pickHero
});
return resResult(STATUS.SUCCESS);
}
}

14
game-server/app/servers/activity/handler/sevenDaysHandler.ts
View File

@@ -81,11 +81,8 @@ export class SevenDaysHandler {
// 根据dic_hero 获得 1. 碎片id 2. 碎片数量 3. 初始武将星级 4. 初始品质
let dicHero = gameData.hero.get(hid);
if (!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let { pieceId, quality, initialStars: star, pieceCount, jobid: job, name: hName, initialSkin } = dicHero;
// createHero
let hero = await createHero(roleId, sid, serverId, {
roleId, serverId, roleName, hid, hName, star, quality, job, skins: [{ id: initialSkin, enable: true }]
});
let hero = await createHero(roleId, roleName, sid, serverId, { hid });
addHeros.push(hero);
}
}
@@ -139,12 +136,11 @@ export class SevenDaysHandler {
// 根据dic_hero 获得 1. 碎片id 2. 碎片数量 3. 初始武将星级 4. 初始品质
let dicHero = gameData.hero.get(hid);
if (!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let { pieceId, quality, initialStars: star, pieceCount, jobid: job, name: hName, initialSkin } = dicHero;
// createHero
let hero = await createHero(roleId, sid, serverId, {
roleId, serverId, roleName, hid, hName, star, quality, job, skins: [{ id: initialSkin, enable: true }]
});
addHeros.push(hero);
let { heroes } = await createHero(roleId, roleName, sid, serverId, { hid });
for(let hero of heroes) {
addHeros.push(hero);
}
}
}

2
game-server/app/servers/battle/handler/normalBattleHandler.ts
View File

@@ -344,7 +344,7 @@ export class NormalBattleHandler {
});
// 任务
await checkTaskWithWar(roleId, sid, funcs, TASK_TYPE.BATTLE_MAIN_SWEEP, warInfo, [], count, 0);
await checkTaskWithWar(roleId, sid, funcs, TASK_TYPE.BATTLE_MAIN_SWEEP, battleId, [], count, 0);
return resResult(STATUS.SUCCESS, {
battleId, count,

4
game-server/app/servers/battle/handler/pvpHandler.ts
View File

@@ -191,8 +191,8 @@ export class PvpHandler {
return resResult(STATUS.BATTLE_MISS_INFO);
}
let checkHeroes = await checkBattleHeroesByHid(roleId, heroes);
if(!checkHeroes) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
let { isOK } = await checkBattleHeroesByHid(roleId, heroes);
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);

10
game-server/app/servers/role/handler/heroHandler.ts
View File

@@ -134,17 +134,15 @@ export class HeroHandler {
// 根据dic_hero 获得 1. 碎片id 2. 碎片数量 3. 初始武将星级 4. 初始品质
let dicHero = gameData.hero.get(hid);
if(!dicHero) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let {pieceId, quality, initialStars: star, pieceCount, jobid: job, name: hName, initialSkin} = dicHero;
let {pieceId, quality, pieceCount} = dicHero;
// 碎片数量是否足够
let costResult = await handleCost(roleId, sid, [{id: pieceId, count: pieceCount}]);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// createHero
let hero = await createHero(roleId, sid, serverId, {
roleId, serverId, roleName, hid, hName, star, quality, job, skins:[{id: initialSkin, enable: true}]
});
let { heroes } = await createHero(roleId, roleName, sid, serverId, { hid });
pushComposeOrangeHero(roleId, roleName, serverId, hero);
return resResult(STATUS.SUCCESS, {curHero: returnHeroCeRatio(hero)});
pushComposeOrangeHero(roleId, roleName, serverId, heroes[0]);
return resResult(STATUS.SUCCESS, {curHero: heroes[0]});
}
// 武将升级

18
game-server/app/services/gachaService.ts
View File

@@ -15,7 +15,7 @@ import { RECRUIT } from "../pubUtils/dicParam";
*/
export async function getLimitGacha(activityId: number) {
let activityData: ActivityModelType = await ActivityModel.findActivity(activityId, true);
let activityData = await ActivityModel.findActivity(activityId, true);
if(!activityData) return false;
let gachaData = new GachaData(activityData);
@@ -224,10 +224,9 @@ function getPoolByHope(hope: Hope[], qualtiy: number) {
if(h.hasGet) hasGetHope.push(h.id);
}
let list = decodeArrayListStr(RECRUIT.RECRUIT_WISH_LIST).map(cur => {
let curHope = hopeMap.get(parseInt(cur[0]));
return { id: parseInt(cur[0]), hasGet: curHope?.hasGet||false, weight: parseInt(cur[1]) }
});
let list = gameData.gachaHope.map(cur => {
return {...cur, hasGet: hopeMap.get(cur.id)?.hasGet||false};
})
let { dic: { id, hasGet } } = getRandomWithWeight(list);
if(id == 0 || hasGet) {
return getAllHeroByQuality(qualtiy).filter(cur => !hasGetHope.includes(cur) );
@@ -249,7 +248,7 @@ function getPoolByHope(hope: Hope[], qualtiy: number) {
* 根据品质获得武将池
* @param quality 品质
*/
function getAllHeroByQuality(quality: number) {
export function getAllHeroByQuality(quality: number) {
if(quality == 0) return [ GACHA_OCCUPY_HID ];
let allHero: number[] = [];
@@ -300,10 +299,3 @@ function getSuitPaper(lv: number) {
}
return items;
}
export function transPiece(hid: number) {
let dicHero = gameData.hero.get(hid);
let { pieceId, quality } = dicHero;
let dicPiece = decodeIdCntArrayStr(RECRUIT.RECRUIT_CHANGE_SHARD, 1); // 多少品质对应多少碎片
return { pieceId, count: dicPiece.get(quality.toString()) }
}

2
game-server/app/services/normalBattleService.ts
View File

@@ -87,7 +87,7 @@ export async function checkBattleHeroesByHid(roleId: string, heroes: Array<numbe
let hero = findHeroes.find(cur => cur.hid == hid);
if (!hero) flag = false;
}
return flag;
return { isOK: flag, heroes: findHeroes };
}
export async function updateWarStar(roleId: string, battleId: number, warType: number, star: number) {

74
game-server/app/services/rewardService.ts
View File

@@ -8,14 +8,15 @@ import { calAllHeroCe, pushCalPlayerCe, pushCalAllHeroCe } from './playerCeServi
import { ItemModel } from '../db/Item';
import { STATUS } from '../consts/statusCode';
import { pinus } from 'pinus';
import { addEquips, addBags, addSkins, addFigure, unlockFigure as pubUnlockFigure, createHero as pubCreateHero, createHeroes as pubCreateHeroes } from '../pubUtils/itemUtils';
import { EquipInter, ItemInter, BagInter } from '../pubUtils/interface';
import { addEquips, addBags, addSkins, addFigure, unlockFigure as pubUnlockFigure, createHeroes as pubCreateHeroes, transPiece } from '../pubUtils/itemUtils';
import { EquipInter, ItemInter, BagInter, RewardInter } from '../pubUtils/interface';
import { gameData } from '../pubUtils/data';
import { uniq, indexOf, findIndex } from 'underscore';
import { HeroModel, HeroUpdate } from '../db/Hero';
import { HeroModel, HeroUpdate, HeroType } from '../db/Hero';
import { Figure } from '../domain/dbGeneral';
import { Rank } from './rankService';
import { pushTaskUpdate } from './taskService';
import { CreateHeroParam } from '../domain/roleField/hero';
export async function handleFixedReward(roleId: string, roleName: string, sid: string, rewardStr: string, multi: number) {
let reward = parseGoodStr(rewardStr);
@@ -311,38 +312,51 @@ export async function pushFigureUpdate(roleId: string, sid: string, figureInfo:
* @param serverId
* @param heroInfo
*/
export async function createHeroes(roleId: string, sid: string, serverId: number, heroInfo: HeroUpdate[]) {
let { heroes, role, figureInfo, calHeroResults, calAllHeroResults, taskPushMessage } = await pubCreateHeroes(roleId, heroInfo);
export async function createHeroes(roleId: string, roleName: string, sid: string, serverId: number, heroInfo: CreateHeroParam[]) {
let r = new Rank(REDIS_KEY.HERO_NUM_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, role.heroNum, role.heroNumUpdatedAt, role);
let hids = heroInfo.map(cur => cur.hid);
let userHeroesMap = await HeroModel.findMapByHidRange(hids, roleId);
await pushFigureUpdate(roleId, sid, figureInfo);
for(let calHeroResult of calHeroResults) {
await pushCalPlayerCe(roleId, sid, calHeroResult);
}
for(let calAllHeroResult of calAllHeroResults) {
await pushCalAllHeroCe(roleId, sid, calAllHeroResult);
let newHeroInfo: CreateHeroParam[] = [], pieces: ItemInter[] = [];
for(let h of heroInfo) {
if(userHeroesMap.has(h.hid)) {
let {pieceId, count} = transPiece(h.hid);
pieces.push({ id: pieceId, count });
} else {
newHeroInfo.push(h)
}
}
pushTaskUpdate(roleId, sid, null, taskPushMessage);
let resultHeroes: HeroType[], resultItems: ItemInter[];
if(newHeroInfo.length > 0) {
let { heroes, role, figureInfo, calHeroResults, calAllHeroResults, taskPushMessage } = await pubCreateHeroes(roleId, roleName, serverId, newHeroInfo);
return heroes;
let r = new Rank(REDIS_KEY.HERO_NUM_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, role.heroNum, role.heroNumUpdatedAt, role);
await pushFigureUpdate(roleId, sid, figureInfo);
for(let calHeroResult of calHeroResults) {
await pushCalPlayerCe(roleId, sid, calHeroResult);
}
for(let calAllHeroResult of calAllHeroResults) {
await pushCalAllHeroCe(roleId, sid, calAllHeroResult);
}
pushTaskUpdate(roleId, sid, null, taskPushMessage);
resultHeroes = heroes;
}
if(pieces.length > 0) {
let goods = await addItems(roleId, roleName, sid, pieces);
resultItems = goods;
}
return { heroes: resultHeroes, goods: resultItems }
}
export async function createHero(roleId: string, sid: string, serverId: number, heroInfo: HeroUpdate) {
let { hero, role, figureInfo, calHeroResult, calAllHeroResult, taskPushMessage } = await pubCreateHero(roleId, heroInfo);
let r = new Rank(REDIS_KEY.HERO_NUM_RANK, { serverId });
await r.setRankWithRoleInfo(roleId, role.heroNum, role.heroNumUpdatedAt, role);
await pushFigureUpdate(roleId, sid, figureInfo);
await pushCalPlayerCe(roleId, sid, calHeroResult);
await pushCalAllHeroCe(roleId, sid, calAllHeroResult);
pushTaskUpdate(roleId, sid, null, taskPushMessage);
return hero;
export async function createHero(roleId: string, roleName: string, sid: string, serverId: number, heroInfo: CreateHeroParam) {
let result = await createHeroes(roleId, roleName, sid, serverId, [heroInfo]);
return result;
}

8
gm-server/app/service/users.ts
View File

@@ -252,11 +252,9 @@ export default class GMUsers extends Service {
if(hero) continue;
let dicHero = ctx.service.utils.getHeroById(hid);
if(!dicHero) continue;
let {quality, initialStars: star, jobid: job, name: hName, initialSkin} = dicHero;
const heroInfo = {
roleId, roleName: role.roleName, hid, hName, star, quality, job, serverId: role.serverId,
lv: hlv, exp: getHeroExpByLv(hlv - 1)||0,
skins:[{id: initialSkin, enable: true}],
roleId, roleName: role.roleName, hid, serverId: role.serverId,
lv: hlv, exp: getHeroExpByLv(hlv - 1)||0
}
heroInfos.push(heroInfo);
}
@@ -267,7 +265,7 @@ export default class GMUsers extends Service {
try {
for(let heroInfo of heroInfos) {
await pubCreateHero(heroInfo.roleId, heroInfo);
await pubCreateHero(heroInfo.roleId, heroInfo.roleName, heroInfo.serverId, heroInfo);
}
return ctx.service.utils.resResult(STATUS.SUCCESS, { uids });
} catch(e) {

2
shared/consts/constModules/sysConst.ts
View File

@@ -689,4 +689,4 @@ export enum GACHA_CONTENT_TYPE {
SUIT_PAPER = 6, // 套装图纸
}
export const GACHA_OCCUPY_HID = 99; // 抽卡里占位的武将
export const GACHA_OCCUPY_HID = 9999; // 抽卡里占位的武将

3
shared/consts/statusCode.ts
View File

@@ -324,6 +324,9 @@ export const STATUS = {
// 抽卡相关 31101-31200
GACHA_COST_NOT_ENOUGH: { code: 31101, simStr: '招募券不足' },
GACHA_NOT_ASSIGN: { code: 31102, simStr: '请选择武将' },
GACHA_HOPE_NOT_GOLD: { code: 31103, simStr: '武将品质错误' },
GACHA_CAN_NOT_PICK: { code: 31004, simStr: '不可选择该武将' },
GACHA_TURNTABLE_POINT_NOT_ENOUGH: { code: 31005, simStr: '转盘积分不足' },
// 社交相关状态 40000 - 49999
SYS_CHANNEL_AUTH_NOT_ENOUGH: { code: 40000, simStr: '无法在系统频道发送消息' },
UPDATE_PRIVATE_MSG_READ_TIME_ERR: { code: 40001, simStr: '更新私聊阅读时间失败' },

13
shared/db/Hero.ts
View File

@@ -156,6 +156,15 @@ export default class Hero extends BaseModel {
return hero;
}
public static async findMapByHidRange(hids: Array<number>, roleId: string, select?: string, getters = false) {
const hero = await HeroModel.findByHidRange(hids, roleId, select, getters);
let map = new Map<number, HeroType>();
for(let h of hero) {
map.set(h.hid, h);
}
return map;
}
public static async findBySeqIdAndRole(seqId: number, roleId: string, lean = true) {
const hero: HeroType = await HeroModel.findOne({ seqId, roleId }).lean(lean);
return hero;
@@ -241,9 +250,9 @@ export default class Hero extends BaseModel {
return result;
}
public static async updateHeroInfo(roleId: string, hid:number, heroUpdate:HeroUpdate, select?: string, lean = true) {
public static async updateHeroInfo(roleId: string, hid:number, heroUpdate:HeroUpdate, select?: string, getters = false) {
delete heroUpdate._id;
let result: HeroType = await HeroModel.findOneAndUpdate({roleId, hid}, {$set:heroUpdate}, {new: true}).select(select).lean(lean);
let result: HeroType = await HeroModel.findOneAndUpdate({roleId, hid}, {$set:heroUpdate}, {new: true}).select(select).lean({ getters });
return result;
}

8
shared/db/UserGacha.ts
View File

@@ -92,7 +92,13 @@ export default class UserGacha extends BaseModel {
}
public static async updateInfo(roleId: string, gachaId: number, activityId: number, update: UserGachaParam) {
let rec: UserGachaType = await UserGachaModel.findOneAndUpdate({ roleId, gachaId, activityId }, { $set: update }, { new: true }).lean();
const doc = new UserGachaModel();
const setOnInsert = doc.toJSON();
delete setOnInsert._id;
for(let key in update) {
delete setOnInsert[key];
}
let rec: UserGachaType = await UserGachaModel.findOneAndUpdate({ roleId, gachaId, activityId }, { $set: update, $setOnInsert: setOnInsert }, { new: true, upsert: true }).lean();
return rec;
}

5
shared/domain/roleField/hero.ts Normal file
View File

@@ -0,0 +1,5 @@
import { HeroUpdate } from '../../db/Hero';
export interface CreateHeroParam extends HeroUpdate {
hid: number;
}

30
shared/pubUtils/data.ts
View File

@@ -187,7 +187,10 @@ export const gameData = {
taskBox: dicTaskBox,
gacha: dicGacha,
gachaContent: dicGachaContent,
gachaContentHero: dicGachaContentHero
gachaContentHero: dicGachaContentHero,
gachaHope: getGachaHopePercent(),
gachaTurntable: getGachaTurntablePercent(),
heroTransPiece: getHeroTransPiece()
};
// 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -582,4 +585,29 @@ export function getRandExpedition(cnt = 1) {
arr.push(dicExpedition);
}
return getRandEelm(arr, cnt);
}
// 抽卡心愿单概率
function getGachaHopePercent() {
let arr = decodeArrayListStr(RECRUIT.RECRUIT_WISH_LIST);
return arr.map(cur => {
return { id: parseInt(cur[0]), weight: parseInt(cur[1]) }
});
}
// 抽卡转盘概率
function getGachaTurntablePercent() {
let arr = decodeArrayListStr(RECRUIT.RECRUIT_BONUS_HERO_QUANTITY);
return arr.map(cur => {
return { quality: parseInt(cur[0]), weight: parseInt(cur[1]) }
});
}
function getHeroTransPiece() {
let map = decodeIdCntArrayStr(RECRUIT.RECRUIT_CHANGE_SHARD, 1);
let newMap = new Map<number, number>();
for(let [id, count] of map) {
newMap.set(parseInt(id), count);
}
return newMap
}

23
shared/pubUtils/itemUtils.ts
View File

@@ -14,6 +14,7 @@ import { Figure } from '../domain/dbGeneral';
import { getBeforeDaySeconds, nowSeconds } from './timeUtil';
import { calPlayerCeAndSave, reCalAllHeroCe } from './playerCe';
import { checkTask, checkTaskWithHeroes, checkTaskWithEquip, accomplishTask } from './taskUtil';
import { CreateHeroParam } from '../domain/roleField/hero';
export async function addSkins(roleId: string, id: number) {
let skinInfo = gameData.fashion.get(id);
@@ -221,12 +222,12 @@ function unlockSingleFigure(dbFigures: Figure[], id: number, unlockDirect = fals
return figure
}
export async function createHero(roleId: string, heroInfo: HeroUpdate) {
let { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage } = await createHeroes(roleId, [heroInfo])
export async function createHero(roleId: string, roleName: string, serverId: number, heroInfo: CreateHeroParam) {
let { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage } = await createHeroes(roleId, roleName, serverId, [heroInfo])
return { hero: heroes[0], role, figureInfo, calHeroResult: calHeroResults[0], calAllHeroResult: calAllHeroResults[0], taskPushMessage }
}
export async function createHeroes(roleId: string, heroInfos: HeroUpdate[]) {
export async function createHeroes(roleId: string, roleName: string, serverId: number, heroInfos: CreateHeroParam[]) {
let heroNum = 0;
let skinIds = new Array<number>();
@@ -234,12 +235,16 @@ export async function createHeroes(roleId: string, heroInfos: HeroUpdate[]) {
let heroes: HeroType[] = [], calHeroResults = [], calAllHeroResults = [];
for (let heroInfo of heroInfos) {
let curHero = await HeroModel.createHero(heroInfo); heroes.push(curHero);
let dicHero = gameData.hero.get(heroInfo.hid);
let { quality, initialStars: star, jobid: job, name: hName, initialSkin } = dicHero;
let info = { roleId, roleName, serverId, quality, star, job, hName, skins: [{id: initialSkin, enable: true}] };
let curHero = await HeroModel.createHero(Object.assign(info, heroInfo));
let calHeroResult = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.INIT, roleId, curHero, {}); calHeroResults.push(calHeroResult);
let calAllHeroResult = await reCalAllHeroCe(HERO_SYSTEM_TYPE.ADD_SKIN, roleId, {}, skinIds); calAllHeroResults.push(calAllHeroResult);
heroes.push(calHeroResult.hero);
conditions.push({ type: FIGURE_UNLOCK_CONDITION.GET_HERO, paramHid: heroInfo.hid });
heroInfo.skins.forEach(cur => {
info.skins.forEach(cur => {
skinIds.push(cur.id);
conditions.push({ type: FIGURE_UNLOCK_CONDITION.GET_SKIN, paramSkinId: cur.id });
});
@@ -257,4 +262,10 @@ export async function createHeroes(roleId: string, heroInfos: HeroUpdate[]) {
//成长任务
await accomplishTask(roleId, TASK_TYPE.HERO_NUM, heroNum)
return { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage }
}
export function transPiece(hid: number) {
let dicHero = gameData.hero.get(hid);
let count = gameData.heroTransPiece.get(dicHero.quality);
return { pieceId: dicHero.pieceId, count }
}

2
shared/pubUtils/playerCe.ts
View File

@@ -37,7 +37,7 @@ export async function calPlayerCeAndSave(type: number, roleId: string, originHer
update.attr = heroAttrs;
update.ce = heroCe;
if (originHero.historyCe < heroCe) update.historyCe = heroCe;
let hero = await HeroModel.updateHeroInfo(roleId, originHero.hid, update); // 更新武将
let hero = await HeroModel.updateHeroInfo(roleId, originHero.hid, update, null, true); // 更新武将 返回是战力缩过的
// 更新到角色
let { topLineup, topLineupCe } = await calculatetopLineup(role, originHero.hid, heroCe, originHero._id); // 计算更新最强五人战力

7
web-server/app/service/Auth.ts
View File

@@ -310,14 +310,11 @@ export default class Auth extends Service {
let dicHero = getHeroInfoById(hid);
if (!dicHero) break;
let { quality, initialStars: star, jobid: job, name: hName, initialSkin } = dicHero;
heroInfos.push({
roleId, roleName: role.roleName, hid, hName, star, quality, job, serverId: role.serverId,
skins: [{ id: initialSkin, enable: true }], lv: DEFAULT_HERO_LV, exp: getHeroExpByLv(DEFAULT_HERO_LV - 1) || 0
hid, lv: DEFAULT_HERO_LV, exp: getHeroExpByLv(DEFAULT_HERO_LV - 1) || 0
});
}
await createHeroes(roleId, heroInfos);
await createHeroes(roleId, role.roleName, serverId, heroInfos);
for (let { id, count } of DEFAULT_ITEMS) {
let dicGoods = gameData.goods.get(id);