xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'feature/test'

Browse Source
This commit is contained in:
luying
2022-03-04 16:33:55 +08:00
parent 051dd56f9e 78e166c5ef
commit c06ef998ff
11 changed files with 165 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game-server/app/services/gmService.ts
+19 -5
View File
@@ -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 playerRecord = await ActivityPopUpShopModel.addTaskPushMessage(role.serverId, activity.activityId, role.roleId, task.id, task.taskType, task.condition, beginTime, endTime);
param['beginTimeStamp'] = playerRecord.beginTime;
let playerRecords = await ActivityPopUpShopModel.findAllOpenData(role.serverId, activity.activityId, role.roleId);
let playerRecord: ActivityPopUpShopModelType;
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
+60 -60
View File
@@ -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); // 按照等级匹配对手
if (!flag) flag = await matchPlayerByRank(seasonNum, oppPlayers, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
if (!flag) flag = await matchRobot(oppPlayers, role, score, dicOpp);
pvpHistoryOpp = await matchPlayer(seasonNum, chosenOpps, roleId, pLv, dicOpp); // 按照等级匹配对手
if (!pvpHistoryOpp) pvpHistoryOpp = await matchPlayerByRank(seasonNum, chosenOpps, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
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({
roleId: pvpHistoryOpp.oppRoleId,
oppDef: pvpHistoryOpp._id,
pos,
isRobot: false,
});
return true
chosenOpps.push(pvpHistoryOpp.oppRoleId);
return pvpHistoryOpp;
}
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;
oppPlayers.push({
roleId: pvpHistoryOpp.oppRoleId,
oppDef: pvpHistoryOpp._id,
pos,
isRobot: false,
});
return true;
if (!pvpHistoryOpp) return null;
chosenOpps.push(pvpHistoryOpp.oppRoleId);
return pvpHistoryOpp;
}
/**
@@ -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({
...defense, defCe, ...role, pos, rankLv, heroes, otherHeroes, roleId, oppRoleId: makeRobotId(pvpdefense.roleId)
});
return pvpHistoryOpp;
return {
isRobot: false, ...defense, defCe, ...role, pos, rankLv, heroes, otherHeroes, roleId, oppRoleId: makeRobotId(pvpdefense.roleId)
};
}
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
let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
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
return {
isRobot: true, roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0, warId: result.war_id, buff: getRandSingleEelm(result.mapseid)||0,
};
}
// 生成机器人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}
}