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

活动：添加新的任务统计

Browse Source
This commit is contained in:
qiaoxin
2021-05-28 12:29:06 +08:00
parent 8961cdf248
commit cdb03bcc75
14 changed files with 260 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,7 +13,7 @@ import { getAp, setAp } from '../../../services/actionPointService';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { checkBattleHeroes, roleLevelup } from '../../../services/normalBattleService';
import { checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
import { gameData } from '../../../pubUtils/data';
export default function (app: Application) {
@@ -292,6 +292,7 @@ export class ExpeditionBattleHandler {
let roleName = session.get('roleName');
let sid = session.get('sid');
const funcs: number[] = session.get('funcs');
const serverId = session.get('serverId');
let role = await RoleModel.findByRoleId(roleId);
let { expeditionPoint } = role;
@@ -331,6 +332,7 @@ export class ExpeditionBattleHandler {
// 任务
await checkTask(roleId, sid, funcs, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1, true, { point });
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1)
let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward);

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

@@ -1,4 +1,4 @@
import {Application, BackendSession, pinus} from 'pinus';
import { Application, BackendSession, pinus } from 'pinus';
import { uniq, findWhere, findIndex } from 'underscore';
import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
import { refreshEnemies, getEnemies, getLvByScore, defaultHeroes, comsumeChallengeCnt, refresh, findPvpDefByRoleId, checkRoleIsRobot, getRefOppCnt, findPvpDefAllByRoleId, generPVPOppRecInfo, generMyRecInfo, robotIdComBack } from '../../../services/pvpService';
@@ -23,9 +23,9 @@ import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
import { SystemConfigModel } from '../../../db/SystemConfig';
import { Rank } from '../../../services/rankService';
import { checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
export default function(app: Application) {
export default function (app: Application) {
return new PvpHandler(app);
}
@@ -33,20 +33,20 @@ export class PvpHandler {
constructor(private app: Application) {
}
async addRoleScore(msg: {heroScores: Array<{hid: number, score:number}>}, session: BackendSession) {
async addRoleScore(msg: { heroScores: Array<{ hid: number, score: number }> }, session: BackendSession) {
let { heroScores: addHeroScores } = msg;
let roleId = session.get('roleId');
let sid = session.get('sid');
const funcs: number[] = session.get('funcs');
let {heroScores, hisScore} = await PvpDefenseModel.findByRoleId(roleId);
let { heroScores, hisScore } = await PvpDefenseModel.findByRoleId(roleId);
let score = 0;
for (let {hid, score: heroScore} of addHeroScores) {
for (let { hid, score: heroScore } of addHeroScores) {
if (heroScore < 0) continue;
let index = findIndex(heroScores, {hid});
let index = findIndex(heroScores, { hid });
if (index != -1) {
heroScores[index].score = heroScore;
} else {
heroScores.push({hid, score :heroScore});
heroScores.push({ hid, score: heroScore });
}
}
for (let heroScore of heroScores) {
@@ -59,7 +59,7 @@ export class PvpHandler {
hisScore = score;
}
let pLv = getPLvByScore(score);
let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore, pLv, heroScores});
let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore, pLv, heroScores });
let roleName = session.get('roleName');
const role = await RoleModel.findByRoleId(roleId);
@@ -70,27 +70,27 @@ export class PvpHandler {
// 任务
await checkTask(roleId, sid, funcs, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores });
return resResult(STATUS.SUCCESS, {score, hisScore, heroScores});
return resResult(STATUS.SUCCESS, { score, hisScore, heroScores });
}
async debugPvpSeasonReset(msg: {}, session: BackendSession) {
let { seasonNum, seasonEndTime } = await setPvpSeasonResult({name: 'exce setPvpSeasonResult debug'});
let { seasonNum, seasonEndTime } = await setPvpSeasonResult({ name: 'exce setPvpSeasonResult debug' });
return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime })
}
async debugPvpWarReset(msg: {}, session: BackendSession) {
let systemConfig = await resetPvpWarId();
return resResult(STATUS.SUCCESS, {systemConfig});
return resResult(STATUS.SUCCESS, { systemConfig });
}
async debugPvpSeasonResetTime(msg: {day: number}, session: BackendSession) {
let { day:hour } = msg;
async debugPvpSeasonResetTime(msg: { day: number }, session: BackendSession) {
let { day: hour } = msg;
let { seasonNum, seasonEndTime } = await pinus.app.rpc.systimer.systimerRemote.resetPvpSeasonTime.toServer('systimer-server-1', hour);
return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime });
}
async debugAddChallengeCnt(msg: {challengeCnt: number}, session: BackendSession) {
let { challengeCnt } = msg;
async debugAddChallengeCnt(msg: { challengeCnt: number }, session: BackendSession) {
let { challengeCnt } = msg;
let roleId = session.get('roleId');
if (challengeCnt > PVP.PVP_CHALLENGE_COUNTS) {
challengeCnt = PVP.PVP_CHALLENGE_COUNTS;
@@ -99,64 +99,66 @@ export class PvpHandler {
return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
}
async getData (msg: {}, session: BackendSession) {
async getData(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
let oppPlayers = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
let { isDefaultHero, heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, seasonNum } = pvpDefense;
if (isFirstEntry) {
await PvpDefenseModel.updateInfo(roleId, {isFirstEntry:false});
await PvpDefenseModel.updateInfo(roleId, { isFirstEntry: false });
}
let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId);
let flag = false;
if (!!pvpSeasonResult) {
var { oldSeasonData, show, heroGoods, rankGoods} = pvpSeasonResult;
if ( oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
var { oldSeasonData, show, heroGoods, rankGoods } = pvpSeasonResult;
if (oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
seasonEndTime = oldSeasonData.seasonEndTime;
heroScores = oldSeasonData.heroScores;
score = oldSeasonData.score;
refOppCnt = oldSeasonData.refOppCnt;
challengeCnt = oldSeasonData.challengeCnt;
challengeRefTime = oldSeasonData.challengeRefTime;
challengeCnt = oldSeasonData.challengeCnt;
challengeRefTime = oldSeasonData.challengeRefTime;
} else if (show) {//是否需要弹出结算奖励界面
await PvpSeasonResultModel.updatePvpSeasonResult(roleId, {show: false});
await PvpSeasonResultModel.updatePvpSeasonResult(roleId, { show: false });
flag = true;
}
}
let r = new Rank(REDIS_KEY.PVP_RANK, {});
let myRank = await r.getMyRank({roleId});//去redis中获取排名
let data:any = {warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
let {actorId, dataId, order} = cur;
return { actorId, dataId, order }
}), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero }
let myRank = await r.getMyRank({ roleId });//去redis中获取排名
let data: any = {
warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
let { actorId, dataId, order } = cur;
return { actorId, dataId, order }
}), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero
}
if (flag) {//弹出结赛季结算奖励
data.resultRecord = { oldSeasonData, heroGoods, rankGoods }
data.resultRecord = { oldSeasonData, heroGoods, rankGoods }
}
return resResult(STATUS.SUCCESS, data);
}
// 刷新对手
async refreshOppPlayer (msg: {}, session: BackendSession) {
async refreshOppPlayer(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let sid = session.get('sid');
let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
// 刷新次数及消耗
let { refOppCnt, refOppTime, consume } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime);
if(refOppCnt >= gameData.maxPvpRefreshCnt) {
if (refOppCnt >= gameData.maxPvpRefreshCnt) {
return resResult(STATUS.PVP_REFRESH_CNT_REACH_MAX);
}
let costResult = await handleCost(roleId, sid, consume);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 刷新对手
let role = <RoleType>pvpDefense.role;
let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv);
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers, refOppCnt: refOppCnt + 1, refOppTime });
let result = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
@@ -165,7 +167,7 @@ export class PvpHandler {
}
// 获取对手阵容具体信息
async getOppPlayer (msg: { roleId: string }, session: BackendSession) {
async getOppPlayer(msg: { roleId: string }, session: BackendSession) {
let roleId = session.get('roleId');
let oppoRoleId = msg.roleId;
@@ -173,29 +175,29 @@ export class PvpHandler {
let { oppPlayers } = pvpDefense;
let curOpp = oppPlayers.find(cur => cur.roleId == oppoRoleId);
if(!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
let { oppRoleId, heroes } = <PvpHistoryOppType>curOpp.oppDef;
let { oppRoleId, heroes } = <PvpHistoryOppType>curOpp.oppDef;
return resResult(STATUS.SUCCESS, { roleId: oppRoleId, pos: curOpp.pos, heroes });
}
// 开战
async pvpStart (msg: { warId: number, heroes: number[], roleId: string }, session: BackendSession) {
async pvpStart(msg: { warId: number, heroes: number[], roleId: string }, session: BackendSession) {
const { warId, heroes, roleId: oppRoleId } = msg;
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let warInfo = gameData.war.get(warId);
if(!warInfo) {
if (!warInfo) {
return resResult(STATUS.BATTLE_MISS_INFO);
}
let { isOK } = await checkBattleHeroesByHid(roleId, heroes);
if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
if (!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
// 检查挑战次数
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
@@ -204,7 +206,7 @@ export class PvpHandler {
}
let { oppPlayers } = pvpDefense;
let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId);
if(!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
const battleCode = genCode(8); // 关卡唯一值
@@ -224,44 +226,45 @@ export class PvpHandler {
}
// 结算
async pvpEnd (msg: { battleCode: string, isSuccess: boolean, myHeroes: pvpEndParamInter[], oppHeroes: pvpEndParamInter[] }, session: BackendSession) {
async pvpEnd(msg: { battleCode: string, isSuccess: boolean, myHeroes: pvpEndParamInter[], oppHeroes: pvpEndParamInter[] }, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let sid = session.get('sid');
const funcs: number[] = session.get('funcs');
const serverId = session.get('serverId');
const { battleCode, isSuccess, myHeroes, oppHeroes } = msg;
const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
if(!BattleRecord || BattleRecord.status != 0) {
if (!BattleRecord || BattleRecord.status != 0) {
return resResult(STATUS.BATTLE_STATUS_WRONG);
}
let { record: { heroes: dbHeroes, oppRoleId, pos } } = BattleRecord;
let flag = 1; // 对比hero信息
for(let {hid} of myHeroes) {
if(dbHeroes.indexOf(hid) == -1) flag = 0;
for (let { hid } of myHeroes) {
if (dbHeroes.indexOf(hid) == -1) flag = 0;
}
if(!flag) return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
if (!flag) return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
// 更新军功
let {pvpDefense, warId} = await findPvpDefByRoleId(roleId);
if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
let { pvpDefense, warId } = await findPvpDefByRoleId(roleId);
if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
let { oppPlayers, winStreakNum, heroScores, score, hisScore } = pvpDefense;
let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
if(!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
const role = await RoleModel.findByRoleId(roleId, null, true);
if(isSuccess) {
winStreakNum ++;
if (isSuccess) {
winStreakNum++;
} else {
winStreakNum = 0;
}
const myRecInfo = await generMyRecInfo(heroScores, winStreakNum, role, isSuccess, pos, myHeroes);
let { attackInfo, showHeroScores, addSumScore } = myRecInfo
score += addSumScore;
@@ -270,23 +273,23 @@ export class PvpHandler {
const defenseInfo = await generPVPOppRecInfo(isSuccess, curOpp, oppHeroes, role.lv);
// 战报记录
await PvpRecordModel.createRec({roleId1: roleId, roleId2: robotIdComBack(oppRoleId), warId: BattleRecord.battleId, attackInfo, defenseInfo, createTime: nowSeconds()});
await PvpRecordModel.createRec({ roleId1: roleId, roleId2: robotIdComBack(oppRoleId), warId: BattleRecord.battleId, attackInfo, defenseInfo, createTime: nowSeconds() });
// 对手记录更新
await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
// 刷新对手
let newOppPlayers: Array<OppPlayers> = await refreshEnemies(role, score, pLv);
// 更新battleRecord
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess?1:2 }
$set: { status: isSuccess ? 1 : 2 }
}, true);
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
// 减少挑战次数
let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
if ( hisScore < score) {
if (hisScore < score) {
hisScore = score;
}
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers: newOppPlayers, heroScores, score, pLv, winStreakNum, challengeCnt, challengeRefTime, hisScore });
@@ -295,10 +298,13 @@ export class PvpHandler {
// 加入排行榜
let r = new Rank(REDIS_KEY.PVP_RANK, {});
await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
let myRank = await r.getMyRank({roleId});
let myRank = await r.getMyRank({ roleId });
await checkTaskInPvpEnd(roleId, sid, funcs, isSuccess, heroScores);
if (isSuccess) {
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.PVP_WIN_SERIES, 1)
}
return resResult(STATUS.SUCCESS, {
battleCode, isSuccess,
score, pLv, myRank, hisScore,
@@ -312,15 +318,15 @@ export class PvpHandler {
});
}
async saveDefense(msg: { heroes: Array<{actorId: number, dataId: number, order: number}>, isDefaultHero:boolean }, session: BackendSession) {
let {heroes, isDefaultHero} = msg;
async saveDefense(msg: { heroes: Array<{ actorId: number, dataId: number, order: number }>, isDefaultHero: boolean }, session: BackendSession) {
let { heroes, isDefaultHero } = msg;
let roleId = session.get('roleId');
if (heroes.length > LINEUP_NUM || heroes.length <= 0) {
return resResult(STATUS.WRONG_PARMS);
}
heroes = uniq(heroes, function(item) {
return item.order;
});
heroes = uniq(heroes, function (item) {
return item.order;
});
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { heroes: defHeros, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
let defCe = 0;
@@ -333,26 +339,26 @@ export class PvpHandler {
}).map(cur => cur.hid);
let dataIds = new Array<number>(), orders = new Array<number>();
for(let hero of heroes) {
if(hero.actorId) {
for (let hero of heroes) {
if (hero.actorId) {
let isInTop = topLineup.find(cur => cur.hid == hero.actorId);
if(!isInTop) {
if (!isInTop) {
hero.actorId = hids.shift();
}
dataIds.push(hero.dataId);
orders.push(hero.order);
}
}
for(let hid of hids) {
for (let hid of hids) {
let dataId = 0;
for (let i = PVP_HERO_POS.START; i <= PVP_HERO_POS.END; i++) {
if(dataIds.includes(i)) continue;
if (dataIds.includes(i)) continue;
dataIds.push(i);
dataId = i; break;
}
let order = 0;
for (let i = PVP_HERO_ORDER.START; i <= PVP_HERO_ORDER.END; i++) {
if(orders.includes(i)) continue;
if (orders.includes(i)) continue;
orders.push(i);
order = i; break;
}
@@ -363,11 +369,11 @@ export class PvpHandler {
}
for (let dataId = PVP_HERO_POS.START; dataId <= PVP_HERO_POS.END; dataId++) {
let index = findIndex(heroes, {dataId});
let defIndex = findIndex(defHeros, {dataId});
let index = findIndex(heroes, { dataId });
let defIndex = findIndex(defHeros, { dataId });
if (defIndex == -1) {
defIndex = defHeros.length;
defHeros.push({actorId:0, order:0,ce:0, hero:null,dataId});
defHeros.push({ actorId: 0, order: 0, ce: 0, hero: null, dataId });
}
if (index == -1) {
defHeros[defIndex].actorId = 0;
@@ -383,16 +389,16 @@ export class PvpHandler {
let hero = await HeroModel.findByHidAndRole(heroes[index].actorId, roleId);
if (!hero) {
continue;
}
}
defHeros[defIndex].actorId = heroes[index].actorId;
defHeros[defIndex].order = heroes[index].order;
defHeros[defIndex].ce = hero.ce;
defHeros[defIndex].hero = hero._id;
defCe += hero.ce;
defCe += hero.ce;
}
let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, {defCe, heroes: defHeros, challengeCnt, challengeRefTime, isDefaultHero });
let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, { defCe, heroes: defHeros, challengeCnt, challengeRefTime, isDefaultHero });
return resResult(STATUS.SUCCESS, { heroes: resHeroes, challengeCnt, challengeRefTime, isDefaultHero });
}
async getRank(msg: {}, session: BackendSession) {
@@ -400,11 +406,11 @@ export class PvpHandler {
let roleId = session.get('roleId');
let r = new Rank(REDIS_KEY.PVP_RANK, {});
let {ranks, myRank} = await r.getRankListWithMyRank({roleId});
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
if(!myRank) {
if (!myRank) {
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
myRank = await r.generMyRankWithRole(roleId, pvpDefense.score, getSeconds(pvpDefense.refOppTime));
}
@@ -417,52 +423,52 @@ export class PvpHandler {
let { roleId: oppoRoleId } = msg;
let isRobot = checkRoleIsRobot(oppoRoleId);
let result: PlayerDetail;
if(isRobot) { // 如果是机器人，从自己的pvpDefense中寻找
if (isRobot) { // 如果是机器人，从自己的pvpDefense中寻找
let pvpHistoryOpp = await PvpHistoryOppModel.findByRoleIdAndOppId(roleId, oppoRoleId);
if(!pvpHistoryOpp) {
if (!pvpHistoryOpp) {
return resResult(STATUS.PVP_ROLE_NOT_FOUND);
}
let heroes = new Array<PlayerDetailHero>();
for(let hero of pvpHistoryOpp.heroes) {
for (let hero of pvpHistoryOpp.heroes) {
let newHero = new PlayerDetailHero();
newHero.setPvpHeroInfo(hero);
heroes.push(newHero);
}
for(let hero of pvpHistoryOpp.otherHeroes) {
for (let hero of pvpHistoryOpp.otherHeroes) {
let newHero = new PlayerDetailHero();
newHero.setPvpHeroInfo(hero);
heroes.push(newHero);
}
result = new PlayerDetail({...pvpHistoryOpp, roleId: pvpHistoryOpp.oppRoleId, heroes, rank: pvpHistoryOpp.rankLv});
result = new PlayerDetail({ ...pvpHistoryOpp, roleId: pvpHistoryOpp.oppRoleId, heroes, rank: pvpHistoryOpp.rankLv });
} else { // 查询对方pvpDefense
let pvpDefense = await PvpDefenseModel.findByRoleId(oppoRoleId);
let dbHeroes = await HeroModel.findByRole(oppoRoleId);
let role = await RoleModel.findByRoleId(oppoRoleId);
let heroes = new Array<PlayerDetailHero>();
for(let {hid, lv, star, colorStar, quality } of dbHeroes) {
for (let { hid, lv, star, colorStar, quality } of dbHeroes) {
let heroScore = pvpDefense.heroScores.find(cur => cur.hid == hid);
heroes.push({
actorId: hid, lv, star, colorStar, quality,
score: heroScore?heroScore.score: 0
score: heroScore ? heroScore.score : 0
});
}
heroes.sort((a, b) => b.score - a.score);
let r = new Rank(REDIS_KEY.PVP_RANK, {});
let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
result = new PlayerDetail({...role, ...pvpDefense, heroes, rank});
result = new PlayerDetail({ ...role, ...pvpDefense, heroes, rank });
}
return resResult(STATUS.SUCCESS, result);
}
async receiveBox(msg: {id: number}, session: BackendSession) {
let {id} = msg;
async receiveBox(msg: { id: number }, session: BackendSession) {
let { id } = msg;
let roleId = session.get('roleId');
let sid: string = session.get('sid');
let roleName = session.get('roleName');
@@ -470,25 +476,25 @@ export class PvpHandler {
let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
let pvpBoxs = getPvpBoxs();
let pvpBox = findWhere(pvpBoxs, {id});
let pvpBox = findWhere(pvpBoxs, { id });
if (hisScore < pvpBox.score) {
return resResult(STATUS.PVP_NOT_REACH_BOX_SCORE);
}
if (receivedBox.indexOf(id) != -1 ) {
if (receivedBox.indexOf(id) != -1) {
return resResult(STATUS.PVP_BOX_IS_GOT);
}
receivedBox.push(id);
let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
await PvpDefenseModel.updateInfo(roleId, {receivedBox, challengeCnt, challengeRefTime});
let result = await addItems(roleId, roleName, sid, pvpBox.reward );
await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
let result = await addItems(roleId, roleName, sid, pvpBox.reward);
// 任务
await checkTask(roleId, sid, funcs, TASK_TYPE.PVP_RECEIVE_BOX, 1, true, {});
return resResult(STATUS.SUCCESS,{goods: result, receivedBox, challengeCnt, challengeRefTime});
return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });
}
async getRec(msg: {}, session: BackendSession ) {
async getRec(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId);
return resResult(STATUS.SUCCESS, {list: pvpRecords});
return resResult(STATUS.SUCCESS, { list: pvpRecords });
}
}

2
game-server/app/servers/order/handler/orderHandler.ts
View File

@@ -249,7 +249,7 @@ export class orderHandler {
}), [{ uid: roleId, sid: sid }]);
//活动统计
await addRechargeMoney(roleId, serverId, price);
console.log(`测试支付完成!!!!!!!!!!!!! serverId:${serverId}, productID:${productID}, roleId:${roleId}, localOrderID:${localOrderID}`)
console.log(`测试支付完成!!!!!!!!!!!!! serverId:${serverId}, productID:${productID}, productType:${productType}, roleId:${roleId}, localOrderID:${localOrderID}, payType:${payType}`)
return resResult(STATUS.SUCCESS, result);
}

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

@@ -115,6 +115,7 @@ export class HeroHandler {
let roleId: string = session.get('roleId');
let sid: string = session.get('sid');
let funcs: number[] = session.get('funcs');
const serverId = session.get('serverId');
let { hid, type } = msg;
@@ -173,6 +174,7 @@ export class HeroHandler {
// 任务
await checkTaskWithHero(roleId, sid, funcs, TASK_TYPE.HERO_LV, hero, [oldLv]);
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.HERO_LV, 1, { hid, lv: update.lv });
const curHero = {
hid, lv: hero.lv, exp: hero.exp
@@ -397,6 +399,7 @@ export class HeroHandler {
await checkTask(roleId, sid, funcs, TASK_TYPE.HERO_TRAIN_SUM, 1, true, {});
//活动统计
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.HERO_TRAIN_SUM, 1)
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.HERO_TRAIN, 1, { hid })
return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, job: hero.job, jobStage: hero.jobStage } });
}

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

@@ -66,7 +66,7 @@ export async function getPlayerGrowthFundData(activityId: number, serverId: numb
for (let page of playerData.list) {
for (let item of page.items) {
if (item.taskType == TASK_TYPE.BATTLE_MAIN) {
let index = warIDs.findIndex(id => { return id === item.condition })
let index = warIDs.findIndex(id => { return id === item.taskParamArray[1] })
if (index != -1) {
item.isComplete = true;
}

8
game-server/app/services/growthService.ts
View File

@@ -2,6 +2,7 @@ import { ACTIVITY_TYPE } from '../consts';
import { ActivityModel, ActivityModelType } from '../db/Activity';
import { ActivityGrowthModel, ActivityGrowthModelType } from '../db/ActivityGrowth';
import { ActivityGrowthPointModel, ActivityGrowthPointModelType } from '../db/ActivityGrowthPoint';
import { HeroModel } from '../db/Hero';
import { ServerlistModel } from '../db/Serverlist';
import { GrowthData, GrowthItem } from '../domain/activityField/growthField';
@@ -23,8 +24,9 @@ export async function growthActivity(serverId: number, roleId: string) {
let playerRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityData.activityId, roleId);
let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityData.activityId, roleId);
let userHeroes = await HeroModel.findByRole(roleId);
let playerData = new GrowthData(activityData);
await playerData.setPlayerRecords(playerRecords, roleId);
await playerData.setPlayerRecords(playerRecords, roleId, userHeroes);
playerData.setPlayerPointRecord(playerPointRecord);
return playerData;
}
@@ -42,8 +44,10 @@ export async function getPlayerGrowthData(activityId: number, serverId: number,
let playerRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityId, roleId);
let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityId, roleId);
let userHeroes = await HeroModel.findByRole(roleId);
let playerData = new GrowthData(activityData);
await playerData.setPlayerRecords(playerRecords, roleId);
await playerData.setPlayerRecords(playerRecords, roleId, userHeroes);
playerData.setPlayerPointRecord(playerPointRecord);
return playerData;
}

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

@@ -80,6 +80,7 @@ export async function checkActivityTask(serverId: number, sid: string, funcs: nu
}
export async function pushActivityUpdate(roleId: string, sid: string, funcs: number[], pushMessage: any[]) {
console.log('pushActivityUpdate', JSON.stringify(pushMessage))
if (pushMessage.length > 0) {
if (!sid || !funcs) {
let onlineUser = await getRoleOnlineInfo(roleId);
@@ -109,6 +110,7 @@ export async function checkTaskInBattleEnd(serverId: number, roleId: string, sid
await checkTaskWithWar(roleId, sid, funcs, TASK_TYPE.BATTLE_EXPEDITION, battleId, heroes, 1, star);
//成长任务
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_MAIN, 1, { warId: battleId })
await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_EXPEDITION, 1)
}

14
shared/db/ActivityDailyChallenges.ts
View File

@@ -23,6 +23,8 @@ export default class Activity_Daily_Challenges extends BaseModel {
totalCount: number; // 累计达成次数
@prop({ required: true })
receiveRewardCount: number; // 领取奖励次数
@prop({ required: true })
data: string; // 数据信息
//任务领取记录
public static async addCellRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
@@ -45,6 +47,14 @@ export default class Activity_Daily_Challenges extends BaseModel {
return result;
}
//根据活动记录统计数据
public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { data: data } }, { upsert: true, new: true }).lean(true);
return result;
}
//根据活动id查询活动数据
public static async findData(serverId: number, activityId: number, roleId: string, lean = true) {
let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ serverId, roleId, activityId }).lean(lean);
@@ -58,8 +68,8 @@ export default class Activity_Daily_Challenges extends BaseModel {
}
//查询第几天某个的活动数据
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ serverId, roleId, activityId, dayIndex, cellIndex }).lean(lean);
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOne({ serverId, roleId, activityId, dayIndex, cellIndex, type }).lean(true);
return result;
}

20
shared/db/ActivityGrowth.ts
View File

@@ -1,5 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { TASK_TYPE } from '../consts';
/**
* 活动系统 - 成长任务活动
@@ -23,8 +24,8 @@ export default class Activity_Growth extends BaseModel {
totalCount: number; // 累计达成次数
@prop({ required: true })
receiveRewardCount: number; // 领取奖励次数
@prop({ required: true, default: false })
getPointReward: boolean; // 是否兑换领取奖章奖励
@prop({ required: true })
data: string; // 数据信息
//任务领取记录
public static async addCellRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number,) {
@@ -33,13 +34,6 @@ export default class Activity_Growth extends BaseModel {
return result;
}
//当日奖章领取记录
public static async addDayRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
{ $set: { getPointReward: true } }, { upsert: true, new: true }).lean(lean);
return result;
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
@@ -54,6 +48,14 @@ export default class Activity_Growth extends BaseModel {
return result;
}
//根据活动记录统计数据
public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { data: data } }, { upsert: true, new: true }).lean(true);
return result;
}
//根据活动id查询活动数据
public static async findData(serverId: number, activityId: number, roleId: string, lean = true) {
let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ serverId, roleId, activityId }).lean(lean);

9
shared/db/ActivityThirtyDays.ts
View File

@@ -23,6 +23,8 @@ export default class Activity_Thirty_Days extends BaseModel {
totalCount: number; // 累计达成次数
@prop({ required: true })
isReceive: boolean; // 是否领取过奖励
@prop({ required: true })
data: string; // 数据信息
//添加领取记录
public static async addRecord(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
@@ -38,6 +40,13 @@ export default class Activity_Thirty_Days extends BaseModel {
return result;
}
//根据活动记录统计数据
public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { data: data } }, { upsert: true, new: true }).lean(true);
return result;
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, type: number, count: number, lean = true) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, type },

37
shared/domain/activityField/growthField.ts
View File

@@ -2,10 +2,9 @@ import { TASK_TYPE, ACTIVITY_RESOURCES_TYPE } from '../../consts';
import { ActivityModelType } from '../../db/Activity';
import { ActivityGrowthModelType } from '../../db/ActivityGrowth';
import { ActivityGrowthPointModelType } from '../../db/ActivityGrowthPoint';
import { HeroType } from '../../db/Hero';
import { RoleModel } from '../../db/Role';
import { RewardInter } from '../../pubUtils/interface';
import { parseGoodStrWithType, parseHeroStrWithType } from '../../pubUtils/util';
import { CreateHeroParam } from '../roleField/hero';
import { splitString } from '../../pubUtils/util';
import { ActivityBase } from './activityField';
@@ -40,6 +39,7 @@ export class GrowthItem {
condition: number; //任务数据条件 dic_zyz_taskType.jsonT
point: number; // 任务达成获得的奖章数量，只在当前活动中有用，虚拟
reward: string; // 任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
taskParamArray: number[];
totalCount: number = 0; //完成任务累计次数
receiveRewardCount: number = 0; //领取奖励次数
@@ -55,26 +55,8 @@ export class GrowthItem {
this.reward = data.reward;
this.totalCount = 0;
this.receiveRewardCount = 0;
}
this.taskParamArray = splitString(data.taskParam, '&')
public heroReward(): CreateHeroParam[] {
let rewardArray = [];
let rewardData = this.reward.split('|').filter(obj => { return obj && obj != '' });
for (let objStr of rewardData) {
let reward = parseHeroStrWithType(objStr);
rewardArray.push(reward);
}
return rewardArray.filter(obj => { return obj && obj.type == ACTIVITY_RESOURCES_TYPE.HERO })
}
public goodReward(): RewardInter[] {
let rewardArray = [];
let rewardData = this.reward.split('|').filter(obj => { return obj && obj != '' });
for (let objStr of rewardData) {
let reward = parseGoodStrWithType(objStr);
rewardArray.push(reward);
}
return rewardArray.filter(obj => { return obj && obj.type == ACTIVITY_RESOURCES_TYPE.GOODS })
}
public canReceive(): boolean {
@@ -146,7 +128,6 @@ export class GrowthData extends ActivityBase {
//第几天的奖章兑换
public findPointItem(id: number) {
console.log('ddddddddddd', JSON.stringify(this.pointRewardList), id)
let index = this.pointRewardList.findIndex(obj => { return obj && obj.id === id })
return (index != -1) ? this.pointRewardList[index] : null;
}
@@ -162,7 +143,7 @@ export class GrowthData extends ActivityBase {
})
}
//解析玩家领取记录
//解析玩家积分兑换记录
public setPlayerPointRecord(data: ActivityGrowthPointModelType) {
if (!data) {
return;
@@ -176,17 +157,21 @@ export class GrowthData extends ActivityBase {
}
//解析玩家领取记录
public async setPlayerRecords(data: ActivityGrowthModelType[], roleId: string) {
public async setPlayerRecords(data: ActivityGrowthModelType[], roleId: string, userHeroes: HeroType[]) {
let { heroNum } = await RoleModel.findByRoleId(roleId);
for (let obj of this.list) {
let index = data.findIndex(record => { return obj.dayIndex == record.dayIndex && obj.cellIndex == record.cellIndex })
if (index != -1) {
obj.totalCount = data[index].totalCount ? data[index].totalCount : 0;
obj.receiveRewardCount = data[index].receiveRewardCount ? data[index].receiveRewardCount : 0;
}
if (obj.taskType === TASK_TYPE.HERO_NUM) {
obj.totalCount = heroNum;
} else if (obj.taskType === TASK_TYPE.HERO_LV) {
obj.taskParam
let lv = obj.taskParamArray[1];
let heroes = userHeroes.filter(hero => { return hero.lv >= lv })
obj.totalCount = heroes.length;
}
}
}

11
shared/domain/activityField/growthFundField.ts
View File

@@ -2,6 +2,7 @@ import { ACTIVITY_RESOURCES_TYPE, ACTIVITY_TYPE } from '../../consts';
import { ActivityModelType } from '../../db/Activity';
import { ActivityBuyRecordsModelType } from '../../db/ActivityBuyRecords';
import { ActivityGrowthFundModelType } from '../../db/ActivityGrowthFund';
import { splitString } from '../../pubUtils/util';
import { ActivityBase } from './activityField';
@@ -15,7 +16,7 @@ export class GrowthFundItem {
condition: number; //0
reward: string; // 任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
isComplete: boolean //是否完成任务
taskParamArray: number[]//
// isReceive: boolean = false; //是否领取过奖励
constructor(data: any) {
@@ -28,6 +29,8 @@ export class GrowthFundItem {
this.condition = data.conditon;
this.isComplete = false;
// this.isReceive = false;
this.taskParamArray = splitString(data.taskParam, '&')
}
}
@@ -70,14 +73,14 @@ export class GrowthFundData extends ActivityBase {
switch (this.type) {
case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP: {
if (!this.isReceive(page.pageIndex, item.cellIndex) && item.condition == condition) {
if (!this.isReceive(page.pageIndex, item.cellIndex) && item.taskParamArray[1] == condition) {
item.isComplete = true;
items.push(Object.assign(item, { pageIndex: page.pageIndex, activityId: this.activityId }))
}
break;
}
case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP:
case ACTIVITY_TYPE.GROWTH_FUND_TOWER:
case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:
case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE:
case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP: {
if (!this.isReceive(page.pageIndex, item.cellIndex) && item.condition <= condition) {

1
shared/pubUtils/itemUtils.ts
View File

@@ -269,6 +269,7 @@ export async function createHeroes(roleId: string, roleName: string, serverId: n
let taskPushMessage = m1.concat(m2, m3, m4);
//成长任务
await accomplishTask(serverId, roleId, TASK_TYPE.HERO_NUM, heroNum)
await accomplishTask(serverId, roleId, TASK_TYPE.HERO_QUALITY, heroNum, { heroes })
return { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage }
}

93
shared/pubUtils/taskUtil.ts
View File

@@ -494,7 +494,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
let growthActivity = new GrowthData(activity);
let taskArray = growthActivity.findTaskByType(taskType);
for (let task of taskArray) {
let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
let recordData = taskRecord && taskRecord.data ? JSON.parse(taskRecord.data) : null;
let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
if (addCount) {
if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
await ActivityGrowthModel.setTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
@@ -502,6 +504,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
await ActivityGrowthModel.addTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
}
}
if (record) {
await ActivityGrowthModel.addTaskRecord(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, JSON.stringify(record));
}
}
}
@@ -511,7 +516,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
let growthActivity = new DailyChallengesData(activity);
let taskArray = growthActivity.findTaskByType(taskType, growthActivity.today());
for (let task of taskArray) {
let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
let recordData = taskRecord && taskRecord.data ? taskRecord.data : {}
let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
if (addCount) {
if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
await ActivityDailyChallengesModel.setTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
@@ -519,6 +526,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
await ActivityDailyChallengesModel.addTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
}
}
if (record) {
await ActivityGrowthModel.addTaskRecord(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, JSON.stringify(record));
}
}
}
@@ -543,10 +553,15 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
thirtyDaysActivity.setPlayerRecords(playerRecords);
let taskArray = thirtyDaysActivity.findUncompleteTaskByType(taskType);
for (let task of taskArray) {
let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, thirtyDaysActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
let recordData = taskRecord && taskRecord.data ? taskRecord.data : {}
let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
if (addCount) {
await ActivityThirtyDaysModel.addTaskCount(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.taskType, addCount);
}
if (record) {
await ActivityGrowthModel.addTaskRecord(serverId, thirtyDaysActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, JSON.stringify(record));
}
}
}
}
@@ -614,10 +629,11 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
*
*/
export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: string, count: number, paramObj?: any): number {
export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: string, count: number, paramObj?: any, recordData?: any): any {
console.log('达成任务标准', roleId, taskType, taskParam, count, paramObj)
let param = splitString(taskParam, '&');
let addCount: number = 0; // 条件是否满足
let record: any = null;
switch (taskType) {
case TASK_TYPE.ROLE_LV://重置数据
addCount = count;
@@ -693,18 +709,79 @@ export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: strin
case TASK_TYPE.GUILD_ACTIVITY:
addCount = count;
break;
case TASK_TYPE.HERO_TRAIN_SUM:
addCount = count;
break;
case TASK_TYPE.EQUIP_SUM:
addCount = count;
break;
case TASK_TYPE.HERO_LV://{ hid, lv}
{
let hid = paramObj.hid;
let lv = paramObj.lv;
if (lv < param[1]) {
break;
}
if (recordData) {
if (recordData.indexOf(hid) != -1) {
break;
}
record = recordData;
} else {
record = [];
}
addCount = count;
record.push(hid)
break;
}
case TASK_TYPE.HERO_TRAIN_SUM://训练X次是所有武将的训练次数的总和达到要求就好了
{
addCount = count;
break;
}
case TASK_TYPE.HERO_TRAIN://X名武将训练Y次，要求单名武将训练Y次，这样的武将要有X名
{
let hid = paramObj.hid;
if (recordData) {
record = recordData;
if (record['hid']) {
if (record['hid'] < param[1] && (record['hid'] + count >= param[1])) {
addCount = count;
record['hid'] += count;
break;
}
}
}
record['hid'] = count;
break;
}
case TASK_TYPE.BATTLE_EXPEDITION:
{
addCount = count;
break;
}
case TASK_TYPE.BATTLE_EXPEDITION_BOX:
{
addCount = count;
break;
}
case TASK_TYPE.HERO_QUALITY:
{
let quality = param[1]
let heroes = paramObj.heroes.filter(hero => { return hero.quality == quality })
addCount = heroes.length;
break;
}
case TASK_TYPE.PVP_WIN_SERIES:
{
addCount = count;
break;
}
default:
addCount = 0;
break;
}
return addCount;
return { addCount, record };
}
/**