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

任务：埋点48/71

Browse Source
This commit is contained in:
luying
2021-04-18 15:09:56 +08:00
parent 9f4f346447
commit 4bd4513ae6
11 changed files with 186 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,12 +1,13 @@
import { Application, BackendSession } from 'pinus';
import { getGamedata } from '../../../pubUtils/gamedata';
import { EventRecordModel } from '../../../db/EventRecord';
import { RoleModel } from '../../../db/Role';
import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS } from '../../../consts';
import { EVENT_STATUS, EVENT_RECORD_STATUS, EVENT_ANSWER_STATUS, TASK_TYPE } from '../../../consts';
import { checkEvent, checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz } from '../../../services/eventSercive';
import { handleFixedReward } from '../../../services/rewardService';
import { handleFixedReward, addItems } from '../../../services/rewardService';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { checkTask } from '../../../services/taskService';
import { gameData } from '../../../pubUtils/data';
export default function(app: Application) {
return new EventBattleHandler(app);
@@ -100,17 +101,16 @@ export class EventBattleHandler {
if(dataEventId != eventId) {
return resResult(STATUS.EVENT_WRONG_ID);
}
let dicEvent = getGamedata('dic_zyz_event');
let curEvent = dicEvent.find(cur => cur.eventID == eventId);
if(!curEvent) {
let dicEvent = gameData.event.get(eventId);
if(!dicEvent) {
return resResult(STATUS.EVENT_INFO_NOT_FOUND);
}
// 保存状态
let result = await EventRecordModel.setStatusByCode(roleId, eventCode, isSuccess?EVENT_RECORD_STATUS.SUCCESS_RECEIVED:EVENT_RECORD_STATUS.FAIL_RECEIVED);
// 保存奖励
let rewardStr = isSuccess?curEvent.winReward:curEvent.loseReward;
let goods = await handleFixedReward(roleId, roleName, sid, rewardStr, 1);
let reward = isSuccess?dicEvent.winReward:dicEvent.loseReward;
let goods = await addItems(roleId, roleName, sid, reward);
if(eventStatus == EVENT_STATUS.STARTING) { // 如果是第一次开启的挑战，保存成开启状态
await RoleModel.setEventStatus(roleId, EVENT_STATUS.OPEN);
// 第一场时间挑战完，开始正常刷新事件，所以刷新时间也重置起来
@@ -119,6 +119,8 @@ export class EventBattleHandler {
}
// 推送消息刷新
await checkEvent(session, true);
// 任务
await checkTask(roleId, sid, TASK_TYPE.BATTLE_EVENT, 1, true, { eventType: dicEvent.eventType })
return resResult(STATUS.SUCCESS, {
isSuccess,
eventCode: result.eventCode,

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

@@ -7,13 +7,14 @@ import { ExpeditionPointModel } from '../../../db/ExpeditionPoint';
import { RoleModel } from '../../../db/Role';
import { calculateSumCE, genCode } from '../../../pubUtils/util';
import { getPointRewardStatus, getResetRemainCnt, findOrCreateEnemies } from '../../../services/expeditionService';
import { EXPEDITION_CONST, EXPEDITION_WAR_RECORD_STATUS, LINEUP_NUM } from '../../../consts';
import { EXPEDITION_CONST, EXPEDITION_WAR_RECORD_STATUS, LINEUP_NUM, TASK_TYPE } from '../../../consts';
import { WarReward } from '../../../services/warRewardService';
import { handleFixedReward } from '../../../services/rewardService';
import { getAp, setAp } from '../../../services/actionPointService';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { checkBattleHeroes, roleLevelup } from '../../../services/normalBattleService';
import { checkTaskWithWar } from '../../../services/taskService';
export default function(app: Application) {
return new ExpeditionBattleHandler(app);
@@ -146,7 +147,7 @@ export class ExpeditionBattleHandler {
* 记录我军数据，生成战斗唯一表示，记录状态
*/
async checkBattle(msg: { expeditionCode: string, expeditionId: number, battleId: number, heroes: Array<number> }, session: BackendSession) {
const { expeditionCode, expeditionId, battleId, heroes } = msg;
const { expeditionCode, expeditionId, battleId, heroes: seqIds } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let warInfo = getWarById(battleId);
@@ -167,8 +168,8 @@ export class ExpeditionBattleHandler {
if(!preBattle) return resResult(STATUS.BATTLE_NEED_PREVIOUS_GK);
}
let checkHeroes = await checkBattleHeroes(roleId, heroes);
if(!checkHeroes) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
let { isOK, heroes } = await checkBattleHeroes(roleId, seqIds);
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
let expeditionWarRecord = await ExpeditionWarRecordModel.getRecordByCodeAndId(expeditionCode, expeditionId);
if(!expeditionWarRecord ) {
@@ -185,7 +186,7 @@ export class ExpeditionBattleHandler {
status: 0,
warName: warInfo.gk_name,
warType: warInfo.warType,
record: { heroes }
record: { heroes, seqIds }
}
}, true);
@@ -226,9 +227,9 @@ export class ExpeditionBattleHandler {
}
let flag = 1; // 对比hero信息
let { record: { heroes: dbHeroes } } = BattleRecord;
let { record: { heroes: dbHeroes, seqIds: dbSeqIds } } = BattleRecord;
for(let {dataId} of heroes) {
if(dbHeroes.indexOf(dataId) == -1) flag = 0;
if(dbSeqIds.indexOf(dataId) == -1) flag = 0;
}
if(!flag) {
return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
@@ -268,6 +269,7 @@ export class ExpeditionBattleHandler {
// 更新下一关状态
await ExpeditionWarRecordModel.updateStatus(expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);
}
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_WITH_HERO, battleId, dbHeroes, 1, star);
return resResult(STATUS.SUCCESS, {
expeditionCode, expeditionId,

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

@@ -3,7 +3,7 @@ import { BattleRecordModel } from '../../../db/BattleRecord';
import { BattleSweepRecordModel } from '../../../db/BattleSweepRecord';
import { getWarById, } from '../../../pubUtils/gamedata';
import { genCode } from '../../../pubUtils/util';
import { WAR_TYPE, EVENT_STATUS, FUNC_OPT_TYPE, MSG_SOURCE, REDIS_KEY } from '../../../consts';
import { WAR_TYPE, EVENT_STATUS, FUNC_OPT_TYPE, MSG_SOURCE, REDIS_KEY, TASK_TYPE } from '../../../consts';
import { checkDaily, checkDailyAndIncrease } from '../../../services/dailyBattleService';
import { checkTowerWar, towerBattleEnd } from '../../../services/battleService';
import { WarReward } from '../../../services/warRewardService';
@@ -20,6 +20,7 @@ import { gameData } from '../../../pubUtils/data';
import { pushMysteryFirstMsg, pushTowerMsg, pushVestigeFirstMsg } from '../../../services/chatService';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { Rank } from '../../../services/rankService';
import { checkTaskWithWar, checkTaskInBattleEnd } from '../../../services/taskService';
export default function(app: Application) {
return new NormalBattleHandler(app);
@@ -31,7 +32,7 @@ export class NormalBattleHandler {
// 获取关卡列表
async checkBattle(msg: {battleId: number, heroes: Array<number> }, session: BackendSession) {
const { battleId, heroes } = msg;
const { battleId, heroes: seqIds } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let warInfo = getWarById(battleId);
@@ -56,8 +57,8 @@ export class NormalBattleHandler {
if(preBattle == -1) return resResult(STATUS.BATTLE_NEED_PREVIOUS_GK);
}
let checkHeroes = await checkBattleHeroes(roleId, heroes);
if(!checkHeroes) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
let { isOK, heroes } = await checkBattleHeroes(roleId, seqIds);
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
const battleCode = genCode(8); // 关卡唯一值
let dailyNum = {};
@@ -96,7 +97,7 @@ export class NormalBattleHandler {
status: 0,
warName: warInfo.gk_name,
warType: warInfo.warType,
record: { heroes }
record: { heroes, seqIds }
}
}, true);
@@ -175,9 +176,9 @@ export class NormalBattleHandler {
}
let flag = 1; // 对比hero信息
let { record: { heroes: dbHeroes } } = BattleRecord;
for(let hid of heroes) {
if(dbHeroes.indexOf(hid) == -1) flag = 0;
let { record: { heroes: dbHeroes, seqIds: dbSeqIds } } = BattleRecord;
for(let seqId of dbSeqIds) {
if(dbSeqIds.indexOf(seqId) == -1) flag = 0;
}
if(!flag) {
return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
@@ -268,6 +269,7 @@ export class NormalBattleHandler {
let actordata = await roleLevelup(roleId, isSuccess?warInfo.kingExp:0, session);// 主公升级经验
await checkTaskInBattleEnd(roleId, sid, battleId, dbHeroes, star);
// 返回值：
// towerStatus: false-本层未通过, true-本层已通过
return resResult(STATUS.SUCCESS, {
@@ -339,6 +341,9 @@ export class NormalBattleHandler {
$inc: { count }
});
// 任务
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_MAIN_SWEEP, warInfo, [], count, 0);
return resResult(STATUS.SUCCESS, {
battleId, count,
battleGoods: result,

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

@@ -10,7 +10,7 @@ import { getTaskById, getTowerDataByLv } from '../../../pubUtils/gamedata';
import { decodeArrayStr, resResult, shouldRefresh, calculateNum, getRefTime, genCode } from '../../../pubUtils/util';
import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime, getTasksReward, getTaskStatus, getDoingOrWaitingTasks } from '../../../services/battleService';
import { handleFixedReward, addItems, handleCost } from '../../../services/rewardService';
import { checkBattleHeroes } from '../../../services/normalBattleService';
import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
import { getGoldObject } from '../../../pubUtils/itemUtils';
import { Rank } from '../../../services/rankService';
@@ -241,7 +241,7 @@ export class TowerBattleHandler {
if (task.heroes.length !== taskInfo.actorNeeded) { // 武将数，从策划表中读取
return resResult(STATUS.TOWER_TASK_MAX_HERO);
}
let hasHero = await checkBattleHeroes(roleId, task.heroes);
let hasHero = await checkBattleHeroesByHid(roleId, task.heroes);
if(!hasHero) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
if (tasksCode.indexOf(task.taskCode) === -1) {
return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);

5
game-server/app/services/battleService.ts
View File

@@ -1,7 +1,7 @@
import { HeroModel } from './../db/Hero';
import { HangUpRecordModel } from './../db/HangUpRecord';
import { pinus } from 'pinus';
import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY } from './../consts';
import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY, TASK_TYPE } from './../consts';
import { BattleRecordModel } from './../db/BattleRecord';
import { TowerRecordModel } from './../db/TowerRecord';
import { RoleModel } from './../db/Role';
@@ -12,6 +12,7 @@ import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
import { TowerTaskRecModel } from '../db/TowerTaskRec';
import { cloneDeep } from 'lodash';
import { Rank } from './rankService';
import { checkTask } from './taskService';
export async function checkTowerWar(roleId: string, battleId: number, heroes: Array<number>) {
const battleIdStr = `${battleId}`;
@@ -91,6 +92,8 @@ export async function towerBattleEnd(sid: string, roleId: string, serverId: numb
await startHangUp(roleId, roleName);
pinus.app.get('channelService').pushMessageByUids('hangUpEnable', resResult(STATUS.SUCCESS, {enable: true}), [{uid: roleId, sid}]);
}
// 任务
await checkTask(roleId, sid, TASK_TYPE.BATTLE_TOWER_LV, role.towerLv, false, {});
}
return {
status: 0,

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

@@ -56,17 +56,19 @@ export async function roleLevelup(roleId: string, kingExp: number, session: Back
}
export async function checkBattleHeroes(roleId: string, heroes: Array<number>) {
export async function checkBattleHeroes(roleId: string, seqIds: Array<number>) {
let heroes: number[] = [];
let flag = true;
if(heroes.length <= 0) flag = false;
if(seqIds.length <= 0) flag = false;
const findHeroes = await HeroModel.findBySeqIdRange(heroes, roleId);
if(findHeroes.length != heroes.length) flag = false;
for(let seqId of heroes) {
const findHeroes = await HeroModel.findBySeqIdRange(seqIds, roleId);
if(findHeroes.length != seqIds.length) flag = false;
for(let seqId of seqIds) {
let hero = findHeroes.find(cur => cur.seqId == seqId);
if(!hero) flag = false;
heroes.push(hero.hid);
}
return flag;
return { isOK: flag, heroes };
}
export async function checkBattleHeroesByHid(roleId: string, heroes: Array<number>) {

24
game-server/app/services/taskService.ts
View File

@@ -2,11 +2,12 @@ import * as taskUtil from '../pubUtils/taskUtil';
import { RoleType } from '../db/Role';
import { pinus } from 'pinus';
import { resResult } from '../pubUtils/util';
import { STATUS } from '../consts';
import { STATUS, TASK_TYPE } from '../consts';
import { TaskParam } from '../domain/roleField/task';
import { HeroType } from '../db/Hero';
import { EquipType } from '../db/Equip';
import { getRoleOnlineInfo } from './redisService';
import { TASK } from '../pubUtils/dicParam';
export async function checkTaskWithRoles(roleId: string, sid: string, taskType: number, roles: RoleType[]) {
for(let role of roles) {
@@ -34,6 +35,11 @@ export async function checkTaskWithArgs(roleId: string, sid: string, taskType: n
pushTaskUpdate(roleId, sid, pushMessage);
}
export async function checkTaskWithWar(roleId: string, sid: string, taskType: number, warId: number, heroes: number[], count: number, star: number) {
let pushMessage = await taskUtil.checkTaskWithWar(roleId, taskType, warId, heroes, count, star);
pushTaskUpdate(roleId, sid, pushMessage);
}
export async function checkTask(roleId: string, sid: string, taskType: number, count: number, isInc: boolean, param: TaskParam) {
let pushMessage = await taskUtil.checkTask(roleId, taskType, count, isInc, param);
pushTaskUpdate(roleId, sid, pushMessage);
@@ -48,4 +54,20 @@ export async function pushTaskUpdate(roleId: string, sid: string, pushMessage: {
let uids = [{uid: roleId, sid}];
pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
}
}
/**
* battle.normalBattleHandler.battleEnd 中会触发的任务，因为有点多提出来了
*/
export async function checkTaskInBattleEnd(roleId: string, sid: string, battleId: number, heroes: number[], star: number) {
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_WITH_HERO, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_MAIN, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DAILY_STAR, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DAILY, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DUNGEON, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DUNGEON_WAR, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_TOWER, battleId, heroes, 1, star);
await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_VESTIGE, battleId, heroes, 1, star);
}

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

@@ -612,4 +612,16 @@ export enum TASK_TYPE {
FRIEND_SEND_HEART = 35, // 赠送友情点
CHAT = 36, // 发送消息
BATTLE_COST_AP = 37, // 消耗体力
BATTLE_WITH_HERO = 38, // 使用某武将挑战某关卡
BATTLE_MAIN = 39, // 通关主线
BATTLE_MAIN_SWEEP = 40, // 扫荡主线
BATTLE_EVENT = 41, // 奇遇
BATTLE_DAILY_STAR = 42, // 每日x星通关
BATTLE_DAILY = 43, // 每日通关
BATTLE_DUNGEON = 44, // 秘境
BATTLE_DUNGEON_WAR = 45, // 通关秘境有些关卡
BATTLE_TOWER_LV = 46, // 镇念塔层数
BATTLE_TOWER = 47, // 镇念塔
BATTLE_VESTIGE = 48, // 遗迹
}

2
shared/db/BattleRecord.ts
View File

@@ -10,6 +10,8 @@ import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoos
class Record {
@prop({ required: true, type: Number })
heroes: Array<number>; // 武将id
@prop({ required: true, type: Number })
seqIds: Array<number>; // 武将seqid
@prop({ required: false })
oppRoleId?: string; // pvp对手
@prop({ required: false })

4
shared/domain/roleField/task.ts
View File

@@ -9,4 +9,8 @@ export class TaskParam {
oldLv?: number;
stage?: number;
chatType?: number;
warId?: number;
heroes?: number[];
eventType?: number;
dailyType?: number;
}

103
shared/pubUtils/taskUtil.ts
View File

@@ -1,6 +1,6 @@
import { gameData } from './data';
import { DicTask } from './dictionary/DicTask';
import { TASK_TYPE, ABI_STAGE } from '../consts';
import { TASK_TYPE, ABI_STAGE, WAR_TYPE } from '../consts';
import { UserTaskRecModel, UserTaskRecType } from '../db/UserTaskRec'
import { RoleType } from '../db/Role';
import { TaskParam } from '../domain/roleField/task';
@@ -32,7 +32,7 @@ export async function checkTaskWithRole(roleId: string, taskType: number, role:
let today = getTodayZeroPoint();
if(today > role.loginTime) {
if(today - role.loginTime > 24 * 60 * 60 ) {
pushMessage = await checkTask(roleId, taskType, 1, false, {});
pushMessage = await checkTask(roleId, taskType, 0, false, {});
} else {
pushMessage = await checkTask(roleId, taskType, 1, true, {});
}
@@ -226,6 +226,63 @@ export async function checkTaskWithArgs(roleId: string, taskType: number, args:
return pushMessage
}
export async function checkTaskWithWar(roleId: string, taskType: number, warId: number, heroes: number[], count: number, star: number) {
let dicWar = gameData.war.get(warId);
let pushMessage = new Array<{type: number, id: number, count: number, received: boolean}>();
if(taskType == TASK_TYPE.BATTLE_WITH_HERO)
{
pushMessage = await checkTask(roleId, taskType, count, true, { warId, heroes });
}
else if (taskType == TASK_TYPE.BATTLE_MAIN)
{
if(dicWar.warType == WAR_TYPE.NORMAL) {
pushMessage = await checkTask(roleId, taskType, count, true, { warId });
}
}
else if (taskType == TASK_TYPE.BATTLE_MAIN_SWEEP)
{
if(dicWar.warType == WAR_TYPE.NORMAL) {
pushMessage = await checkTask(roleId, taskType, count, true, {});
}
}
else if (taskType == TASK_TYPE.BATTLE_DAILY_STAR)
{
if(dicWar.warType == WAR_TYPE.DAILY) {
pushMessage = await checkTask(roleId, taskType, count, true, { warId, star });
}
}
else if (taskType == TASK_TYPE.BATTLE_DAILY)
{
if(dicWar.warType == WAR_TYPE.DAILY) {
pushMessage = await checkTask(roleId, taskType, count, true, { dailyType: dicWar.dailyType })
}
}
else if (taskType == TASK_TYPE.BATTLE_DUNGEON)
{
if(dicWar.warType == WAR_TYPE.MYSTERY||dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
pushMessage = await checkTask(roleId, taskType, count, true, {});
}
}
else if (taskType == TASK_TYPE.BATTLE_DUNGEON_WAR)
{
if(dicWar.warType == WAR_TYPE.MYSTERY||dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
pushMessage = await checkTask(roleId, taskType, count, true, { warId });
}
}
else if (taskType == TASK_TYPE.BATTLE_TOWER)
{
if(dicWar.warType == WAR_TYPE.TOWER) {
pushMessage = await checkTask(roleId, taskType, count, true, {});
}
}
else if (taskType == TASK_TYPE.BATTLE_VESTIGE) {
if(dicWar.warType == WAR_TYPE.VESTIGE) {
pushMessage = await checkTask(roleId, taskType, count, true, {});
}
}
return pushMessage
}
// 根据taskType判断有哪些任务需要check的
export async function checkTask(roleId: string, taskType: number, count: number, isInc: boolean, param: TaskParam) {
let tasks = gameData.taskType.get(taskType);
@@ -279,6 +336,11 @@ export async function checkTaskRec(roleId: string, group: number, dicTask: DicTa
case TASK_TYPE.EQUIP_JEWEL_SUM:
case TASK_TYPE.FRIEND_NUM:
case TASK_TYPE.FRIEND_SEND_HEART:
case TASK_TYPE.BATTLE_MAIN_SWEEP:
case TASK_TYPE.BATTLE_DUNGEON:
case TASK_TYPE.BATTLE_TOWER_LV:
case TASK_TYPE.BATTLE_TOWER:
case TASK_TYPE.BATTLE_VESTIGE:
isMatch = true;
break;
case TASK_TYPE.HERO_STAR_UP:
@@ -317,9 +379,24 @@ export async function checkTaskRec(roleId: string, group: number, dicTask: DicTa
isMatch = param.stage == taskParam[1];
break;
case TASK_TYPE.CHAT:
isMatch = param.chatType == 0 || param.chatType == taskParam[0];
isMatch = taskParam[0] == 0 || param.chatType == taskParam[0];
break;
case TASK_TYPE.BATTLE_WITH_HERO:
isMatch = checkWarId(taskParam, 2, param.warId) && checkHero(taskParam, 0, param.heroes);
break;
case TASK_TYPE.BATTLE_MAIN:
case TASK_TYPE.BATTLE_DUNGEON_WAR:
isMatch = checkWarId(taskParam, 0, param.warId);
break;
case TASK_TYPE.BATTLE_EVENT:
isMatch = taskParam[0] == 0 || param.eventType == taskParam[0];
break;
case TASK_TYPE.BATTLE_DAILY_STAR:
isMatch = (taskParam[0] == 0 || param.star == taskParam[0]) && checkWarId(taskParam, 2, param.warId);
break;
case TASK_TYPE.BATTLE_DAILY:
isMatch = taskParam[0] == 0 || param.dailyType == taskParam[0];
break;
}
console.log('****isMatch', isMatch, type, taskType, group, count)
@@ -334,6 +411,24 @@ export async function checkTaskRec(roleId: string, group: number, dicTask: DicTa
}
}
/**
* 检查关卡id是否在条件中
* @param taskParam 条件number[] 填法 warcount&warid&... 有多少warid就warcount填几
* @param index warcount在第几位，0开始
* @param warId 关卡id
*/
function checkWarId(taskParam: number[], index: number, warId: number) {
let warCount = taskParam[index];
if(!warCount) return false;
let warIdList = taskParam.slice(index + 1, index + 1 + warCount);
return warIdList.indexOf(warId) != -1;
}
function checkHero(taskParam: number[], index: number, heroes: number[]) {
let hid = taskParam[index];
return heroes.indexOf(hid) != -1;
}
function checkRecResult(rec: UserTaskRecType, condition: number) {
if(!rec) return false;
if(rec.received) return false;