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

57
game-server/app/servers/battle/handler/pvpHandler.ts
View File

@@ -159,14 +159,13 @@ export class PvpHandler {
let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
// 检查挑战次数
let seasonNum: number = this.app.get('pvpSeasonNum');
let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
let { challengeCnt, challengeRefTime } = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
if (challengeCnt == 0) {
return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
}
await PvpDefenseModel.updateInfo(roleId, { challengeCnt, challengeRefTime });
let { oppPlayers } = pvpDefense;
let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId);
let curOpp = pvpDefense.oppPlayers.find(cur => cur.roleId == oppRoleId);
if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
const battleCode = genCode(8); // 关卡唯一值
@@ -183,8 +182,32 @@ export class PvpHandler {
}, true);
await checkTask(roleId, sid, TASK_TYPE.PVP, 1, true, {});
// 对手记录更新
await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
let update: pvpUpdateInter = {
oppBeforePlayers: pvpDefense.oppPlayers
};
// 刷新对手
const role = await RoleModel.findByRoleId(roleId, null, true);
let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score ,pvpDefense.attack.score, pvpDefense.attack.pLv||1);
update.oppPlayers = oppPlayers;
// 减少挑战次数
let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
refChallengeObj.challengeCnt--;
update = {...update, ...refChallengeObj};
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
let result = new PvpDataReturn(); // 返回对象
result.setPvpDefense(pvpDefense);
let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
result.setOppPlayers(oppPlayersReturn);
return resResult(STATUS.SUCCESS, {
battleCode
battleCode,
...pick(result, ['oppPlayers', 'challengeCnt', 'challengeRefTime'])
});
}
@@ -225,32 +248,20 @@ export class PvpHandler {
let { attackInfo, showHeroScores, updateParam } = myRecInfo
update = { ...update, ...updateParam };
let curOpp = pvpDefense.oppPlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
let curOpp = pvpDefense.oppBeforePlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
const defenseInfo = await generPVPOppRecInfo(isSuccess, curOpp, oppHeroes, role.lv);
// 战报记录
await PvpRecordModel.createRec({ roleId1: roleId, roleId2: robotIdComBack(oppRoleId), warId: BattleRecord.battleId, attackInfo, defenseInfo, createTime: nowSeconds() });
// 对手记录更新
await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
// 刷新对手
let seasonNum: number = this.app.get('pvpSeasonNum');
let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score ,pvpDefense.attack.score, pvpDefense.attack.pLv||1);
update.oppPlayers = oppPlayers;
// 更新battleRecord
await BattleRecordModel.updateBattleRecordByCode(battleCode, {
$set: { status: isSuccess ? 1 : 2 }
}, true);
// 减少挑战次数
let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
refChallengeObj.challengeCnt--;
update = {...update, ...refChallengeObj};
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
@@ -354,14 +365,14 @@ export class PvpHandler {
let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
// 更新挑战阵容
let score = 0;
let scores: number[] = [];
for(let { actorId } of heroes) {
let heroScore = pvpDefense.heroScores.find(cur => cur.hid == actorId);
if(heroScore) {
score += heroScore.score;
scores.push(heroScore.score);
}
}
let attack = new Attack(heroes, score);
let attack = new Attack(heroes, scores);
let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, attack.heroes, []);
// 刷对手
let role = <RoleType>pvpDefense.role;
@@ -391,11 +402,11 @@ export class PvpHandler {
let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
// 更新防守阵容
let score = 0, heroIdMap = new Map<number, string>(), hids: number[] = [];
let scores: number[] = [], heroIdMap = new Map<number, string>(), hids: number[] = [];
for(let { actorId } of heroes) {
let heroScore = pvpDefense.heroScores.find(cur => cur.hid == actorId);
if(heroScore) {
score += heroScore.score;
scores.push(heroScore.score);
}
// 记录hero的objectId，用于存defense.heroes.hero
if(pvpDefense.defense && pvpDefense.defense.heroes) {
@@ -417,7 +428,7 @@ export class PvpHandler {
let defenseHeroes = heroes.map(cur => {
return new DefenseHero(cur, heroIdMap.get(cur.actorId));
});
let defense = new Defense(defenseHeroes, score, warId, buff);
let defense = new Defense(defenseHeroes, scores, warId, buff);
let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, defense.heroes, dbHeroes);
pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { ...refChallengeObj, defense, lineupCe });

24
game-server/app/services/gmService.ts
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);

120
game-server/app/services/pvpService.ts
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}
}

