pvp: 修复重复对手bug

game-server/app/services/playerCeService.ts

@@ -10,23 +10,34 @@ import { calPlayerCeAndSave as pubCalPlayerCeAndSave,  reCalAllHeroCe } from '..
 import Hero, { HeroType, HeroUpdate } from '../db/Hero';
 import { defaultHeroes } from './pvpService'; 
 import { RoleUpdate } from '../db/Role';
+import { redisUserInfoUpdate } from './redisService';
+import { REDIS_KEY } from '../consts';
 
 //修改并下发战力
 export async function calPlayerCeAndSave(type: number, sid: string, roleId: string, originHero: HeroType, update: HeroUpdate, args?: Array<number>) {
-    let {role, pushHeros, topLineupCe, hero} = await pubCalPlayerCeAndSave(type, roleId, originHero, update, args);
+    let {role, pushHeros, topLineupCe, hero, guild} = await pubCalPlayerCeAndSave(type, roleId, originHero, update, args);
     console.log(JSON.stringify(pushHeros))
     //下发战力
     let uids = [{ uid: roleId, sid }];
     pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: reduceCe(role.ce) , heros: pushHeros, topLineupCe:  reduceCe(topLineupCe) }), uids);
     defaultHeroes(role);
+
+    if(guild) {
+        await redisUserInfoUpdate(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]);
+    }
+
     return hero;
 }
 
 export async function calAllHeroCe(type:number, sid: string, roleId: string, update: RoleUpdate, args?:Array<number>) {
-    let {role, ce, pushHeros, topLineupCe } = await reCalAllHeroCe(type, roleId, update, args);
+    let {role, ce, pushHeros, topLineupCe, guild } = await reCalAllHeroCe(type, roleId, update, args);
     if(pushHeros.length > 0) {
         let uids = [{ uid: roleId, sid }];
         pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: reduceCe(ce), heros: pushHeros, topLineupCe: reduceCe(topLineupCe) }), uids);    
+    
+        if(guild) {
+            await redisUserInfoUpdate(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]);
+        }
     }
     return role;
 }

game-server/app/services/pvpService.ts

