pvp：结算阵容分数

game-server/app/services/pvpService.ts

@@ -10,7 +10,7 @@ import { gameData, getPLvByScore, getPvpHeroRewardsByScore, getPvpRankRewardsByR
 import { PVP } from '../pubUtils/dicParam';
 import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig'
 import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
-import { HeroesRecord } from '../db/PvpRecord';
+import { HeroesRecord, PvpRecordPlayerInfo } from '../db/PvpRecord';
 import { HeroModel, CeAttrData, HeroType } from '../db/Hero';
 import { AttributeCal } from '../domain/roleField/attribute';
 import { PvpEnemies, PvpHeroInfo, PvpOtherHeroes } from '../domain/dbGeneral';
@@ -37,7 +37,6 @@ export async function getEnemies(oppPlayers: OppPlayer[], winStreakNum: number)
     for (let oppPlayer of oppPlayers) {
         let dicOpponent = dicPvpOpponent.get(oppPlayer.pos);
         let oppDef = <PvpHistoryOppType>oppPlayer.oppDef; // select 'oppRoleId pos roleName head frame spine rankLv pLv defCe'
-console.log('*******', oppDef)
 
         if (oppDef) delete oppDef.heroes;
         result.push({
@@ -393,19 +392,24 @@ export function getPlayerMainAttribute(heroAttrs: CeAttrData[], roleAttrs: CeAtt
 }
 
 // 获取我方战报记录
-export async function generMyRecInfo(heroScores: HeroScore[], winStreakNum: number, role: RoleType, isSuccess: boolean, pos: number, myHeroes: pvpEndParamInter[]) {
-
-    let { roleId, roleName } = role;
+export async function generMyRecInfo(pvpDefense: PvpDefenseType, role: RoleType, isSuccess: boolean, pos: number, myHeroes: pvpEndParamInter[]) {
+    let { attack, defense, heroScores, winStreakNum, score, hisScore } = pvpDefense;
+    let { roleId } = role;
+    if (isSuccess) {
+        winStreakNum ++;
+    } else {
+        winStreakNum = 0;
+    }
 
     const dicOpp = gameData.pvpOpponent.get(pos);
     const plusScore = getPlusScore(winStreakNum);
     let pLv = getLvByScore(heroScores);
 
-    // TODO 这里heroScore可以改为不改变原数据，而创建新数据的方式
-    let myHeroRecords = new Array<HeroesRecord>();
+    let myHeroRecords: HeroesRecord[] = []; // 存入rec里面的数据
     let showHeroScores = new Array<{ hid: number, addScore: number, plusScore: number, score: number }>();
     let addSumScore = 0;
-    for (let { hid, damage, heal, underDamage } of myHeroes) {
+    for (let { actorId: hid } of attack.heroes) {
+        let params = myHeroes.find(cur => cur.hid == hid);
         let curHeroScore = heroScores.find(cur => cur.hid == hid);
         if (isSuccess) {
             if (!curHeroScore) {
@@ -426,28 +430,35 @@ export async function generMyRecInfo(heroScores: HeroScore[], winStreakNum: numb
             });
         }
         const myHero = await HeroModel.findByHidAndRole(hid, roleId, 'quality star colorStar lv skinId');
-        let { quality, star, colorStar, lv, skinId } = myHero;
 
-        myHeroRecords.push({
-            hid, quality, star, colorStar, lv, damage, heal, underDamage, skinId
-        });
+        let record = new HeroesRecord();
+        record.setByHero(myHero, params);
+        myHeroRecords.push(record);
     }
 
-    let attackInfo = {
-        roleId,
-        roleName,
-        lv: pLv,
-        head: role.head,
-        frame: role.frame,
-        spine: role.spine,
-        title: role.title,
-        ce: role.topLineupCe,
-        heroes: myHeroRecords,
-        isSuccess,
-        score: isSuccess ? addSumScore : 0
+    let attackInfo = new PvpRecordPlayerInfo();
+    attackInfo.setByRole(role, myHeroRecords, isSuccess, isSuccess ? addSumScore : 0, pLv)
+
+    let newAttack = <Attack>calLineupScore(attack, heroScores);
+    let newDefense = <Defense>calLineupScore(defense, heroScores);
+
+    let updateParam = {
+        winStreakNum, attack: newAttack, defense: newDefense, heroScores, score: score + addSumScore, hisScore: hisScore > score + addSumScore? hisScore: score + addSumScore
     }
 
-    return { attackInfo, showHeroScores, addSumScore, newHeroScore: heroScores }
+    return { attackInfo, showHeroScores, updateParam }
+}
+
+function calLineupScore(lineup: Attack|Defense, heroScores: HeroScore[]) {
+    let score = 0;
+    for(let { actorId } of lineup.heroes) {
+        let hs = heroScores.find(cur => cur.hid == actorId);
+        if(hs) {
+            score += hs.score;
+        }
+    }
+    let pLv = getPLvByScore(score);
+    return {...lineup, score, pLv}
 }
 
 // 获取对手战报记录
@@ -455,26 +466,41 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayer,
     let oppHeroRecords = new Array<HeroesRecord>();
     let oppRole = <PvpHistoryOppType>curOpp.oppDef;
     if (!oppRole) { console.error('opp role not found') }
-    for (let { hid, damage, heal, underDamage } of oppHeroes) {
-        let historyHero = oppRole.heroes.find(cur => cur.actorId == hid);
+
+    for (let params of oppHeroes) {
+        let historyHero = oppRole.heroes.find(cur => cur.actorId == params.hid);
         if (historyHero) {
-            let hs = new HeroesRecord(historyHero, damage, heal, underDamage);
+            let hs = new HeroesRecord();
+            hs.setByPvpHeroInfo(historyHero, params);
             oppHeroRecords.push(hs);
         }
     }
-    return {
-        roleId: robotIdComBack(oppRole.oppRoleId),
-        roleName: oppRole.roleName,
-        lv: oppRole.pLv,
-        head: oppRole.head,
-        frame: oppRole.frame,
-        spine: oppRole.spine,
-        title: oppRole.title,
-        ce: oppRole.defCe,
-        heroes: oppHeroRecords,
-        isSuccess: !isSuccess,
-        score: 0
+    let addSumScore = 0;
+    if(!curOpp.isRobot && !isSuccess) {
+        let pvpDefense = await PvpDefenseModel.findByRoleId(oppRole.roleId);
+        if(pvpDefense && pvpDefense.defense) {
+            let { attack, defense, heroScores, score } = pvpDefense;
+            for(let { actorId } of defense.heroes) {
+                let hs = heroScores.find(cur => cur.hid == actorId);
+                if(hs) {
+                    hs.score += PVP.PVP_DEFENSE_SUCCESS_REWARD;
+                } else {
+                    heroScores.push({ hid: actorId, score: PVP.PVP_DEFENSE_SUCCESS_REWARD })
+                }
+                addSumScore += PVP.PVP_DEFENSE_SUCCESS_REWARD;
+            }
+
+            let newAttack = <Attack>calLineupScore(attack, heroScores);
+            let newDefense = <Defense>calLineupScore(defense, heroScores);
+
+            await PvpDefenseModel.updateInfo(oppRole.roleId, { attack: newAttack, defense: newDefense, heroScores, score: score + addSumScore });
+
+        }
     }
+
+    let defenseInfo = new PvpRecordPlayerInfo();
+    defenseInfo.setByHistoryOpp(oppRole, oppHeroRecords, !isSuccess, isSuccess ? 0 : addSumScore)
+    return defenseInfo
 }
 
 /**