Merge branch 'feature/test'

game-server/app/servers/battle/handler/pvpHandler.ts

@@ -159,14 +159,13 @@ export class PvpHandler {
         let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
         if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 检查挑战次数
+        let seasonNum: number = this.app.get('pvpSeasonNum');
         let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let { challengeCnt, challengeRefTime } = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         if (challengeCnt == 0) {
             return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
         }
-        await PvpDefenseModel.updateInfo(roleId, { challengeCnt, challengeRefTime });
+        let curOpp = pvpDefense.oppPlayers.find(cur => cur.roleId == oppRoleId);
-        let { oppPlayers } = pvpDefense;
-        let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId);
         if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
 
         const battleCode = genCode(8); // 关卡唯一值
@@ -183,8 +182,32 @@ export class PvpHandler {
         }, true);    
         await checkTask(roleId, sid, TASK_TYPE.PVP, 1, true, {});
 
+        // 对手记录更新
+        await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
+
+        let update: pvpUpdateInter = {
+            oppBeforePlayers: pvpDefense.oppPlayers
+        };
+        // 刷新对手
+        const role = await RoleModel.findByRoleId(roleId, null, true);
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score ,pvpDefense.attack.score, pvpDefense.attack.pLv||1);
+        update.oppPlayers = oppPlayers;
+
+        // 减少挑战次数
+        let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        refChallengeObj.challengeCnt--;
+        update = {...update, ...refChallengeObj};
+
+        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
+
+        let result = new PvpDataReturn(); // 返回对象
+        result.setPvpDefense(pvpDefense);
+        let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
+        result.setOppPlayers(oppPlayersReturn);
+
         return resResult(STATUS.SUCCESS, {
-            battleCode
+            battleCode,
+            ...pick(result, ['oppPlayers', 'challengeCnt', 'challengeRefTime'])
         });
     }
 
@@ -225,32 +248,20 @@ export class PvpHandler {
         let { attackInfo, showHeroScores, updateParam } = myRecInfo
         update = { ...update, ...updateParam };
 
-        let curOpp = pvpDefense.oppPlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
+        let curOpp = pvpDefense.oppBeforePlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
         if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
         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 PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
-
-        // 刷新对手
         let seasonNum: number = this.app.get('pvpSeasonNum');
-        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
-        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score ,pvpDefense.attack.score, pvpDefense.attack.pLv||1);
-        update.oppPlayers = oppPlayers;
 
         // 更新battleRecord
         await BattleRecordModel.updateBattleRecordByCode(battleCode, {
             $set: { status: isSuccess ? 1 : 2 }
         }, true);
 
-        // 减少挑战次数
-        let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
-        refChallengeObj.challengeCnt--;
-        update = {...update, ...refChallengeObj};
-
         pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
 
 
@@ -354,14 +365,14 @@ export class PvpHandler {
         let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         // 更新挑战阵容
-        let score = 0;
+        let scores: number[] = [];
         for(let { actorId } of heroes) {
             let heroScore = pvpDefense.heroScores.find(cur => cur.hid == actorId);
             if(heroScore) {
-                score += heroScore.score;
+                scores.push(heroScore.score);
             }
         }
-        let attack = new Attack(heroes, score);
+        let attack = new Attack(heroes, scores);
         let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, attack.heroes, []);
         // 刷对手
         let role = <RoleType>pvpDefense.role;
