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

✨ feat(gvg): 遗迹生成数据

Browse Source
This commit is contained in:
luying
2023-01-31 11:04:44 +08:00
parent 3c8ac3c9e5
commit 4035645772
12 changed files with 2174 additions and 1270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
game-server/app/servers/guild/handler/gvgFighterHandler.ts
View File

@@ -1,4 +1,14 @@
import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
import { GVG_PERIOD, STATUS } from "../../../consts";
import { GVGVestigeRankModel } from "../../../db/GVGVestigeRank";
import { HeroModel } from "../../../db/Hero";
import { RoleModel } from "../../../db/Role";
import { GVGVestigeOppLineup } from "../../../domain/gvgField/returnData";
import { gameData } from "../../../pubUtils/data";
import { resResult } from "../../../pubUtils/util";
import { checkVestige, getOppPlayerByRanks, refreshVestigeOppRanks } from "../../../services/gvg/gvgFightService";
import { getGroupIdOfServer, getGVGPeriodData } from "../../../services/gvg/gvgService";
import { getAllServerName } from "../../../services/redisService";
export default function (app: Application) {
new HandlerService(app, {});
@@ -18,7 +28,40 @@ export class GVGProduceHandler {
// 遗迹页面
async getVestige(msg: { vestigeId: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const { vestigeId } = msg;
let { configId, period } = getGVGPeriodData();
if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
let groupId = await getGroupIdOfServer(serverId);
if(!await checkVestige(groupId, vestigeId)) {
return resResult(STATUS.GVG_VESTIGE_ERR);
}
let dicRankMap = gameData.gvgVestige.get(vestigeId);
if(!dicRankMap) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let myVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
if(!myVestigateRank) {
let role = await RoleModel.findByRoleId(roleId, 'roleId');
let oppRanks = refreshVestigeOppRanks(-1);
myVestigateRank = await GVGVestigeRankModel.initRank(configId, vestigeId, groupId, role, oppRanks );
}
let { rank, lineup, oppRanks, refreshCnt } = myVestigateRank;
let score = dicRankMap?.get(rank)||0;
let lineupCe = lineup.reduce((pre, cur) => pre + cur.ce, 0);
let oppPlayers = await getOppPlayerByRanks(serverId, groupId, vestigeId, oppRanks);
return resResult(STATUS.SUCCESS, {
vestigeId,
myRank: rank,
score,
lineup, lineupCe,
oppPlayers,
refreshCnt
})
}
// 编辑阵容
@@ -28,7 +71,36 @@ export class GVGProduceHandler {
// 获取对手阵容消息
async getOppLineup(msg: { vestigeId: number, roleId: string, rank: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
let { vestigeId, roleId: targetRoleId, rank } = msg;
let myVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
const serverNames = await getAllServerName();
let isRobot = targetRoleId.startsWith('robot');
let result = new GVGVestigeOppLineup(vestigeId);
result.setMyRank(myVestigateRank?.rank||0);
let dicGVGVestige = gameData.gvgVestige.get(vestigeId)?.get(rank);
if(!dicGVGVestige) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(isRobot) {
let dicWar = gameData.war.get(dicGVGVestige?.warId);
let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
result.setRobot(dicGVGVestige, dicWarJson, serverNames[serverId]);
} else {
let hisVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
if(!hisVestigateRank) return resResult(STATUS.GVG_VESTIGE_TARGET_NOT_FOUND);
let role = await RoleModel.findByRoleId(hisVestigateRank.roleId, 'roleId roleName serverId guildName title lv heads head spines spine frames frame')
if(!hisVestigateRank) return resResult(STATUS.GVG_VESTIGE_TARGET_NOT_FOUND);
let hids = hisVestigateRank.lineup?.map(cur => cur.actorId)||[];
let heroes = await HeroModel.findByHidRange(hids, roleId, 'hid skinId quality star colorStar lv');
result.setPlayer(dicGVGVestige, role, heroes, serverNames);
}
return resResult(STATUS.SUCCESS, result);
}
// 刷新对手

60
game-server/app/services/gvg/gvgFightService.ts
View File

@@ -2,9 +2,16 @@
import { GVG_PERIOD } from "../../consts";
import { GVGVestigeModel } from "../../db/GVGVestige";
import { gameData } from "../../pubUtils/data";
import { GVGVestigeRankModel } from "../../db/GVGVestigeRank";
import { HeroModel } from "../../db/Hero";
import { RoleType } from "../../db/Role";
import { GVGVestigeOppPlayer } from "../../domain/gvgField/returnData";
import { gameData, getGVGVestigeRange } from "../../pubUtils/data";
import { getTimeFun } from "../../pubUtils/timeUtil";
import { getRandEelm } from "../../pubUtils/util";
import { getRandEelm, getRandValueByMinMax } from "../../pubUtils/util";
import { getNumberArr, uniqueArr } from "../ladderService";
import { calLineupScore } from "../pvpService";
import { getAllServerName } from "../redisService";
import { getGroupIdOfServer, getGVGServerType } from "./gvgService";
// 备战期的遗迹和激战期的开始结束战斗时间
@@ -31,3 +38,52 @@ export async function getVestiges(serverId: number) {
}
return vestige.vestiges||[];
}
export async function checkVestige(groupId: number, vestigeId: number) {
let todayVestige = await GVGVestigeModel.getVestigate(groupId);
if(!todayVestige) return false;
return !!todayVestige.vestiges.find(cur => cur.vestigeId == vestigeId);
}
// 根据自己排名随机出对手排名
export function refreshVestigeOppRanks(rank: number) {
let dicRange = getGVGVestigeRange(rank);
if(!dicRange) return [];
let { rangeBeforeFrom, rangeBeforeTo, rangeBeforeNum, rangeAfterFrom, rangeAfterTo, rangeAfterNum } = dicRange;
let beforeRanks = randomRank(rangeBeforeFrom == -1? rank: rangeBeforeFrom, rangeBeforeTo == -1? rank: rangeBeforeTo, rangeBeforeNum);
let afterRanks = randomRank(rangeAfterFrom == -1? rank: rangeAfterFrom, rangeAfterTo == -1? rank: rangeAfterTo, rangeAfterNum);
let topRanks = getNumberArr(dicRange.topChallengeFrom + 1, dicRange.topChallengeTo);
let ranks = [...topRanks, ...beforeRanks, ...afterRanks];
return uniqueArr(ranks.sort((a, b) => a - b));
}
function randomRank(min: number, max: number, len: number) {
if(min == max || len == 0) return [];
let arr = getNumberArr(min + 1, max);
return getRandEelm(arr, len);
}
export async function getOppPlayerByRanks(serverId: number, groupId: number, vestigeId: number, ranks: number[]) {
let serverNames = await getAllServerName();
let opps = await GVGVestigeRankModel.findByRanks(groupId, vestigeId, ranks);
let dicRankMap = gameData.gvgVestige.get(vestigeId);
if(!dicRankMap) return [];
let result: GVGVestigeOppPlayer[] = [];
for(let rank of ranks) {
let obj = new GVGVestigeOppPlayer(rank);
let opp = opps.find(cur => cur.rank == rank);
let dicCurRank = dicRankMap.get(rank);
if(opp) {
let role = <RoleType>opp.role;
let lineupce = opp.lineup.reduce((pre, cur) => pre + cur.ce, 0);
obj.setByRole(role, serverNames, lineupce, dicCurRank?.score||0);
} else {
obj.setByDic(dicCurRank, serverNames[serverId]);
}
result.push(obj);
}
return result;
}

2
game-server/app/services/playerCeService.ts
View File

@@ -21,6 +21,7 @@ import { SkinType } from '../db/Skin';
import { LadderMatchModel } from '../db/LadderMatch';
import { ArtifactModelType } from '../db/Artifact';
import { GVGLeagueModel } from '../db/GVGLeague';
import { GVGVestigeRankModel } from '../db/GVGVestigeRank';
interface Param {
isInitRole?: boolean,
@@ -442,6 +443,7 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
let hero = await HeroModel.updateHeroInfo(roleId, hid, { ce });
await PvpDefenseModel.updateCe(roleId, hid, ce); // 更新pvp防守阵战力
await LadderMatchModel.updateCe(roleId, hid, ce);
await GVGVestigeRankModel.updateCe(roleId, hid, ce);
pushHeros.push({ hid, ce: hero.ce, incHeroCe: inc });
}
}

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

@@ -577,6 +577,7 @@ export const FILENAME = {
DIC_GVG_TASK: 'dic_zyz_GVGTask',
DIC_GVG_VESTIGE_TYPE: 'dic_zyz_GVGVestigeType',
DIC_GVG_VESTIGE: 'dic_zyz_GVGVestige',
DIC_GVG_VESTIGE_RANGE: 'dic_zyz_GVGVestigeRange',
DIC_GVG_VESTIGE_LEAGUE_RANK: 'dic_zyz_GVGVestigeLeagueRank',
}

2
shared/consts/statusCode.ts
View File

@@ -336,6 +336,8 @@ export const STATUS = {
GVG_TASK_HAS_RECEIVED: { code: 21330, simStr: '任务已领取过' },
GVG_BATTLE_CITY_FULL: { code: 21331, simStr: '城市已满员' },
GVG_BATTLE_TEAM_INVALID: { code: 21332, simStr: '无效的队伍' },
GVG_VESTIGE_ERR: { code: 21333, simStr: '今日未开放该遗迹' },
GVG_VESTIGE_TARGET_NOT_FOUND: { code: 21334, simStr: '对手未找到' },
// 通用 30000 - 30099
DIC_DATA_NOT_FOUND: { code: 30000, simStr: '数据表未找到' },

64
shared/db/GVGVestigeRank.ts
View File

@@ -1,9 +1,22 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
import Role from './Role';
import Role, { RoleType } from './Role';
import { getZeroPoint } from '../pubUtils/timeUtil';
@index({ groupId: 1, vestigeId: 1 })
export default class GVGVestige extends BaseModel {
class Lineup {
@prop({ required: true })
actorId: number; // 武将
@prop({ required: true })
dataId: number; // 出兵表上所占位置
@prop({ required: true })
order: number; // 行动顺序
@prop({ required: true })
ce: number; // 战力
}
@index({ day: 1, groupId: 1, vestigeId: 1, rank: 1 })
@index({ roleId: 1 })
export default class GVGVestigeRank extends BaseModel {
@prop({ required: true })
configId: number; // 赛期
@@ -34,11 +47,50 @@ export default class GVGVestige extends BaseModel {
@prop({ required: true, default: 0 })
locked: number; // 是否被挑战
@prop({ required: true, default: false })
hasAdjustLineup: boolean; // 是否调整过阵容
@prop({ required: true, type: Lineup, default: [] })
lineup: Lineup[]; // 阵容
@prop({ required: true, type: Number, default: [] })
oppRanks: number[]; // 对手的排名
@prop({ required: true, default: 0 })
refreshCnt: number; // 刷新次数
public static async findRankByRole(vestigeId: number, roleId: string) {
let today = getZeroPoint();
let result: GVGVestigeRankType = await GVGVestigeRankModel.findOne({ day: today, vestigeId, roleId }).lean();
return result;
}
public static async initRank(configId: number, vestigeId: number, groupId: number, role: RoleType, oppRanks: number[]) {
let today = getZeroPoint();
let doc = new GVGVestigeRankModel();
let update = Object.assign(doc.toJSON(), { role: role._id, configId, groupId, oppRanks });
let result: GVGVestigeRankType = await GVGVestigeRankModel.findOneAndUpdate({ day: today, vestigeId, roleId: role.roleId }, { $setOnInsert: update }, { new: true, upsert: true }).lean();
return result;
}
public static async findByRanks(groupId: number, vestigeId: number, ranks: number[]) {
let today = getZeroPoint();
let result: GVGVestigeRankType[] = await GVGVestigeRankModel.find({ day: today, vestigeId, groupId, rank: { $in: ranks } })
.populate('role', 'roleId roleName head frame spine heads frames spines title lv guildName serverId updatedAt')
.lean();
return result;
}
public static async updateCe(roleId: string, hid: number, ce: number) {
let today = getZeroPoint();
await GVGVestigeRankModel.updateMany({ day: today, roleId, 'lineup.hid': hid }, { $set: { 'lineupCe.$.ce': ce } });
}
}
export const GVGVestigeModel = getModelForClass(GVGVestige);
export const GVGVestigeRankModel = getModelForClass(GVGVestigeRank);
export interface GVGVestigeType extends Pick<DocumentType<GVGVestige>, keyof GVGVestige> {
export interface GVGVestigeRankType extends Pick<DocumentType<GVGVestigeRank>, keyof GVGVestigeRank> {
id: number;
};
export type GVGVestigeUpdate = Partial<GVGVestigeType>; // 将所有字段变成可选项
export type GVGVestigeRankUpdate = Partial<GVGVestigeRankType>; // 将所有字段变成可选项

166
shared/domain/gvgField/returnData.ts
View File

@@ -1,11 +1,15 @@
import { RoleType } from "../../db/Role";
import { GVGLeagueType } from "../../db/GVGLeague";
import { GVGLeaguePrepareType } from "../../db/GVGLeaguePrepare";
import { Distribute, GVGUserDataType } from "../../db/GVGUserData";
import { GVGUserDataType } from "../../db/GVGUserData";
import { GuildType } from "../../db/Guild";
import { LEAGUE_JOB } from "../../consts";
import { GVGLeagueFarmType } from "../../db/GVGLeagueFarm";
import { nowSeconds } from "../../pubUtils/timeUtil";
import { DicGVGVestige } from "../../pubUtils/dictionary/DicGVGVestige";
import { EXTERIOR, GVG } from "../../pubUtils/dicParam";
import { DicWarJson } from "../../pubUtils/dictionary/DicWarJson";
import { gameData } from "../../pubUtils/data";
import { HeroType } from "../../db/Hero";
class LeagueLeaderInfo {
name: string; // 盟主名
@@ -353,3 +357,161 @@ export interface LeagueGood {
id: number,
count: number
}
export class GVGVestigeOppPlayer {
rank: number;
roleId: string;
roleName: string;
lv: number;
head: number;
frame: number;
spine: number;
title: number;
guildName: string;
serverName: string;
lineupCe: number;
score: number;
constructor(rank: number) {
this.rank = rank;
}
setByRole(role: RoleType, serverNames: any, lineupCe: number, score: number) {
this.roleId = role.roleId;
this.roleName = role.roleName;
this.lv = role.lv;
this.head = role.head;
this.frame = role.frame;
this.spine = role.spine;
this.title = role.title;
this.guildName = role.guildName;
this.serverName = serverNames[role.serverId];
this.lineupCe = lineupCe;
this.score = score;
}
setByDic(dic: DicGVGVestige, serverName: string) {
this.lineupCe = dic.ce;
this.roleId = `robot${this.rank}`;
this.roleName = GVG.GVG_ROBOT_NAME;
this.lv = dic.level;
this.head = dic.head;
this.frame = EXTERIOR.EXTERIOR_FACECASE;
this.spine = dic.spine;
this.title = 1;
this.guildName = '';
this.serverName = serverName;
this.lineupCe = dic.ce;
this.score = dic.score;
}
}
// getOppLineup返回
export class GVGVestigeOppLineupHero {
hid: number; // 武将
skinId: number; // 皮肤id
quality: number; // 品质
star: number; // 星级
colorStar: number; // 彩星
lv: number; // 等级
setByWarJson(warJson: DicWarJson) {
this.hid = warJson.actorId;
this.skinId = warJson.actorId;
this.lv = warJson.lv;
let dicHero = gameData.hero.get(warJson.actorId);
if(dicHero) {
this.quality = dicHero.quality;
if(this.quality == 4) {
this.star = 6;
this.colorStar = warJson.star;
} else {
this.star = warJson.star;
this.colorStar = 0;
}
}
}
setByDefenseHero(hero: HeroType) {
this.hid = hero.hid;
this.skinId = hero.skinId;
this.quality = hero.quality;
this.star = hero.star;
this.colorStar = hero.colorStar;
this.lv = hero.lv;
}
}
export class GVGVestigeOppLineup {
vestigeId: number; // 遗迹id
myRank: number;
rank: number;
score: number;
isRobot: boolean;
roleId: string;
roleName: string;
serverName: string;
guildName: string;
lv: number;
head: number;
frame: number;
spine: number;
title: number;
lineupCe: number = 0; // 阵容战力
heroes: GVGVestigeOppLineupHero[] = [];
constructor(vestigeId: number) {
this.vestigeId = vestigeId;
}
setMyRank(myRank: number) {
this.myRank = myRank;
}
setRobot(dic: DicGVGVestige, warJsons: DicWarJson[], serverName: string) {
this.isRobot = true;
this.rank = dic.rank;
this.score = dic.score;
this.roleId = `robot${dic.rank}`;
this.roleName = GVG.GVG_ROBOT_NAME;
this.serverName = serverName;
this.guildName = '';
this.lineupCe = dic.ce;
this.lv = dic.level;
this.head = dic.head;
this.frame = EXTERIOR.EXTERIOR_FACECASE;
this.spine = dic.spine;
this.title = 1;
for(let warJson of warJsons) {
if(warJson.relation == 2) {
let hero = new GVGVestigeOppLineupHero();
hero.setByWarJson(warJson);
this.heroes.push(hero);
}
}
}
setPlayer(dic: DicGVGVestige, role: RoleType, heroes: HeroType[], serverNames: any) {
this.isRobot = false;
this.rank = dic.rank;
this.score = dic.score;
this.roleId = role.roleId;
this.roleName = role.roleName;
this.serverName = serverNames[role.serverId];
this.guildName = role.guildName;
this.title = role.title;
this.lv = role.lv;
this.head = role.head;
this.frame = role.frame;
this.spine = role.spine;
for(let hero of heroes) {
this.lineupCe += hero.ce;
let obj = new GVGVestigeOppLineupHero();
obj.setByDefenseHero(hero);
this.heroes.push(obj);
}
}
}

15
shared/pubUtils/data.ts
View File

@@ -129,6 +129,7 @@ import { dicGVGCityAdd, loadGVGCityAdd } from './dictionary/DicGVGCityAdd';
import { dicGVGTask, dicGVGTaskByType, loadGVGTask } from './dictionary/DicGVGTask';
import { dicGVGVestigeByType, loadGVGVestigeType } from './dictionary/DicGVGVestigeType';
import { dicGVGVestige, loadGVGVestige } from './dictionary/DicGVGVestige';
import { DicGVGVestigeRange, dicGVGVestigeRange, loadGVGVestigeRange } from './dictionary/DicGVGVestigeRange';
export const gameData = {
daily: dicDaily,
@@ -325,6 +326,7 @@ export const gameData = {
gvgVestigeByServerType: dicGVGVestigeByType,
gvgVestigeCntByServerType: new Map<number, number>(), // 单服or跨服 => 遗迹数量
gvgVestige: dicGVGVestige,
gvgVestigeRange: dicGVGVestigeRange,
};
// 在此提供一些原先在gamedata中提供的方法，以便更方便获取gameData数据
@@ -1169,6 +1171,18 @@ function parseGVGVestigeCnt() {
}
}
export function getGVGVestigeRange(myRank: number) {
let latestRank: DicGVGVestigeRange;
for(let dic of gameData.gvgVestigeRange) {
latestRank = dic;
let { rankMin, rankMax } = dic;
if((rankMin < myRank && (rankMax >= myRank || rankMax == -1))) {
return dic;
}
}
return latestRank
}
// 初始加载
function initDatas() {
parseDicParam();
@@ -1379,6 +1393,7 @@ function loadDatas() {
loadGVGTask();
loadGVGVestigeType();
loadGVGVestige();
loadGVGVestigeRange();
}
// 重载dicParam

6
shared/pubUtils/dicParam.ts
View File

@@ -391,6 +391,8 @@ export const GVG = {
GVG_FARM_LOCK_TIME: 300, // 农田锁定时间（秒）
GVG_MINE_LOCK_TIME: 300, // 矿山锁定时间（秒）
GVG_FORESTRY_LOCK_TIME: 300, // 林场锁定时间（秒）
GVG_FIELD_TYPE_RATIO: '1&5|2&10|3&10', // 全联盟的特殊格子上限百分比（a%的格子为小麦这个）1&a|2&b|3&c
GVG_SP_FIELD_RATIO: '10&30', // 分配给玩家的时候有多少特殊格子 min&max 填最大最小百分比即可
GVG_FIELD_TYPE_RATIO: '1&5%|2&10%|3&10%', // 全联盟的特殊格子上限百分比（a%的格子为小麦这个）1&a|2&b|3&c
GVG_SP_FIELD_RATIO: '10%&30%', // 分配给玩家的时候有多少特殊格子 min&max 填最大最小百分比即可
GVG_REFRESH_TIME: 5, // 0
GVG_ROBOT_NAME: '遗迹守护者', // 0
};

9
shared/pubUtils/dictionary/DicGVGVestige.ts
View File

@@ -12,12 +12,12 @@ export interface DicGVGVestige {
readonly rank: number;
// 驻扎分
readonly score: number;
// 机器人的名字
readonly name: string;
// 显示在上面的形象
readonly spine: number;
// 显示在详情的头像
readonly head: number;
// 显示在上面的形象
readonly spine: number;
// 显示的机器人的等级
readonly level: number;
// 显示战力
readonly ce: number;
// 突破奖励
@@ -42,6 +42,7 @@ export function loadGVGVestige() {
o.onceLeagueReward = parseGoodStr(o.onceLeagueReward);
o.battleReward = parseGoodStr(o.battleReward);
o.battleLeagueReward = parseGoodStr(o.battleLeagueReward);
o.warId = parseInt(o.warId);
if(!dicGVGVestige.has(o.vestigeId)) {
dicGVGVestige.set(o.vestigeId, new Map());
}

39
shared/pubUtils/dictionary/DicGVGVestigeRange.ts Normal file
View File

@@ -0,0 +1,39 @@
// GVG遗迹
import { FILENAME } from '../../consts'
import { readFileAndParse } from '../util'
export interface DicGVGVestigeRange {
// id
id: number;
// 最低排名(不含)
rankMin: number;
// 最高排名(含)
rankMax: number;
// 往前随机的排名最高是多少名
rangeBeforeFrom: number;
// 往前随机的排名最低是多少名
rangeBeforeTo: number;
// 往前随机的排名里随机多少个
rangeBeforeNum: number;
// 往后随机的排名最高是多少名
rangeAfterFrom: number;
// 往后随机的排名最低是多少名
rangeAfterTo: number;
// 往后随机的排名最低是多少名
rangeAfterNum: number;
// 是否显示前十名/前五名
topChallengeFrom: number;
// 是否显示前十名/前五名
topChallengeTo: number;
}
export const dicGVGVestigeRange: DicGVGVestigeRange[] = [];
export function loadGVGVestigeRange() {
dicGVGVestigeRange.splice(0, dicGVGVestigeRange.length);
let arr = readFileAndParse(FILENAME.DIC_GVG_VESTIGE_RANGE);
arr.forEach(o => {
dicGVGVestigeRange.push(o);
});
arr = undefined;
}

3000
shared/resource/jsons/dic_zyz_GVGVestige.json
View File

File diff suppressed because it is too large Load Diff