pvp：修改随机对手逻辑

game-server/app/services/pvpService.ts

@@ -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

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;                // 对手头像