@@ -391,11 +402,11 @@ export class PvpHandler {
         let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         // 更新防守阵容
-        let score = 0, heroIdMap = new Map<number, string>(), hids: number[] = [];
+        let scores: number[] = [], heroIdMap = new Map<number, string>(), hids: number[] = [];
         for(let { actorId } of heroes) {
             let heroScore = pvpDefense.heroScores.find(cur => cur.hid == actorId);
             if(heroScore) {
-                score += heroScore.score;
+                scores.push(heroScore.score);
             }
             // 记录hero的objectId，用于存defense.heroes.hero
             if(pvpDefense.defense && pvpDefense.defense.heroes) {
@@ -417,7 +428,7 @@ export class PvpHandler {
         let defenseHeroes = heroes.map(cur => {
             return new DefenseHero(cur, heroIdMap.get(cur.actorId));
         });
-        let defense = new Defense(defenseHeroes, score, warId, buff);
+        let defense = new Defense(defenseHeroes, scores, warId, buff);
         let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, defense.heroes, dbHeroes);
 
         pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { ...refChallengeObj, defense, lineupCe });

game-server/app/services/gmService.ts

@@ -28,7 +28,7 @@ import { TreasureHuntData } from "../domain/activityField/treasureHuntField";
 import { RefreshShopData } from "../domain/activityField/refreshShopField";
 import { RoleType } from "../db/Role";
 import { MonopolyData } from "../domain/activityField/monopolyField";
-import { ActivityPopUpShopModel } from "../db/ActivityPopUpShop";
+import { ActivityPopUpShopModel, ActivityPopUpShopModelType } from "../db/ActivityPopUpShop";
 
 // —————————————— 跑马灯 —————————————— //
 // 初始
@@ -298,10 +298,24 @@ export async function getParamStr(activity: ActivityModelType, productID: string
             let allTaskData: any[] = JSON.parse(activity.data);
             let task = allTaskData.find(cur => cur.productID == productID);
             if(!task) break;
-            let beginTime = new Date();
+
-            let endTime = moment(new Date()).add(task.duration, 'h').toDate();
+            let playerRecords = await ActivityPopUpShopModel.findAllOpenData(role.serverId, activity.activityId, role.roleId);
-            let playerRecord = await ActivityPopUpShopModel.addTaskPushMessage(role.serverId, activity.activityId, role.roleId, task.id, task.taskType, task.condition, beginTime, endTime);
+            let playerRecord: ActivityPopUpShopModelType;
-            param['beginTimeStamp'] = playerRecord.beginTime;
+            for(let record of playerRecords) {
+                let playerData = new PopUpShopData(task, activity.activityId);
+                playerData.setPlayerRecords(record);
+                if (record && playerData.buyCount < task.count) {
+                    playerRecord = record; break;
+                }
+            }
+            console.log('####', playerRecord, task)
+            if(!playerRecord) {
+                let beginTime = new Date();
+                let endTime = moment(new Date()).add(task.duration, 'h').toDate();
+                playerRecord = await ActivityPopUpShopModel.addTaskPushMessage(role.serverId, activity.activityId, role.roleId, task.id, task.taskType, task.condition, beginTime, endTime);    
+            }
+
+            param['beginTimeStamp'] = playerRecord.beginTime.getTime();
             break;
         case ACTIVITY_TYPE.REFRESH_SHOP:
             let { activityGroupId } = await ServerlistModel.findByServerId(role.serverId);

game-server/app/services/pvpService.ts

@@ -6,7 +6,7 @@ import { PVP_HERO_POS, REDIS_KEY, PVP_CONST, COUNTER, TASK_TYPE, MAIL_TYPE, TA_E
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
 import { getRandSingleIndex, genCode, shouldRefresh, getChineseName, makeRobotId, robotIdComBack, getRandSingleEelm } from '../pubUtils/util';
 import { pvpEndParamInter, RewardInter } from '../pubUtils/interface';
-import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByRank, getPvpDifficultByScore } from "../pubUtils/data";
+import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByRank, getPvpDifficultByScore, getPlvAndScore } from "../pubUtils/data";
 import { PVP } from '../pubUtils/dicParam';
 import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig'
 import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
@@ -17,7 +17,7 @@ import { PvpEnemies, PvpHeroInfo, PvpOtherHeroes } from '../domain/dbGeneral';
 import { DicWarJson } from '../pubUtils/dictionary/DicWarJson';
 import { findWhere, findIndex } from 'underscore';
 import { pinus } from 'pinus';
-import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp';
+import { PvpHistoryOppModel, PvpHistoryOppType, PvpOppCreateParam } from '../db/PvpHistoryOpp';
 import { Rank } from './rankService';
 import { CounterModel } from '../db/Counter';
 import { DicRankRewads } from '../pubUtils/dictionary/DicPvpRankReward';
@@ -60,29 +60,48 @@ export async function getEnemies(oppPlayers: OppPlayer[], winStreakNum: number)
  * @param pLv 我的排名
  */
 export async function refreshEnemies(role: RoleType, seasonNum: number, sumScore: number, score: number, pLv: number) {
+    console.log('#####',seasonNum, sumScore, score, pLv)
     let { roleId } = role;
-    let oppPlayers: OppPlayer[] = [];
+    let chosenOpps: string[] = [];
+    let pvpHistoryOppParam: PvpOppCreateParam[] = [];
     let opp = dicPvpOpponent.values()
     for (let dicOpp of opp) {
-        let flag = false; // 是否筛选成功
+        let pvpHistoryOpp: PvpOppCreateParam; // 是否筛选成功
         if (sumScore >= PVP_CONST.SCORE_LINE) { // 将这个放到const
-            flag = await matchPlayer(seasonNum, oppPlayers, roleId, pLv, dicOpp); // 按照等级匹配对手
+            pvpHistoryOpp = await matchPlayer(seasonNum, chosenOpps, roleId, pLv, dicOpp); // 按照等级匹配对手
-            if (!flag) flag = await matchPlayerByRank(seasonNum, oppPlayers, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
+            if (!pvpHistoryOpp) pvpHistoryOpp = await matchPlayerByRank(seasonNum, chosenOpps, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
-            if (!flag) flag = await matchRobot(oppPlayers, role, score, dicOpp);
+            if (!pvpHistoryOpp) pvpHistoryOpp = await matchRobot(chosenOpps, role, score, dicOpp);
         } else {
-            flag = await matchRobot(oppPlayers, role, score, dicOpp);
+            pvpHistoryOpp = await matchRobot(chosenOpps, role, score, dicOpp);
         }
-        if (!flag) continue;
+        if (!pvpHistoryOpp) continue;
+        pvpHistoryOppParam.push(pvpHistoryOpp);
     }
 
+    let oppPlayers: OppPlayer[] = [];
+    pvpHistoryOppParam.sort((a, b) => {
+        if(a.pLv != b.pLv) return b.pLv - a.pLv;
+        return b.defCe - a.defCe;
+    });
+    for(let i = 0; i < pvpHistoryOppParam.length; i++) {
+        let param = pvpHistoryOppParam[i];
+        param.pos = i + 1;
+        let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp(param);
+        oppPlayers.push({
+            roleId: pvpHistoryOpp.oppRoleId,
+            oppDef: pvpHistoryOpp._id,
+            isRobot: pvpHistoryOpp.isRobot,
+            pos: pvpHistoryOpp.pos,
+        });
+    }
     return oppPlayers;
 }
 
-export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer[], roleId: string, pos: number) {
+export async function matchPlayerByRank(seasonNum: number, chosenOpps: string[], roleId: string, pos: number) {
     // console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
     let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
     let ridRanks = new Array<number>(); // 已经被使用了的排名
-    for (let { roleId: curRoleId } of oppPlayers) {
+    for (let curRoleId of chosenOpps) {
         let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId) });
         ridRanks.push(rankLv);
     }
@@ -93,7 +112,7 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
     let oppRoleId = '';
     let oppRank = 0;
     if (myRank == 0) {
-        return false
+        return null
     } else if (myRank == 1) { // 第一名
         if (pos == 1) {
             oppRank = 2;
@@ -112,7 +131,7 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
             }
         }
     } else if (myRank == 0) {
-        return false
+        return null
     } else {
         if (pos == 1 || pos == 2) { // 刷新我前一名
             oppRank = myRank - 1;
@@ -127,51 +146,42 @@ export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer
         }
     }
     let result = await r.getUserByRank(oppRank);
-    if (result.length <= 0) return false;
+    if (result.length <= 0) return null;
     oppRoleId = result[0];
 
     let pvpdefense = await PvpDefenseModel.findByRoleIdIncludeAll(oppRoleId);
-    if (!pvpdefense || pvpdefense.seasonNum != seasonNum) return false;
+    if (!pvpdefense || pvpdefense.seasonNum != seasonNum) return null;
     let pvpHistoryOpp = await generPlayerOppHis(pvpdefense, roleId, pos);
-    if (!pvpHistoryOpp) return false;
+    if (!pvpHistoryOpp) return null;
 
-    oppPlayers.push({
+    chosenOpps.push(pvpHistoryOpp.oppRoleId);
-        roleId: pvpHistoryOpp.oppRoleId,
+    return pvpHistoryOpp;
-        oppDef: pvpHistoryOpp._id,
-        pos,
-        isRobot: false,
-    });
-    return true
 }
 
-async function matchPlayer(seasonNum: number, oppPlayers: OppPlayer[], roleId: string, pLv: number, dicOpp: DicPvpOpponent) {
+async function matchPlayer(seasonNum: number, chosenOpps: string[], roleId: string, pLv: number, dicOpp: DicPvpOpponent) {
     // console.log('matchPlayer', JSON.stringify(oppPlayers))
 
     let { id: pos, minLv, maxLv } = dicOpp
     let range = await PvpDefenseModel.findByTeamLv(seasonNum, pLv + minLv, pLv + maxLv);
     range = range.filter(cur => {
-        return oppPlayers.findIndex(ccur => ccur.roleId == makeRobotId(cur.roleId)) == -1;
+        return chosenOpps.indexOf(makeRobotId(cur.roleId)) == -1;
     });
-    if (range.length <= 0) return false;
+    if (range.length <= 0) return null;
 
     let index = getRandSingleIndex(range.length);
     let result = range[index]; // 本次匹配结果 pvpdefense
-    if (!result) return false;
+    if (!result) return null;
     if (result.roleId == roleId) {
         range.splice(index, 1);
-        if (range.length <= 0) return false;
+        if (range.length <= 0) return null;
         index = getRandSingleIndex(range.length);
         result = range[index];
     }
     let pvpHistoryOpp = await generPlayerOppHis(result, roleId, pos);
-    if (!pvpHistoryOpp) return false;
+    if (!pvpHistoryOpp) return null;
-    oppPlayers.push({
+
-        roleId: pvpHistoryOpp.oppRoleId,
+    chosenOpps.push(pvpHistoryOpp.oppRoleId);
-        oppDef: pvpHistoryOpp._id,
+    return pvpHistoryOpp;
-        pos,
-        isRobot: false,
-    });
-    return true;
 }
 
 /**
@@ -219,23 +229,22 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, roleId: string, pos
     heroes.sort((a, b) => b.score - a.score);
     otherHeroes.sort((a, b) => b.score - a.score);
 
-    let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
+    return {
-        ...defense, defCe, ...role, pos, rankLv, heroes, otherHeroes, roleId, oppRoleId: makeRobotId(pvpdefense.roleId)
+        isRobot: false, ...defense, defCe, ...role, pos, rankLv, heroes, otherHeroes, roleId, oppRoleId: makeRobotId(pvpdefense.roleId)
-    });
+    };
-    return pvpHistoryOpp;
 }
 
-async function matchRobot(oppPlayers: OppPlayer[], role: RoleType, score: number, dicOpp: DicPvpOpponent) {
+async function matchRobot(chosenOpps: string[], role: RoleType, score: number, dicOpp: DicPvpOpponent) {
     // console.log('matchRobot', JSON.stringify(oppPlayers))
 
     let { lv: myLv, roleId } = role;
     let { id: pos, minLv, maxLv, ratio } = dicOpp;
 
     let result = getRandSingleEelm(gameData.pvpWar);
-    if (!result) return false;
+    if (!result) return null;
 
     let robotWarjson = gameData.warJson.get(result.war_id);
-    if (!robotWarjson) return false
+    if (!robotWarjson) return null
     let heroes: PvpEnemies[] = [];
     let defCe = 0;
     for (let h of robotWarjson) {
@@ -254,22 +263,14 @@ async function matchRobot(oppPlayers: OppPlayer[], role: RoleType, score: number
     }
 
     let oppRoleId = generateRobotRoleId();
+    chosenOpps.push(oppRoleId);
     let roleName = getChineseName();
     let pLv = getPLvByScore(score);
     let hisPLv = Math.floor(pLv + (minLv + maxLv) / 2);
     if (hisPLv < 1) hisPLv = 1
-
+    return {
-    let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
+        isRobot: true, roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0, warId: result.war_id, buff: getRandSingleEelm(result.mapseid)||0,
-        roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0, warId: result.war_id, buff: getRandSingleEelm(result.mapseid)||0,
+    };
-    });
-
-    oppPlayers.push({
-        roleId: oppRoleId,
-        oppDef: pvpHistoryOpp._id,
-        pos,
-        isRobot: true
-    });
-    return true
 }
 
 // 生成机器人roleId
@@ -414,7 +415,6 @@ export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType,
 
     const dicOpp = gameData.pvpOpponent.get(pos);
     const plusScore = getPlusScore(winStreakNum);
-    let pLv = getLvByScore(heroScores);
 
     let myHeroRecords: HeroesRecord[] = []; // 存入rec里面的数据
     let showHeroScores = new Array<{ hid: number, addScore: number, plusScore: number, score: number }>();
@@ -449,7 +449,7 @@ export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType,
     }
 
     let attackInfo = new PvpRecordPlayerInfo();
-    attackInfo.setByRole(role, myHeroRecords, isSuccess, isSuccess ? addSumScore : 0, pLv)
+    attackInfo.setByRole(role, myHeroRecords, isSuccess, isSuccess ? addSumScore : 0, attack.pLv);
 
     let newAttack = <Attack>calLineupScore(attack, heroScores);
     let newDefense = <Defense>calLineupScore(defense, heroScores);
@@ -463,14 +463,14 @@ export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType,
 
 function calLineupScore(lineup: Attack|Defense, heroScores: HeroScore[]) {
     if(!lineup) return lineup;
-    let score = 0;
+    let scores: number[] = [];
     for(let { actorId } of lineup.heroes) {
         let hs = heroScores.find(cur => cur.hid == actorId);
         if(hs) {
-            score += hs.score;
+            scores.push(hs.score);
         }
     }
-    let pLv = getPLvByScore(score);
+    let { pLv, score } = getPlvAndScore(scores);
     return {...lineup, score, pLv}
 }
 

shared/consts/constModules/sysConst.ts

@@ -1007,6 +1007,7 @@ export enum ITEM_CHANGE_REASON {
 
 export enum TA_EVENT {
     REGISTER = 'register',                   // 注册
+    CREATE_ROLE = 'create_role',             // 创建角色
     RECHARGE = 'recharge',                   // 发起充值
     RECHARGE_SUCCESS = 'recharge_success',   // 充值成功
     RECHARGE_FAIL = 'recharge_fail',         // 充值失败

shared/db/PvpDefense.ts

@@ -22,6 +22,8 @@ export default class PvpDefense extends BaseModel {
     lineupCe: LineupCe[];
     @prop({ required: true, type: () => OppPlayer, default: [], _id: false })
     oppPlayers: OppPlayer[];
+    @prop({ required: true, type: () => OppPlayer, default: [], _id: false })
+    oppBeforePlayers: OppPlayer[];
     @prop({ required: true, type: () => HeroScore, default: [], _id: false })
     heroScores: HeroScore[];
 
@@ -112,7 +114,8 @@ export default class PvpDefense extends BaseModel {
         const result: PvpDefenseType = await PvpDefenseModel.findOne({ roleId })
         .populate('role', 'head frame spine topLineupCe roleId roleName lv globalCeAttr')
         .populate('heroes.hero')
-        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv title lv pLv defCe heroes warId buff').lean({ getters: true, virtuals: true });
+        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv title lv pLv defCe heroes warId buff')
+        .populate('oppBeforePlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv title lv pLv defCe heroes warId buff').lean({ getters: true, virtuals: true });
         return result;
     }
 

shared/db/PvpHistoryOpp.ts

@@ -20,6 +20,8 @@ export default class PvpHistoryOpp extends BaseModel {
     @prop({ required: true })
     oppRoleId: string;		    	// 对手角色 id
     @prop({ required: true })
+    isRobot: boolean;		    	// 是否是机器人
+    @prop({ required: true })
     roleName: string;				// 角色名称
     @prop({ required: true, default: EXTERIOR.EXTERIOR_FACE })
     head: number;                // 对手头像

shared/domain/battleField/pvp.ts

@@ -4,7 +4,7 @@ import Hero from '../../db/Hero';
 import { PvpDefenseType } from '../../db/PvpDefense';
 import PvpHistoryOpp from '../../db/PvpHistoryOpp';
 import { PvpSeasonResultType } from '../../db/PvpSeasonResult';
-import { getPLvByScore } from '../../pubUtils/data';
+import { getPlvAndScore } from '../../pubUtils/data';
 import { RewardInter } from '../../pubUtils/interface';
 
 
@@ -43,10 +43,12 @@ export class Defense {
     @prop({ required: true })
     pLv: number;                // 防守阵容的等级
     
-    constructor(heroes: DefenseHero[], score: number, warId: number, buff: number) {
+    constructor(heroes: DefenseHero[], scores: number[], warId: number, buff: number) {
         this.heroes = heroes;
+        this.score = scores.reduce((pre, cur) => pre + cur, 0);
+        let {pLv, score} = getPlvAndScore(scores);
+        this.pLv = pLv,
         this.score = score;
-        this.pLv = getPLvByScore(score);
         this.warId = warId;
         this.buff = buff;
     }
@@ -69,10 +71,12 @@ export class Attack {
     @prop({ required: true })
     pLv: number;                // 防守阵容的等级
 
-    constructor(heroes: AttackHero[], score: number) {
+    constructor(heroes: AttackHero[], scores: number[]) {
         this.heroes = heroes;
+        this.score = scores.reduce((pre, cur) => pre + cur, 0);
+        let {pLv, score} = getPlvAndScore(scores);
+        this.pLv = pLv;
         this.score = score;
-        this.pLv = getPLvByScore(score);
     }
 }
 

shared/pubUtils/data.ts

@@ -427,6 +427,13 @@ export function getPLvByScore(score: number) {
     return lv;
 }
 
+export function getPlvAndScore(scores: number[] = []) {
+    if(scores.length <= 0) scores = [0];
+    let maxScore = Math.max(...scores); // 等级：军功最高者的军功*6
+    let score = scores.reduce((pre, cur) => pre + cur, 0);
+    return { score, pLv: getPLvByScore(maxScore * 6)};
+}
+
 export function getPvpHeroRewardsByScore(score: number) {
     for (let item of gameData.pvpHeroRewards) {
         if ((item.max >= score || item.max == -1) && score >= item.min) {

web-server/app/controller/account.ts

@@ -46,8 +46,8 @@ export default class AccountController extends Controller {
 
   public async createRole() {
     const { ctx } = this;
-    const { serverId } = ctx.request.body;
+    const { serverId, distinctId } = ctx.request.body;
-    ctx.body = await ctx.service.auth.createRole(serverId);
+    ctx.body = await ctx.service.auth.createRole(serverId, distinctId);
   }
 
   public async bind() {

web-server/app/service/Auth.ts

@@ -302,7 +302,7 @@ export default class Auth extends Service {
         return ctx.service.utils.resResult(STATUS.ROLE_NOT_FOUND);
     }
 
-    public async createRole(serverId: number) {
+    public async createRole(serverId: number, distinctId: string) {
         console.log('enter Auth createRole');
         const ctx = this.ctx;
         const { uid } = ctx;
@@ -324,6 +324,7 @@ export default class Auth extends Service {
             // 任务
             await checkTask(roleId, TASK_TYPE.ROLE_LV, role.lv, false, {});
 
+            ctx.service.sdk.reportTAEventWithRoleIdAndDistinctId(roleId, distinctId, TA_EVENT.CREATE_ROLE, null, ctx.clientIp);
             return ctx.service.utils.resResult(STATUS.SUCCESS, { roleId: role.roleId });
         }
         return ctx.service.utils.resResult(STATUS.ROLE_NOT_FOUND);
@@ -401,7 +402,7 @@ export default class Auth extends Service {
     public async channelLogin(params: {
         channelType: string, pst: string, clientId: string, deviceId: string, platform: string, platformAppid: string, childGameId: number, pkgName: string, serverType: string, getuiCID: string, distinctId: string
     }) {
-        const { channelType, pst, clientId, deviceId, platform, platformAppid, childGameId, pkgName, serverType, getuiCID, distinctId } = params;
+        const { channelType, pst, clientId, deviceId, platform, platformAppid, childGameId, pkgName, serverType, getuiCID } = params;
         
         const ctx = this.ctx;
 
@@ -418,7 +419,7 @@ export default class Auth extends Service {
             ...requestResult.data, childGameId, platformAppid
         }, token, platform, pkgName, serverType, deviceId, ctx.clientIp);
         if(isCreate) {
-            ctx.service.sdk.reportTAEventWithDistinctId(distinctId, TA_EVENT.REGISTER, null, ctx.clientIp);
+            // ctx.service.sdk.reportTAEventWithDistinctId(distinctId, TA_EVENT.REGISTER, null, ctx.clientIp);
         }
 
         if (getuiCID) {//更新个推cid

web-server/app/service/Sdk.ts

@@ -277,4 +277,27 @@ export default class Sdk extends Service {
         ta.track(event);
     }
 
+    public reportTAEventWithRoleIdAndDistinctId(roleId: string, distinctId: string, eventName: string, properties: any, ip?: string) {
+        let ta = this.app.context.ta;
+        let event = {
+            // 账号 ID （可选)
+            accountId: `${roleId}`,
+            // 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
+            distinctId: distinctId? `${distinctId}`: "",
+            // 事件名称 （必填)
+            event: eventName,
+            // 事件时间 (可选) 如果不填，将以调用接口时的时间作为事件时间
+            time: new Date(),
+            // 事件 IP (可选) 当传入 IP 地址时，后台可以解析所在地
+            ip: ip,
+            // 事件属性 (可选)
+            properties,
+            callback(err) {
+                console.log('*****测试接入事件', err)
+            }
+
+        };
+        ta.track(event);
+    }
+
 }