1
shared/consts/constModules/sysConst.ts
View File

@@ -1007,6 +1007,7 @@ export enum ITEM_CHANGE_REASON {
export enum TA_EVENT {
REGISTER = 'register', // 注册
CREATE_ROLE = 'create_role', // 创建角色
RECHARGE = 'recharge', // 发起充值
RECHARGE_SUCCESS = 'recharge_success', // 充值成功
RECHARGE_FAIL = 'recharge_fail', // 充值失败

5
shared/db/PvpDefense.ts
View File

@@ -22,6 +22,8 @@ export default class PvpDefense extends BaseModel {
lineupCe: LineupCe[];
@prop({ required: true, type: () => OppPlayer, default: [], _id: false })
oppPlayers: OppPlayer[];
@prop({ required: true, type: () => OppPlayer, default: [], _id: false })
oppBeforePlayers: OppPlayer[];
@prop({ required: true, type: () => HeroScore, default: [], _id: false })
heroScores: HeroScore[];
@@ -112,7 +114,8 @@ export default class PvpDefense extends BaseModel {
const result: PvpDefenseType = await PvpDefenseModel.findOne({ roleId })
.populate('role', 'head frame spine topLineupCe roleId roleName lv globalCeAttr')
.populate('heroes.hero')
.populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv title lv pLv defCe heroes warId buff').lean({ getters: true, virtuals: true });
.populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv title lv pLv defCe heroes warId buff')
.populate('oppBeforePlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv title lv pLv defCe heroes warId buff').lean({ getters: true, virtuals: true });
return result;
}

2
shared/db/PvpHistoryOpp.ts
View File

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

14
shared/domain/battleField/pvp.ts
View File

@@ -4,7 +4,7 @@ import Hero from '../../db/Hero';
import { PvpDefenseType } from '../../db/PvpDefense';
import PvpHistoryOpp from '../../db/PvpHistoryOpp';
import { PvpSeasonResultType } from '../../db/PvpSeasonResult';
import { getPLvByScore } from '../../pubUtils/data';
import { getPlvAndScore } from '../../pubUtils/data';
import { RewardInter } from '../../pubUtils/interface';
@@ -43,10 +43,12 @@ export class Defense {
@prop({ required: true })
pLv: number; // 防守阵容的等级
constructor(heroes: DefenseHero[], score: number, warId: number, buff: number) {
constructor(heroes: DefenseHero[], scores: number[], warId: number, buff: number) {
this.heroes = heroes;
this.score = scores.reduce((pre, cur) => pre + cur, 0);
let {pLv, score} = getPlvAndScore(scores);
this.pLv = pLv,
this.score = score;
this.pLv = getPLvByScore(score);
this.warId = warId;
this.buff = buff;
}
@@ -69,10 +71,12 @@ export class Attack {
@prop({ required: true })
pLv: number; // 防守阵容的等级
constructor(heroes: AttackHero[], score: number) {
constructor(heroes: AttackHero[], scores: number[]) {
this.heroes = heroes;
this.score = scores.reduce((pre, cur) => pre + cur, 0);
let {pLv, score} = getPlvAndScore(scores);
this.pLv = pLv;
this.score = score;
this.pLv = getPLvByScore(score);
}
}

7
shared/pubUtils/data.ts
View File

@@ -427,6 +427,13 @@ export function getPLvByScore(score: number) {
return lv;
}
export function getPlvAndScore(scores: number[] = []) {
if(scores.length <= 0) scores = [0];
let maxScore = Math.max(...scores); // 等级：军功最高者的军功*6
let score = scores.reduce((pre, cur) => pre + cur, 0);
return { score, pLv: getPLvByScore(maxScore * 6)};
}
export function getPvpHeroRewardsByScore(score: number) {
for (let item of gameData.pvpHeroRewards) {
if ((item.max >= score || item.max == -1) && score >= item.min) {

4
web-server/app/controller/account.ts
View File

@@ -46,8 +46,8 @@ export default class AccountController extends Controller {
public async createRole() {
const { ctx } = this;
const { serverId } = ctx.request.body;
ctx.body = await ctx.service.auth.createRole(serverId);
const { serverId, distinctId } = ctx.request.body;
ctx.body = await ctx.service.auth.createRole(serverId, distinctId);
}
public async bind() {

7
web-server/app/service/Auth.ts
View File

@@ -302,7 +302,7 @@ export default class Auth extends Service {
return ctx.service.utils.resResult(STATUS.ROLE_NOT_FOUND);
}
public async createRole(serverId: number) {
public async createRole(serverId: number, distinctId: string) {
console.log('enter Auth createRole');
const ctx = this.ctx;
const { uid } = ctx;
@@ -324,6 +324,7 @@ export default class Auth extends Service {
// 任务
await checkTask(roleId, TASK_TYPE.ROLE_LV, role.lv, false, {});
ctx.service.sdk.reportTAEventWithRoleIdAndDistinctId(roleId, distinctId, TA_EVENT.CREATE_ROLE, null, ctx.clientIp);
return ctx.service.utils.resResult(STATUS.SUCCESS, { roleId: role.roleId });
}
return ctx.service.utils.resResult(STATUS.ROLE_NOT_FOUND);
@@ -401,7 +402,7 @@ export default class Auth extends Service {
public async channelLogin(params: {
channelType: string, pst: string, clientId: string, deviceId: string, platform: string, platformAppid: string, childGameId: number, pkgName: string, serverType: string, getuiCID: string, distinctId: string
}) {
const { channelType, pst, clientId, deviceId, platform, platformAppid, childGameId, pkgName, serverType, getuiCID, distinctId } = params;
const { channelType, pst, clientId, deviceId, platform, platformAppid, childGameId, pkgName, serverType, getuiCID } = params;
const ctx = this.ctx;
@@ -418,7 +419,7 @@ export default class Auth extends Service {
...requestResult.data, childGameId, platformAppid
}, token, platform, pkgName, serverType, deviceId, ctx.clientIp);
if(isCreate) {
ctx.service.sdk.reportTAEventWithDistinctId(distinctId, TA_EVENT.REGISTER, null, ctx.clientIp);
// ctx.service.sdk.reportTAEventWithDistinctId(distinctId, TA_EVENT.REGISTER, null, ctx.clientIp);
}
if (getuiCID) {//更新个推cid

23
web-server/app/service/Sdk.ts
View File

@@ -277,4 +277,27 @@ export default class Sdk extends Service {
ta.track(event);
}
public reportTAEventWithRoleIdAndDistinctId(roleId: string, distinctId: string, eventName: string, properties: any, ip?: string) {
let ta = this.app.context.ta;
let event = {
// 账号 ID （可选)
accountId: `${roleId}`,
// 访客 ID （可选)，账号 ID 和访客 ID 不可以都为空
distinctId: distinctId? `${distinctId}`: "",
// 事件名称 （必填)
event: eventName,
// 事件时间 (可选) 如果不填，将以调用接口时的时间作为事件时间
time: new Date(),
// 事件 IP (可选) 当传入 IP 地址时，后台可以解析所在地
ip: ip,
// 事件属性 (可选)
properties,
callback(err) {
console.log('*****测试接入事件', err)
}
};
ta.track(event);
}
}