将刷新添加入初始

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

@@ -1,7 +1,7 @@
 import {Application, BackendSession} from 'pinus';
 const _ = require('underscore');
 import { gameData } from '../../../pubUtils/data';
-import { checkPvp } from '../../../pubUtils/pvpUtil';
+import { checkPvp, initPvpInfo } from '../../../pubUtils/pvpUtil';
 import { RoleModel } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
@@ -16,6 +16,13 @@ export class PvpHandler {
     constructor(private app: Application) {
     }
 
+    async test(msg: {}, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let role = await RoleModel.findByRoleId(roleId);
+        const result = await initPvpInfo(role);
+        return resResult(STATUS.SUCCESS, {result});
+    }
+
     async getData (msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');

game-server/app/services/pvpService.ts

@@ -1,50 +0,0 @@
-import { dicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
-import { OppPlayers, PvpDefenseModel } from "../db/PvpDefense";
-import { getRandomIndexByLen } from '../pubUtils/util';
-import { RoleType } from "../db/Role";
-
-export async function refreshEnemies(role: RoleType, score: number, pLv: number) {
-    let { roleId, topFiveCe } = role;
-    let oppPlayers = new Array<OppPlayers>();
-    let opp = dicPvpOpponent.values()
-    for(let { id, maxLv, minLv, ratio } of opp) {
-        let flag = false; // 是否筛选成功
-        if(score > 3000) {
-            flag = await matchPlayer(oppPlayers,roleId,  id, pLv + minLv, pLv + maxLv);
-            // TODO 当前后分数段没有时，返回前一名的玩家
-            if(!flag) flag = matchRobot(oppPlayers, topFiveCe, ratio);
-        } else {
-            flag = matchRobot(oppPlayers, topFiveCe, ratio);
-        }
-        return flag;
-    }
-    
-    return oppPlayers;
-}
-
-async function matchPlayer(oppPlayers: OppPlayers[], roleId: string, pos: number, minLv: number, maxLv: number ) {
-    let range = await PvpDefenseModel.findByTeamLv(minLv, maxLv);
-    if(range.length <= 0) return false;
-
-    let index = getRandomIndexByLen(range.length);
-    let result = range[index];
-    if(!result) return false;
-    if(result.roleId == roleId) {
-        range.splice(index, 1);
-        if(range.length <= 0) return false;
-        index = getRandomIndexByLen(range.length);
-        result = range[range.length];
-    }
-    
-    oppPlayers.push({
-        oppDef: result._id,
-        pos,
-        isRobot: false,
-        robot: null
-    });
-    return true;
-}
-
-function matchRobot(oppPlayers: OppPlayers[], ce: number, ratio: number) {
-    return true
-}

shared/consts/constModules/battleConst.ts

@@ -148,3 +148,7 @@ export const COM_BATTLE_ROBOT_ID_NAME = [
   {robotRoleId: 'l6wopj9p', robotRoleName: '颜校'},
   {robotRoleId: '6wdqcumj', robotRoleName: '吉辉娇'}
 ];
+
+export const ROBOT_NAME = [
+  '徐埋农', '简普瞳', '邛瑛', '嵇晁伊', '颜校', '吉辉娇'
+];

shared/db/PvpDefense.ts

@@ -41,19 +41,26 @@ function getInitialOppHeros() {
     return heros;
 }
 
-class Robot {
+export class Robot {
     @prop({ required: true })
     roleId: string;					// 角色 id
     @prop({ required: true })
     roleName: string;				// 角色名称
-    @prop({ required: true })
+    @prop({ required: true, default: 19 })
     headHid: number;    
-    @prop({ required: true })
+    @prop({ required: true, default: 19 })
     sHid: number;
     @prop({ required: true })
     defCe: number;
     @prop({ required: true })
     warId: number;                   // 模板的warId
+    
+    constructor(roleId: string, roleName: string, defCe: number, warId: number) {
+        this.roleId = roleId;
+        this.roleName = roleName;
+        this.defCe = defCe;
+        this.warId = warId;
+    }
 }
 
 export class OppPlayers {

shared/pubUtils/pvpUtil.ts

@@ -1,9 +1,14 @@
 /**
  * 体力系统
  */
-import { PvpDefenseModel, Heroes, OppPlayers } from '../db/pvpDefense';
+import { PvpDefenseModel, Heroes, OppPlayers, Robot } from '../db/pvpDefense';
 import { RoleType } from '../db/Role';
-import { PVP_PLAYER_POS, PVP_HERO_POS } from '../consts';
+import { PVP_PLAYER_POS, PVP_HERO_POS, ROBOT_NAME } from '../consts';
+
+import { dicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
+import { getRandomIndexByLen, genCode, getRandomByLen } from '../pubUtils/util';
+import { gameData } from "../pubUtils/data";
+
 
 export async function initPvpInfo(role: RoleType) {
     let heroes: Array<Heroes> = [];
@@ -21,7 +26,7 @@ export async function initPvpInfo(role: RoleType) {
         }
     }
     //初始化对手人阵容TODO
-    let oppPlayers: Array<OppPlayers> = [];
+    let oppPlayers: Array<OppPlayers> = await refreshEnemies(role, 0, 1);
     
     let result = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, heroes, oppPlayers, defCe: role.topFiveCe });
     //加入排行榜 TODO
@@ -35,3 +40,76 @@ export async function checkPvp(role: RoleType) {
     result = await initPvpInfo(role);
     return result;
 }
+
+
+
+// 刷新对手
+export async function refreshEnemies(role: RoleType, score: number, pLv: number) {
+    let { roleId, topFiveCe } = role;
+    let oppPlayers = new Array<OppPlayers>();
+    let opp = dicPvpOpponent.values()
+    for(let { id, maxLv, minLv, ratio } of opp) {
+        let flag = false; // 是否筛选成功
+        if(score > 3000) { // TODO 将这个放到const
+            flag = await matchPlayer(oppPlayers,  id, roleId, pLv + minLv, pLv + maxLv);
+            // TODO 当前后分数段没有时，返回前一名的玩家
+            if(!flag) flag = matchRobot(oppPlayers, id, topFiveCe, ratio);
+        } else {
+            flag = matchRobot(oppPlayers, id, topFiveCe, ratio);
+        }
+        if(!flag) continue;
+    }
+    
+    return oppPlayers;
+}
+
+async function matchPlayer(oppPlayers: OppPlayers[], pos: number, roleId: string, minLv: number, maxLv: number ) {
+    let range = await PvpDefenseModel.findByTeamLv(minLv, maxLv);
+    if(range.length <= 0) return false;
+
+    let index = getRandomIndexByLen(range.length);
+    let result = range[index];
+    if(!result) return false;
+    if(result.roleId == roleId) {
+        range.splice(index, 1);
+        if(range.length <= 0) return false;
+        index = getRandomIndexByLen(range.length);
+        result = range[range.length];
+    }
+    
+    oppPlayers.push({
+        oppDef: result._id,
+        pos,
+        isRobot: false,
+        robot: null
+    });
+    return true;
+}
+
+function matchRobot(oppPlayers: OppPlayers[], pos: number, myCe: number, ratio: number) {
+    let range = gameData.pvpWar;
+    if(range.length <= 0) return false;
+
+    let index = getRandomIndexByLen(range.length);
+    let result = range[index];
+    if(!result) return false;
+
+    let roleId = generateRobotRoleId();
+    let roleName = getRandomByLen(ROBOT_NAME);
+    let robot = new Robot(roleId, roleName, Math.floor(myCe * ratio), result.war_id)
+    oppPlayers.push({
+        oppDef: null,
+        pos,
+        isRobot: true,
+        robot
+    });
+    return true
+}
+
+function generateRobotRoleId() {
+    return `${genCode(10)}_r`;
+}
+
+export function checkRoleIsRobot(roleId: string) {
+    return !!roleId.match(/_r/);
+}

shared/pubUtils/util.ts

@@ -168,6 +168,7 @@ export async function calculateSumCE(roleId: string, type: number, param: { num?
 }
 
 export function getRandomByLen(arr: Array<number>): number
+export function getRandomByLen(arr: Array<string>): string
 export function getRandomByLen(arr: Array<DicRandomEffectPool>): DicRandomEffectPool
 export function getRandomByLen(arr: Array<any>): any {
     let len = arr.length;