@@ -100,8 +100,8 @@ export async function refreshEnemies(role: RoleType, score: number, pLv: number)
     for(let dicOpp of opp) {
         let flag = false; // 是否筛选成功
         if(score >= PVP_CONST.SCORE_LINE) { // 将这个放到const
-            flag = await matchPlayer(oppPlayers, mapWarJson, roleId, pLv, dicOpp); // 按照等级匹配对手
+            flag = await matchPlayer(system.seasonNum, oppPlayers, mapWarJson, roleId, pLv, dicOpp); // 按照等级匹配对手
-            if(!flag) flag = await matchPlayerByRank(oppPlayers, mapWarJson, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
+            if(!flag) flag = await matchPlayerByRank(system.seasonNum, oppPlayers, mapWarJson, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
             if(!flag) flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
         } else {
             flag = await matchRobot(oppPlayers, mapWarJson, role, pLv, dicOpp);
@@ -112,24 +112,33 @@ export async function refreshEnemies(role: RoleType, score: number, pLv: number)
     return oppPlayers;
 }
 
-export async function matchPlayerByRank(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pos: number) {
+export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pos: number) {
     console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
     let ridRanks = new Array<number>(); // 已经被使用了的排名
     for(let { roleId: curRoleId } of oppPlayers) {
         let rankLv = await getMyRank(REDIS_KEY.PVP_RANK, 0, robotIdComBack(curRoleId));
         ridRanks.push(rankLv);
     }
+    console.log('ridRanks', pos, JSON.stringify(ridRanks));
     let myRank = await getMyRank(REDIS_KEY.PVP_RANK, 0, roleId);
-    ridRanks.push(myRank);
     let oppRoleId = '';
     let oppRank = 0;
     if(myRank == 1) { // 第一名
         if(pos == 1) {
             oppRank = 2;
+            while(ridRanks.includes(oppRank)) {
+                oppRank --;
+            }
         } else if(pos == 2) {
             oppRank = 3;
+            while(ridRanks.includes(oppRank)) {
+                oppRank --;
+            }
         } else {
             oppRank = 4;
+            while(ridRanks.includes(oppRank)) {
+                oppRank ++;
+            }
         }
     } else {
         if(pos == 1 || pos == 2) { // 刷新我前一名
@@ -149,7 +158,7 @@ export async function matchPlayerByRank(oppPlayers: OppPlayers[], mapWarJson: Di
     oppRoleId = result[0];
 
     let pvpdefense = await PvpDefenseModel.findByRoleIdIncludeAll(oppRoleId);
-    if(!pvpdefense) return false;
+    if(!pvpdefense || pvpdefense.seasonNum != seasonNum) return false;
     let pvpHistoryOpp = await generPlayerOppHis(pvpdefense, mapWarJson, roleId, pos);
     if(!pvpHistoryOpp) return false;
 
@@ -162,11 +171,11 @@ export async function matchPlayerByRank(oppPlayers: OppPlayers[], mapWarJson: Di
     return true
 }
 
-async function matchPlayer(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pLv: number, dicOpp: DicPvpOpponent ) {
+async function matchPlayer(seasonNum: number, oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], roleId: string, pLv: number, dicOpp: DicPvpOpponent ) {
     console.log('matchPlayer', JSON.stringify(oppPlayers))
 
     let { id: pos, minLv, maxLv } = dicOpp
-    let range = await PvpDefenseModel.findByTeamLv(pLv + minLv, pLv + maxLv);
+    let range = await PvpDefenseModel.findByTeamLv(seasonNum, pLv + minLv, pLv + maxLv);
     range = range.filter(cur => {
         return oppPlayers.findIndex(ccur => ccur.roleId == makeRobotId(cur.roleId)) == -1;
     });
@@ -273,7 +282,7 @@ async function matchRobot(oppPlayers: OppPlayers[], mapWarJson: DicWarJson[], ro
     if(hisPLv < 1) hisPLv = 1
 
     let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
-        roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes
+        roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0
     });
 
     oppPlayers.push({

game-server/app/services/redisService.ts

@@ -233,7 +233,12 @@ export async function getRank(key: string, serverId: number, roleId: string, lim
 // 获取我的排名
 export async function getMyRank(key: string, serverId: number, roleId: string) {
     let myRank = await redisClient().zrevrankAsync(getKeyName(key, serverId), roleId);
-    return myRank + 1;
+
+    if(!myRank && myRank != 0) {
+        return 0
+    } else {
+        return myRank + 1;
+    }
 }
 
 // 获取排名第几名的信息

shared/db/PvpDefense.ts

@@ -140,7 +140,7 @@ export default class PvpDefense extends BaseModel {
     }
 
     public static async updateCe(roleId: string, hid: number, defCe: number, lean = true) {   
-        const rec: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId, 'heroes.actorId': hid }, { $set: { defCe } }).lean(lean);
+        const rec: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId, 'heroes.actorId': hid }, { $inc: { defCe } }).lean(lean);
         return rec
     }
 
@@ -157,8 +157,8 @@ export default class PvpDefense extends BaseModel {
         return result;
     }
 
-    public static async findByTeamLv(min: number, max: number) {
+    public static async findByTeamLv(seasonNum: number, min: number, max: number) {
-        const result: PvpDefenseType[] = await PvpDefenseModel.find({ pLv: { $gte: min, $lte: max } })
+        const result: PvpDefenseType[] = await PvpDefenseModel.find({ seasonNum, pLv: { $gte: min, $lte: max } })
         .populate('role', 'head frame spine topLineupCe roleId roleName lv globalCeAttr')
         .populate('heroes.hero')
         .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine rankLv pLv title lv defCe heroes')

shared/pubUtils/playerCe.ts

@@ -43,7 +43,7 @@ export async function calPlayerCeAndSave(type: number, roleId: string, originHer
     let { topLineup, topLineupCe } = await calculatetopLineup(role, originHero.hid, heroCe, originHero._id); // 计算更新最强五人战力
     role = await RoleModel.updateRoleInfo(roleId, { ce: role.ce + incCe, topLineup, topLineupCe });
 
-    await PvpDefenseModel.updateCe(roleId, originHero.hid, heroCe); // 更新pvp防守阵战力
+    await PvpDefenseModel.updateCe(roleId, originHero.hid, incCe); // 更新pvp防守阵战力
     let guild = await GuildModel.updateCe(roleId, incCe); // 公会更新战力
 
     let pushHeros = new Array<{ hid: number, ce: number, incHeroCe: number }>();
@@ -66,6 +66,7 @@ export async function reCalAllHeroCe(type: number, roleId: string, update: RoleU
     let pushHeros = new Array<{ hid: number, ce: number, incHeroCe: number }>();
 
     let roleCe = 0; // 总战力加成
+    let allIncCe = 0;
     for (let hero of heros) {
         let { attr: heroAttrs } = hero;
         let newAttr = new Attribute();
@@ -73,9 +74,12 @@ export async function reCalAllHeroCe(type: number, roleId: string, update: RoleU
         let heroCe = newAttr.calCe(); // 计算最终战力
 
         let incHeroCe = heroCe - hero.ce;
+        allIncCe += incHeroCe;
         roleCe += heroCe;
         pushHeros.push({ hid: hero.hid, ce: reduceCe(hero.ce), incHeroCe: reduceCe(incHeroCe) });
         await HeroModel.updateHeroInfo(roleId, hero.hid, { ce: heroCe });   
+        await PvpDefenseModel.updateCe(roleId, hero.hid, incHeroCe); // 更新pvp防守阵战力
+
     }
     let { topLineup, topLineupCe } = await calculatetopLineup(role); // 计算更新最强五人战力
 
@@ -85,7 +89,8 @@ export async function reCalAllHeroCe(type: number, roleId: string, update: RoleU
     update.topLineupCe = topLineupCe;
 
     role = await RoleModel.updateRoleInfo(roleId, update);
-    return { role, pushHeros, ce: role.ce, topLineupCe: role.topLineupCe }
+    let guild = await GuildModel.updateCe(roleId, allIncCe); // 公会更新战力
+    return { role, pushHeros, ce: role.ce, topLineupCe: role.topLineupCe, guild }
 }
 
 // 计算武将全局战力