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

远征结算和宝箱领取

Browse Source
This commit is contained in:
luying
2020-10-14 20:16:41 +08:00
parent 57d60be3a2
commit 2b1575516f
11 changed files with 1819 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
game-server/app/servers/battle/handler/battleUtils.ts
View File

@@ -1,8 +1,10 @@
import { ActionPointModel } from '../../../db/ActionPoint';
import { BattleDropModel } from '../../../db/BattleDrop';
import { ExpeditionPointModel } from '../../../db/ExpeditionPoint';
import { RoleModel } from '../../../db/Role';
import { getWarById, getWarJsons } from '../../../util/gamedata';
import { getWarById, getWarJsons, getGamedata } from '../../../util/gamedata';
import { decodeStr, Reward } from '../../../util/util';
import { ACTION_POIN, BATTLE_REWARD_TYPE, WAR_JSON_ATTRIBUTE_TYPE } from '../../../consts/consts';
@@ -121,6 +123,8 @@ export class WarReward {
public async saveReward(num: number) {
this.rewards = new Array();
let warType = this.warInfo.warType;
await this.handleFixReward(num);
await this.handleConditionReward(num);
await this.handleRandomReward(num);
@@ -141,7 +145,7 @@ export async function matchPlayers(scale: number, range: number, myCe: number ,e
return false
}
export async function matchRobots(scale: number, myCe: number, robotCe: number, warJsonIndex:any, role, enemyObj: {enemyFrom: number, enemyId: string, enemies: Array<any> }) {
export async function matchRobots(scale: number, myCe: number, robotCe: number, warJsonIndex:any, lv: number, enemyObj: {enemyFrom: number, enemyId: string, enemies: Array<any> }) {
let {json: dicWarJson, fileName } = getWarJsons(warJsonIndex);
if(dicWarJson) {
enemyObj.enemyFrom = 2;
@@ -152,8 +156,9 @@ export async function matchRobots(scale: number, myCe: number, robotCe: number,
let attribute = decodeWarJsonAttribute(enemy.attribute); // 格式：{'hp':1000, ...}
for(let value in attribute) {
attribute[value] *= ratio;
attribute[value] = Math.round(attribute[value]);
}
enemyObj.enemies.push({...enemy, attribute, lv: role.lv});
enemyObj.enemies.push({...enemy, attribute, lv});
}
return true
@@ -172,4 +177,37 @@ export function decodeWarJsonAttribute(attribute) {
}
}
return obj
}
export async function getPointRewardStatus(roleId: string) {
let role = await RoleModel.findByRoleId(roleId);
let {expeditionPoint} = role;
let dicExpeditionPoint = getGamedata('dic_expedition_point');
let pointRewards = {
expeditionPoint,
rewards: dicExpeditionPoint.map(cur => {
return { point: cur.point, received: false }
})
};
let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
if(pointStatusInDatabase) {
let { rewards = [] } = pointStatusInDatabase;
pointRewards.rewards.forEach(cur => {
let obj = rewards.find(ccur => ccur.point == cur.point);
if(obj) cur.received = obj.received;
});
}
return pointRewards
}
export async function getCEScaleAndRange(roleId: string, curDicExpedition: any) {
// 匹配，判断是不是新手期
const role = await RoleModel.findByRoleId(roleId);
let now = new Date();
let today = now.setHours(0,0,0,0);
let isNew = today - role.createdAt.getTime() <= 3*24*60*60*1000;
let scale = isNew?curDicExpedition.CEScaleNew:curDicExpedition.CEScale;
let range = isNew?curDicExpedition.CERangeNew:curDicExpedition.CERange;
return {scale, range, lv: role.lv}
}

71
game-server/app/servers/battle/handler/eventBattleHandler.ts
View File

@@ -2,8 +2,8 @@ import { Application, BackendSession, FrontendOrBackendSession } from 'pinus';
import { getGamedata } from '../../../util/gamedata';
import { EventRecordModel } from '../../../db/EventRecord';
import { RoleModel } from '../../../db/Role';
import { genCode, decodeStr, decodeStrSingle, Reward, getRandomWithWeight } from '../../../util/util';
import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_TYPE, EVENT_RANDOM_TYPE_ONE_OPEN } from '../../../consts/consts';
import { genCode, decodeStr, decodeStrSingle, Reward } from '../../../util/util';
import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_TYPE } from '../../../consts/consts';
export default function(app: Application) {
return new EventBattleHandler(app);
@@ -177,55 +177,36 @@ async function refreshEvent(num: number, roleId: string, roleName: string, t) {
suitLevel = decodeStrSingle('eventSuitLevel', suitLevel);
return suitLevel.min <= role.lv && suitLevel.max >= role.lv
});
if(EVENT_RANDOM_TYPE_ONE_OPEN) { // 每轮进行记录，保证每次随机出的不重复
let historyRecord = await EventRecordModel.getHostoryEventRecord(roleId);
let {history, turn} = historyRecord;
let randomList = dicEvent.filter(cur => {
return history.find(ccur => {
return ccur.eventId != cur.eventID;
});
let historyRecord = await EventRecordModel.getHostoryEventRecord(roleId);
let {history, turn} = historyRecord;
let randomList = dicEvent.filter(cur => {
return history.find(ccur => {
return ccur.eventId != cur.eventID;
});
console.log(JSON.stringify(randomList));
for(let i = 0; i < num; i++) {
if(randomList.length == 0) { // 刷新的3个事件不重复
turn ++;
randomList = [...dicEvent];
}
let {dic, index} = getRandomWithWeight(randomList);
if(!dic) break;
let eventCode = genCode(8);
let data = await EventRecordModel.saveEventRecord(eventCode, {
roleId, refTime: t, eventId: dic.eventID,
roleName, turn, type: dic.eventType, battleId: dic.warId||0, quality: dic.quality,
status: EVENT_RECORD_STATUS.WAITING
});
event.push(data)
randomList.splice(index, 1);
}
} else {
let randomList = dicEvent;
for(let i = 0; i < num; i++) {
let {dic} = getRandomWithWeight(randomList);
console.log('****', JSON.stringify(randomList))
if(!dic) break;
let eventCode = genCode(8);
let data = await EventRecordModel.saveEventRecord(eventCode, {
roleId, refTime: t, eventId: dic.eventID,
roleName, type: dic.eventType, battleId: dic.warId||0, quality: dic.quality,
status: EVENT_RECORD_STATUS.WAITING
});
event.push(data)
});
console.log(JSON.stringify(randomList));
for(let i = 0; i < num; i++) {
if(randomList.length == 0) { // 一轮刷新过，开始新的一轮，保证所有事件都能刷新一遍
turn ++;
randomList = [...dicEvent];
}
if(randomList.length == 0) break; // 如果还是为0，pass
let index = Math.floor(Math.random() * randomList.length);
let dic = randomList[index];
let eventCode = genCode(8);
let data = await EventRecordModel.saveEventRecord(eventCode, {
roleId, refTime: t, eventId: dic.eventID,
roleName, turn, type: dic.eventType, battleId: dic.warId||0, quality: dic.quality,
status: EVENT_RECORD_STATUS.WAITING
});
event.push(data)
randomList.splice(index, 1);
}
return event;
}
function pushEventMsg(app, roleId, channelName, msg ) {
console.log('***pushEventMsg', channelName)
let channelService = app.get('channelService');

279
game-server/app/servers/battle/handler/expeditionBattleHandler.ts
View File

@@ -1,11 +1,13 @@
import { Application, BackendSession } from 'pinus';
import { getGamedata } from '../../../util/gamedata';
import { getGamedata, getWarById } from '../../../util/gamedata';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { ExpeditionRecordModel } from '../../../db/ExpeditionRecord';
import { ExpeditionWarRecordModel } from '../../../db/ExpeditionWarRecord';
import { ExpeditionPointModel } from '../../../db/ExpeditionPoint';
import { RoleModel } from '../../../db/Role';
import { calculateSumCE, genCode } from '../../../util/util';
import { matchPlayers, matchRobots } from './battleUtils';
import { calculateSumCE, genCode, Reward, decodeStr } from '../../../util/util';
import { matchPlayers, matchRobots, getAp, setAp, WarReward, getPointRewardStatus, getCEScaleAndRange } from './battleUtils';
import { EXPEDITION_INCREASE_POINT } from '../../../consts/consts';
export default function(app: Application) {
return new ExpeditionBattleHandler(app);
@@ -39,26 +41,12 @@ export class ExpeditionBattleHandler {
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCode(expeditionCode);
let curLv = 0;
if(expeditionWarRecord.length > 0) {
curLv = expeditionRecord[expeditionWarRecord.length - 1].expeditionId;
curLv = expeditionWarRecord[expeditionWarRecord.length - 1].expeditionId;
}
// 点数，和宝箱领取状态
let role = await RoleModel.findByRoleId(roleId);
let {expeditionPoint} = role;
let dicExpeditionPoint = getGamedata('dic_expedition_point');
let pointRewards = {
expeditionPoint,
rewards: dicExpeditionPoint.map(cur => {
return { point: cur.point, received: false }
})
};
let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
if(pointStatusInDatabase) {
let { rewards = [] } = pointStatusInDatabase;
pointRewards.rewards = rewards.map(cur => {
return { point: cur.point, received: cur.received }
})
}
let pointRewards = await getPointRewardStatus(roleId);
return {
code: 200,
data: {
@@ -86,7 +74,6 @@ export class ExpeditionBattleHandler {
// 计算我方战斗力（最高五人）
let myCe = await calculateSumCE(roleId, 1, { num: 5 });
console.log('****myCe', myCe);
let enemyObj = {
enemyFrom: 0,
enemyId: '',
@@ -95,24 +82,14 @@ export class ExpeditionBattleHandler {
let dicExpedition = getGamedata('dic_expedition');
let curDicExpedition = dicExpedition.find(cur => cur.id == expeditionId);
// 匹配，判断是不是新手期
const role = await RoleModel.findByRoleId(roleId);
let now = new Date();
let today = now.setHours(0,0,0,0);
let isNew = today - role.createdAt.getTime() <= 3*24*60*60*1000;
let scale = isNew?curDicExpedition.CEScaleNew:curDicExpedition.CEScale;
let range = isNew?curDicExpedition.CERangeNew:curDicExpedition.CERange;
// 获取系数和步长
let {scale, range, lv} = await getCEScaleAndRange(roleId, curDicExpedition);
// 优先匹配其他玩家
let flag = await matchPlayers(scale, range, myCe, enemyObj);
// 当数量不够时使用机器人匹配
if(!flag) {
flag = await matchRobots(scale, myCe, curDicExpedition.ce, curDicExpedition.json, role, enemyObj);
flag = await matchRobots(scale, myCe, curDicExpedition.ce, curDicExpedition.json, lv, enemyObj);
}
console.log('**********flag', flag)
if(!flag) {
return {code: 202, data:'无法匹配对手'};
}
@@ -139,23 +116,177 @@ export class ExpeditionBattleHandler {
* 进入战斗
* 记录我军数据，生成战斗唯一表示，记录状态
*/
async checkBattle(msg: { }, session: BackendSession) {
async checkBattle(msg: { expeditionCode: string, expeditionId: number, battleId: number, heroes: Array<number> }, session: BackendSession) {
const { expeditionCode, expeditionId, battleId, heroes } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let warInfo = getWarById(battleId);
if(!warInfo) {
return { code: 202, data: "缺少关卡信息" }
}
let apJson = await getAp(Date.now(), roleId);
let {ap} = apJson;
if(ap < warInfo.cost) {
return { code: 202, data: "体力不足" }
}
// 前置关卡是否挑战过
let previousGk = warInfo.previousGk;
if(previousGk) {
let preBattle = await BattleRecordModel.getBattleRecordByIdAndStatus(roleId, previousGk, 1);
if(!preBattle) return {code: 202, data: '需要完成上一关才可以挑战'};
}
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if(!expeditionWarRecord ) {
return {code: 202, data: '需要先匹配好对手'}
}
if(expeditionWarRecord.battleStatus == 1) {
return {code: 202, data: '已挑战过这一关'}
}
const battleCode = genCode(8);
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: {
roleId, roleName, battleId,
status: 0,
warName: warInfo.gk_name,
warType: warInfo.warType,
record: { heroes }
}
}, true);
let result = await ExpeditionWarRecordModel.updateStatus(expeditionCode, expeditionId, 0, battleCode);
return {
code: 200,
data: {
expeditionCode,
expeditionId,
battleId,
battleCode,
battleStatus: result.battleStatus,
apJson
}
}
}
/**
* 战斗结算
* 结算战斗奖励，更新远征状态
*/
async battleEnd(msg: { }, session: BackendSession) {
async battleEnd(msg: { expeditionCode: string, expeditionId: number, battleCode: string, battleId: number, isSuccess: boolean, heroes: Array<{actorId: number, hp: number, ap: number}>, enemies: Array<{dataId: number, hp: number, ap: number}>, star: number }, session: BackendSession) {
const { expeditionCode, battleCode, battleId, expeditionId, isSuccess, heroes, star, enemies } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let warInfo = getWarById(battleId);
if(!warInfo) {
return { code: 202, data: "缺少关卡信息" }
}
if(!warInfo.hasOwnProperty('cost')) {
warInfo['cost'] = 0;
}
const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode);
if(!BattleRecord || BattleRecord.status != 0) {
return { code: 202, data: '关卡状态错误' }
}
let flag = 1; // 对比hero信息
let { record: { heroes: dbHeroes } } = BattleRecord;
for(let {actorId} of heroes) {
if(dbHeroes.indexOf(actorId) == -1) flag = 0;
}
if(!flag) {
return { code: 202, data: '关卡信息不同' }
}
const now = Date.now(); // 当前时间戳
let apJson = await setAp(now, roleId, -1 * warInfo.cost); // 扣除体力
if(!apJson) {
return { code: 202, data: '体力不足' }
}
// 检查record
let expeditionRecord = await ExpeditionRecordModel.getExpeditionRecordByCode(expeditionCode);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if(!expeditionRecord|| !expeditionWarRecord) {
return { code: 202, data:'未找到该记录' }
}
// 更新我方剩余血量
await ExpeditionRecordModel.updateHeroStatus(expeditionCode, expeditionRecord.heroes, heroes);
// 更新敌人剩余状态及战斗状态
expeditionWarRecord = await ExpeditionWarRecordModel.updateEnemiesStatus(expeditionCode, expeditionId, isSuccess?1:2, enemies);
// 更新battleRecord状态
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess?1: 2, star }
}, true);
// 更新点数
let role = await RoleModel.increaseExpeditionPoint(roleId, isSuccess?EXPEDITION_INCREASE_POINT:0);
let { expeditionPoint = 0 } = role;
// 关卡奖励
let warReward = new WarReward(roleId, roleName, battleId, isSuccess);
let reward = await warReward.saveReward(1);
return {
code: 200,
data: {
expeditionCode, expeditionId,
battleCode, battleId,
battleStatus: expeditionWarRecord.battleStatus,
goods: reward,
apJson,
expeditionPoint
}
}
}
/**
* 领取战斗宝箱
* 领取宝箱，更新远征状态
*/
async battleReward(msg: { }, session: BackendSession) {
async battleReward(msg: { expeditionCode: string, expeditionId: number }, session: BackendSession) {
const { expeditionCode, expeditionId } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
// 检查expeditionWarRecord的battleStatus
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if(!expeditionWarRecord) {
return {code: 202, data: '未找到该关卡'}
}
if(expeditionWarRecord.battleStatus != 1) {
return {code: 202, data: '需要战斗胜利后才可以领取'}
}
if(expeditionWarRecord.received) {
return {code: 202, data: '已经领取过了'}
}
// 设置expeditionWarRecord的received和rewards
let dicExpedition = getGamedata('dic_expedition');
let curDicExpedition = dicExpedition.find(cur => cur.id == expeditionId);
if(!curDicExpedition) {
return {code: 202, data: '未找到该配置'}
}
let result = await ExpeditionWarRecordModel.updateBoxStatus(expeditionCode, expeditionId, true, curDicExpedition.reward);
let { battleId, battleCode, battleStatus, received } = result;
// 获取东西
let rewards = decodeStr('fixReward', curDicExpedition.reward);
let rewardObject = new Reward(roleId, roleName, rewards);
let goods = await rewardObject.saveReward();
return {
code: 200,
data: {
expeditionCode, expeditionId,
battleId, battleCode, battleStatus, received,
goods
}
}
}
@@ -163,8 +294,47 @@ export class ExpeditionBattleHandler {
* 领取点数宝箱
* 领取点数宝箱，不扣除点数，那么就需要记录领取状态并且有返回
*/
async pointReward(msg: { }, session: BackendSession) {
async pointReward(msg: { point }, session: BackendSession) {
const { point } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let role = await RoleModel.findByRoleId(roleId);
let {expeditionPoint} = role;
let dicExpeditionPoint = getGamedata('dic_expedition_point');
let curDicExpeditionPoint = dicExpeditionPoint.find(cur => cur.point == point);
if(!curDicExpeditionPoint) {
return {code: 202, data: '该点数不能领取奖励'}
}
if(point > expeditionPoint) {
return {code: 202, data: '点数不足'};
}
let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
if(pointStatusInDatabase) {
let {rewards} = pointStatusInDatabase;
let curReward = rewards.find(cur => cur.point == point);
if(curReward && curReward.received) {
return {code: 202, data: '已领取过'}
}
}
// 标记状态
await ExpeditionPointModel.updatePointStatus(roleId, point, curDicExpeditionPoint.reward);
let pointRewards = await getPointRewardStatus(roleId);
let rewards = decodeStr('fixReward', curDicExpeditionPoint.reward);
let rewardObject = new Reward(roleId, roleName, rewards);
let goods = await rewardObject.saveReward();
return {
code: 202,
data: {
pointRewards,
goods
}
}
}
/**
@@ -173,5 +343,38 @@ export class ExpeditionBattleHandler {
*/
async resetPointReward(msg: { }, session: BackendSession) {
let roleId = session.get('roleId');
// let roleName = session.get('roleName');
let pointStatusInDatabase = await ExpeditionPointModel.getExpeditionPoint(roleId);
if(!pointStatusInDatabase) {
return {code: 202, data: '已刷新'}
}
let { rewards } = pointStatusInDatabase;
let dicExpeditionPoint = getGamedata('dic_expedition_point');
let flag: boolean, maxPoint = 0;
for(let dic of dicExpeditionPoint) {
let curReward = rewards.find(cur => cur.point == dic.point);
if(curReward && curReward.received) {
flag = true;
}
if(dic.point > maxPoint) maxPoint = dic.point;
}
if(!flag) {
return {code: 202, data: '宝箱需要领取完才可以刷新'}
}
// 刷新
await ExpeditionPointModel.completeStatus(roleId);
await RoleModel.increaseExpeditionPoint(roleId, maxPoint * -1);
let pointRewards = await getPointRewardStatus(roleId);
return {
code: 200,
data: {
pointRewards
}
}
}
}

2
game-server/app/util/gamedata.ts
View File

@@ -2,7 +2,7 @@ const fs = require('fs');
const path = require('path');
let gamedata = {};
const wars = ['dic_zyz_gk_main', 'dic_zyz_gk_mainElite', 'dic_zyz_gk_daily', 'dic_zyz_gk_event', 'dic_zyz_gk_tower']; // 关卡相关的表
const wars = ['dic_zyz_gk_main', 'dic_zyz_gk_mainElite', 'dic_zyz_gk_daily', 'dic_zyz_gk_event', 'dic_zyz_gk_tower', 'dic_zyz_gk_expedition']; // 关卡相关的表
const allWarInfos = new Map<number, any>();
const towerInfos = new Map<number, any>();

4
shared/consts/consts.ts
View File

@@ -34,7 +34,8 @@ export const WAR_TYPE = {
NORMAL: 1,
DAILY: 2,
EVENT: 3,
TOWER: 4
TOWER: 4,
EXPEDITION: 5
};
// 事件，是否开启保存随机记录方式
@@ -64,6 +65,7 @@ export const EVENT_TYPE = {
};
export const EVENT_START_BATTLE = 101;
export const EXPEDITION_INCREASE_POINT = 2; // 远征每成功一次累计的点数
export const HANG_UP_CONSTS = {
ENABLE_LV: 2,

26
shared/db/ExpeditionPoint.ts
View File

@@ -4,16 +4,15 @@ import { index, getModelForClass, prop } from '@typegoose/typegoose';
/**
* 远征记录
*/
@index({ roleId: 1, eventId: 1 })
@index({ roleId: 1, eventCode: 1 })
@index({ roleId: 1 })
export default class ExpeditionPoint extends BaseModel {
@prop({ required: true })
@prop({ required: true, default: '' })
roleId: string; // 角色 id
@prop({ required: true })
@prop({ required: true, default: 0 })
pointCost: number; // 消耗点数
@prop({ required: true })
@prop({ required: true, default: false })
completed: boolean; // 本轮奖励是否完成
@prop({ required: true, default: [] })
rewards: Array<{point: number, reward: string, received:boolean, recTime: Date}>; // 领取记录
@@ -22,6 +21,23 @@ export default class ExpeditionPoint extends BaseModel {
const result = await ExpeditionPointModel.findOne({ roleId, completed: false }).lean(lean);
return result;
}
public static async updatePointStatus(roleId: string, point: number, reward: string, lean = true) {
const result = await ExpeditionPointModel.findOneAndUpdate(
{ roleId, completed: false },
{ $set: { pointCost: point }, $push: {rewards:{point, reward, received: true, recTime: new Date()}}},
{ new: true, upsert: true }
).lean(lean);
return result;
}
public static async completeStatus(roleId: string, lean = true) {
const result = await ExpeditionPointModel.findOneAndUpdate(
{ roleId, completed: false },
{ $set: {completed: true } }
).lean(lean);
return result;
}
}
export const ExpeditionPointModel = getModelForClass(ExpeditionPoint);

67
shared/db/ExpeditionRecord.ts
View File

@@ -1,33 +1,74 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
class Heroes {
@prop({ required: true })
hid: number; // 敌人id
@prop({ required: true })
hp: number; // 血量
@prop({ required: true })
ap: number; // 怒气
}
/**
* 远征记录
*/
@index({ roleId: 1, eventId: 1 })
@index({ roleId: 1, eventCode: 1 })
@index({ roleId: 1 })
@index({ expeditionCode: 1 })
export default class ExpeditionRecord extends BaseModel {
@prop({ required: true })
@prop({ required: true, default: '' })
roleId: string; // 角色 id
@prop({ required: true })
@prop({ required: true, default: '' })
roleName: string; // 角色 名
@prop({ required: true })
@prop({ required: true, default: '' })
expeditionCode: string; // 远征的唯一标识
@prop({ required: true })
@prop({ required: true, default: 0 })
time: number; // 时间
@prop({ required: true })
heroes: Array<{hid: number, hp: number, cp: number}>; // 我方已出场武将
@prop({ required: true, type: Heroes, default: [] })
heroes: Array<Heroes>; // 我方已出场武将
public static async getTodayRecord(roleId: string, time: number, lean = true) {
const role = await ExpeditionRecordModel.findOne({ roleId, time }).lean(lean);
return role;
const result = await ExpeditionRecordModel.findOne({ roleId, time }).lean(lean);
return result;
}
public static async createTodayRecord(expeditionCode: string, params: { roleId: string, roleName: string, time: number, heroes: Array<{hid: number, hp: number, cp: number}> }, lean = true) {
const role = await ExpeditionRecordModel.findOneAndUpdate({ expeditionCode }, params, { new: true, upsert: true }).lean(lean);
return role;
public static async createTodayRecord(expeditionCode: string, params: { roleId: string, roleName: string, time: number, heroes: Array<Heroes> }, lean = true) {
const result = await ExpeditionRecordModel.findOneAndUpdate({ expeditionCode }, params, { new: true, upsert: true }).lean(lean);
return result;
}
public static async getExpeditionRecordByCode(expeditionCode: string, lean=true) {
const result = await ExpeditionRecordModel.findOne({expeditionCode}).lean(lean);
return result
}
public static async updateHeroStatus(expeditionCode: string, oldHeroes: Array<Heroes>, heroes: Array<{actorId: number, hp: number, ap: number}>, lean=true) {
let pushArr = new Array(), updateArr = new Array();
for(let hero of heroes) {
let {actorId, hp, ap} = hero;
let obj = oldHeroes.find(cur => cur.hid == actorId);
if(!!obj) {
updateArr.push({hid: actorId, hp, ap});
} else {
pushArr.push({hid: actorId, hp, ap})
}
}
console.log(JSON.stringify(oldHeroes), JSON.stringify(heroes), JSON.stringify(pushArr), JSON.stringify(updateArr))
for(let {hid, hp, ap} of updateArr) {
await ExpeditionRecordModel.findOneAndUpdate(
{expeditionCode, 'heroes.hid': hid },
{$set: {'heroes.$.hid': hid, 'heroes.$.hp': hp, 'heroes.$.ap': ap}}
)
}
const result = await ExpeditionRecordModel.findOneAndUpdate(
{ expeditionCode },
{ $push: {heroes: {$each: pushArr} } }
)
return result;
}
}

70
shared/db/ExpeditionWarRecord.ts
View File

@@ -1,6 +1,44 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
class Enemies {
@prop({ required: true })
actorId: number; // 敌人id
@prop({ required: false })
actorName: string; // 敌人名
@prop({ required: false })
dataId: number; // 战场中唯一指向武将的代码
@prop({ required: false })
relation: number; // 角色属于我方还是地方
@prop({ required: false })
outIndex: number; // 程序将信息存入数组顺序
@prop({ required: false })
x: number; // 战场x坐标
@prop({ required: false })
y: number; // 战场y坐标
@prop({ required: false })
direction: number; // 朝向
@prop({ required: false })
var: number; // 变量
@prop({ required: false })
lv: number; // 角色等级
@prop({ required: false })
hide: number; // 是否隐藏
@prop({ required: false })
initial_ai: number; // AI类型
@prop({ required: true })
attribute: {hp: number, atk: number, matk: number, def: number, mdef: number, agi: number, luk: number, speed: number, hit: number, cri: number, flee: number, antCri: number, damageIncrease: number, damageDecrease: number, defIgnore: number, bloodSuck: number, ap: number}; // 属性
@prop({ required: false })
skill: string; // 技能
@prop({ required: false })
seid: string; // 技能
@prop({ required: false })
star: number; // 角色星级
@prop({ required: false })
spine: string; // S动画
}
/**
* 远征记录
*/
@@ -18,7 +56,7 @@ export default class ExpeditionWarRecord extends BaseModel {
@prop({ required: true, default: '' })
battleCode: string; // 关联关卡唯一值
@prop({ required: true, default: 0 })
battleStatus: number; // 是否通过
battleStatus: number; // 是否通过, 0-挑战中 1-成功 2-挑战失败
@prop({ required: true, default: false })
received: boolean; // 本关战胜后宝箱是否领取
@prop({ required: true, default: false })
@@ -27,8 +65,8 @@ export default class ExpeditionWarRecord extends BaseModel {
enemyFrom: number; // 敌军数据来源：1-配表的敌军队，2-玩家
@prop({ required: true, default: '' })
enemyId: string; // 敌军队伍id或玩家id
@prop({ required: true, default: [] })
enemies: Array<any>; // 敌军数据
@prop({ required: true, type: Enemies, default: [] })
enemies: Array<Enemies>; // 敌军数据
public static async getRecordByCode(expeditionCode: string, lean = true) {
const result = await ExpeditionWarRecordModel.find({ expeditionCode }).select('expeditionId battleId battleCode battleStatus received').sort({expeditionId: 1}).lean(lean);
@@ -47,6 +85,32 @@ export default class ExpeditionWarRecord extends BaseModel {
return result;
}
public static async updateStatus(expeditionCode: string, expeditionId: number, battleStatus: number, battleCode: string, lean = true) {
const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus, battleCode}, {new: true}).lean(lean);
return result;
}
public static async updateEnemiesStatus(expeditionCode: string, expeditionId: number, battleStatus: number, enemies: Array<{dataId: number, hp: number, ap: number}>, lean = true) {
for(let {dataId, hp, ap} of enemies) {
console.log('updateEnemiesStatus',ap)
await ExpeditionWarRecordModel.findOneAndUpdate(
{expeditionCode, expeditionId, 'enemies.dataId': dataId },
{$set: {'enemies.$.attribute.hp': hp, 'enemies.$.attribute.ap': ap}}
)
}
const result = ExpeditionWarRecordModel.findOneAndUpdate(
{expeditionCode, expeditionId},
{$set: {battleStatus}},
{new: true}
);
return result;
}
public static async updateBoxStatus(expeditionCode: string, expeditionId: number, received: boolean, reward: string, lean = true) {
const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {received, reward}, {new: true}).lean(lean);
return result;
}
}
export const ExpeditionWarRecordModel = getModelForClass(ExpeditionWarRecord);

7
shared/db/Role.ts
View File

@@ -137,13 +137,18 @@ export default class Role extends BaseModel {
public static async setEventStatus(roleId: string, eventStatus: number, lean = true) {
await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }).lean(lean);
await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }, {new: true}).lean(lean);
}
public static async towerLvUp(roleId: string, lean = true) {
let role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}}).lean(lean);
return role;
}
public static async increaseExpeditionPoint(roleId: string, point: number, lean = true) {
let role = await RoleModel.findOneAndUpdate({roleId}, {$inc: { expeditionPoint: point }}, {new: true}).lean(lean);
return role;
}
}
export const RoleModel = getModelForClass(Role);

1355
shared/resource/jsons/dic_zyz_gk_main.json
View File

File diff suppressed because one or more lines are too long

10
shared/resource/warJsons/4001.json
View File

@@ -13,7 +13,7 @@
"hide": 0,
"initial_ai": 1,
"bossid": 0,
"attribute": "1&1000|2&2000|3&3000",
"attribute": "1&1000|2&2000|3&3000|17&100",
"skill": "&",
"seid": "&",
"star": 0,
@@ -33,7 +33,7 @@
"hide": 0,
"initial_ai": 1,
"bossid": 0,
"attribute": "&",
"attribute": "1&1000|2&2000|3&3000|17&100",
"skill": "&",
"seid": "&",
"star": 0,
@@ -53,7 +53,7 @@
"hide": 0,
"initial_ai": 1,
"bossid": 0,
"attribute": "&",
"attribute": "1&1000|2&2000|3&3000|17&100",
"skill": "&",
"seid": "&",
"star": 0,
@@ -73,7 +73,7 @@
"hide": 0,
"initial_ai": 1,
"bossid": 0,
"attribute": "&",
"attribute": "1&1000|2&2000|3&3000|17&100",
"skill": "&",
"seid": "&",
"star": 0,
@@ -93,7 +93,7 @@
"hide": 0,
"initial_ai": 1,
"bossid": 0,
"attribute": "&",
"attribute": "1&1000|2&2000|3&3000|17&100",
"skill": "&",
"seid": "&",
"star": 0,