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-05 19:18:56 +08:00
parent 94c69089ac
commit 03fa74f3d1
50 changed files with 10354 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
game-server/app.ts
View File

@@ -33,6 +33,7 @@ import { loadGmDb } from './app/db';
import { loadActivities } from './app/services/activity/activityRemoteService';
import { checkAndSetApiIsClose } from './app/services/chatService';
import { initGuildActivityIndexInPinus, resetJoinWoodenHorse } from './app/services/guildActivity/guildActivityService';
import { setGVGServerGroup } from './app/services/gvg/gvgService';
const filePath = (_pinus as any).FILEPATH;
filePath.MASTER = '/config/master';
@@ -192,6 +193,7 @@ async function treatStartLogic(app: _pinus.Application) {
if(app.getServerType() == 'guild') {
initGuildActivityIndexInPinus()
.then(resetJoinWoodenHorse);
setGVGServerGroup();
}
if(app.getServerType() == 'battle'|| app.getServerType() == 'role'|| app.getServerType() == 'connector') {
timeTaskService.setPvpSeasonNum();

2
game-server/app/servers/connector/handler/entryHandler.ts
View File

@@ -142,6 +142,8 @@ export class EntryHandler {
session.push('vipStartTime', () => { });
session.push('channel', () => { });
assignServer(role.roleId, session);
console.log('#####', role.serverId, role.guildCode)
// console.log(role.guildCode)
// session.push('rid', function (err) {
// if (err) {

34
game-server/app/servers/gm/handler/gmHandler.ts
View File

@@ -1,5 +1,5 @@
import { Application, BackendSession, pinus } from 'pinus';
import { getRandSingleEelm, resResult } from '../../../pubUtils/util';
import { getRandSingleEelm, isTimestamp, resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { GMMailModel, GMMailType } from '../../../db/GMMail';
import { ACTIVITY_TYPE, GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE, MEMORY_LOG_TYPE, PUSH_ROUTE, SURVEY_SELECT } from '../../../consts';
@@ -17,6 +17,12 @@ import { getSurvey } from '../../../services/gmService';
import { sendMessageToAllWithSuc } from '../../../services/pushService';
import { sendMailByContent, sendMailsByGmMail } from '../../../services/mailService';
import { saveMemory } from '../../../services/log/memoryLogService';
import { getGVGConfigFromRemote } from '../../../services/gvg/gvgService';
import { GVGServerGroupModel } from '../../../db/GVGServerGroup';
import { isNumber } from 'underscore';
import { group } from 'console';
import { GVGConfigModel } from '../../../db/GVGConfig';
import { ServerlistModel } from '../../../db/Serverlist';
let timer: NodeJS.Timer;
export default function (app: Application) {
@@ -285,4 +291,30 @@ export class GmHandler {
await saveMemory(memoryLogType);
return resResult(STATUS.SUCCESS);
}
async updateGVGServerGroup(msg: { serverId: number[], groupId: number }, session: BackendSession) {
const { serverId: serverIds, groupId } = msg;
if(!isNumber(groupId)) return resResult(STATUS.WRONG_PARMS);
for(let serverId of serverIds) {
if(!isNumber(serverId)) return resResult(STATUS.WRONG_PARMS);
}
let { scheduleTime } = await getGVGConfigFromRemote();
for(let serverId of serverIds) {
await GVGServerGroupModel.updateByServerId(serverId, groupId, scheduleTime);
}
return resResult(STATUS.SUCCESS);
}
async updateGVGConfig(msg: { configId: number, teamTime: number, prepareTime: number, battleTime: number, scheduleTime: number }, session: BackendSession) {
const { configId, teamTime, prepareTime, battleTime, scheduleTime } = msg;
if(!isNumber(configId) || !isTimestamp(teamTime) || !isTimestamp(prepareTime) || !isTimestamp(battleTime) || !isTimestamp(scheduleTime)) {
return resResult(STATUS.WRONG_PARMS);
}
if(teamTime > prepareTime || prepareTime > battleTime || battleTime > scheduleTime) {
return resResult(STATUS.GM_GVG_TIME_ERR);
}
await GVGConfigModel.updateConfig(configId, teamTime, prepareTime, battleTime, scheduleTime);
await pinus.app.rpc.systimer.systimerRemote.initGVGConfigSchedule.broadcast();
return resResult(STATUS.SUCCESS);
}
}

16
game-server/app/servers/guild/handler/guildHandler.ts
View File

@@ -30,6 +30,8 @@ import { changeGuildActivity, guildDismisActivity, guildPayQuitGuild } from '../
import { sendMessageToUserWithSuc } from '../../../services/pushService';
import { GuildActiveModel } from '../../../db/GuildActive';
import { leaveRaceActivityToRemote, leaveRaceWhenDismissToRemote, leaveRaceWhenQuitGuildToRemote } from '../../../services/guildActivity/guildActivityService';
import { getGVGInfoInGuild } from '../../../services/gvg/gvgService';
import { guildAbdicateToLeague, guildDismissToLeague, memberQuitGuildToLeague } from '../../../services/gvg/gvgTeamService';
export default function (app: Application) {
@@ -174,7 +176,7 @@ export class GuildHandler {
const { code } = msg;
const select = ['code', 'name', 'notice', 'ceLimit', 'isAuto', 'icon', 'lv', 'memberCnt', 'guildCe'];
const guild = await GuildModel.findByCode(code, serverId, select.join(' '));
const guild = await GuildModel.findByCode(code, null, select.join(' '));
let leader = <RoleType>guild.leader;
delete guild.leader;
// 返回
@@ -199,7 +201,7 @@ export class GuildHandler {
}
// 管理员最大数 等策划表
let guild = await GuildModel.findByCode(code, serverId, 'managerCnt lv');
let guild = await GuildModel.findByCode(code, serverId, 'managerCnt lv leagueCode');
if (!guild) {
return resResult(STATUS.GUILD_NOT_FOUND);
}
@@ -235,6 +237,7 @@ export class GuildHandler {
await updateUserInfo(REDIS_KEY.GUILD_INFO, code, [{ field: 'leader', value: new GuildLeader(role) }]);
await RoleModel.updateRoleInfo(memberRoleId, { isGuildLeader: true });
await RoleModel.updateRoleInfo(roleId, { isGuildLeader: false });
await guildAbdicateToLeague(guild, roleId, role);
}
guild = await GuildModel.updateInfo(code, updateObject, { managerCnt: managerCntInc }, 'managerCnt code name'); // 如果有转让团长设置leader
@@ -274,13 +277,14 @@ export class GuildHandler {
return resResult(STATUS.SUCCESS, { hasGuild: false })
};
let guild = await GuildModel.findByCode(userGuild.guildCode, serverId);
let guild = await GuildModel.findByCode(userGuild.guildCode, serverId, '+serverId');
if (!guild) {
return resResult(STATUS.GUILD_NOT_FOUND);
}
let result = await getMyGuildInfo(roleId, sid, userGuild, guild, serverId, session);
return resResult(STATUS.SUCCESS, result);
let gvg = await getGVGInfoInGuild(guild);
return resResult(STATUS.SUCCESS, { ...result, gvg });
}
// 玩家申请公会
@@ -561,6 +565,7 @@ export class GuildHandler {
const { members } = guild;
await RoleModel.dissmissGuild(members);
await UserGuildApplyModel.deleteApplyByGuild(code);
await guildDismissToLeague(guild);
await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.broadcast(members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
@@ -602,6 +607,7 @@ export class GuildHandler {
if (!guild) return resResult(STATUS.GUILD_QUIT_ERROR);
await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }])
await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'guildName', value: '' }]);
await memberQuitGuildToLeague(guild, role);
//删除排名信息
await removeBossRank(code, roleId);
@@ -637,7 +643,7 @@ export class GuildHandler {
if (!guild) return resResult(STATUS.GUILD_KICK_ERROR);
await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }])
await updateUserInfo(REDIS_KEY.USER_INFO, memberRoleId, [{ field: 'guildName', value: '' }]);
await memberQuitGuildToLeague(guild, role);
//删除排名信息
await removeBossRank(code, memberRoleId);

61
game-server/app/servers/guild/handler/gvgHandler.ts Normal file
View File

@@ -0,0 +1,61 @@
import { Application, BackendSession, ChannelService, HandlerService, pinus } from "pinus";
import { GVG_PERIOD, GVG_SERVER_TYPE, STATUS } from "../../../consts";
import { GVGLeagueModel } from "../../../db/GVGLeague";
import { GVGLeaguePrepareModel } from "../../../db/GVGLeaguePrepare";
import { GVGMainData } from "../../../domain/gvgField/returnData";
import { resResult } from "../../../pubUtils/util";
import { getGVGConfig, getGVGPeriodData, getGVGServerType } from "../../../services/gvg/gvgService";
import { autoCreateLeague, checkCanChooseJob, checkCanPrepare, getMyAuth } from "../../../services/gvg/gvgTeamService";
import { getAllServerName } from "../../../services/redisService";
import { GVGUserDataModel } from "../../../db/GVGUserData";
import { GVGUserItemModel } from "../../../db/GVGUserItem";
import { GVGUserTaskModel } from "../../../db/GVGUserTask";
export default function (app: Application) {
new HandlerService(app, {});
return new GVGHandler(app);
}
export class GVGHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
// 测试
async getData(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
const guildCode = session.get('guildCode');
const serverId = session.get('serverId');
let { configId, period, countdownTime } = getGVGPeriodData();
let serverType = await getGVGServerType(serverId);
if(serverType == GVG_SERVER_TYPE.NO) return resResult(STATUS.GVG_NO_SERVER_TYPE);
let data = new GVGMainData(configId, period, countdownTime, serverType);
let serverNames = await getAllServerName();
let league = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!league) {
league = await autoCreateLeague(guildCode);
}
if(league) {
data.setLeague(league, serverNames);
let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, league.leagueCode);
data.setLeagueParpare(leaguePrepare);
let userData = await GVGUserDataModel.findByRole(configId, league.leagueCode, roleId);
let items = await GVGUserItemModel.findByRole(configId, league.leagueCode, roleId);
let tasks = await GVGUserTaskModel.findByRole(configId, league.leagueCode, roleId);
data.setPlayerInfo(userData, getMyAuth(league, roleId), await checkCanPrepare(roleId), checkCanChooseJob(userData?.job, leaguePrepare), items, tasks);
}
return resResult(STATUS.SUCCESS, data)
}
async test(msg: { }, session: BackendSession) {
const time = getGVGConfig();
return resResult(STATUS.SUCCESS, { time });
}
}

574
game-server/app/servers/guild/handler/gvgManageHandler.ts Normal file
View File

@@ -0,0 +1,574 @@
import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
import { GUILD_AUTH, GVG_APPLY_TYPE, GVG_PERIOD, GVG_SERVER_TYPE, LEAGUE_AUTH, LEAGUE_MANAGE_TYPE, PUSH_ROUTE, STATUS } from "../../../consts";
import { resResult } from "../../../pubUtils/util";
import { GuildModel, GuildType } from "../../../db/Guild";
import { UserGuildModel } from "../../../db/UserGuild";
import { GVGLeagueModel, GVGLeagueType } from "../../../db/GVGLeague";
import { GVGLeagueApplyModel } from "../../../db/GVGLeagueApply";
import { getGVGPeriodData, getGVGServerType, getServersOfSameGroup } from "../../../services/gvg/gvgService";
import { checkCanManage, checkGuildLeader, checkLeagueAuth, createLeague, getLeagueApplyData, getLeagueInviteData, getMyAuth, joinGuildToLeague } from "../../../services/gvg/gvgTeamService";
import { LeagueGuildInfo, LeagueListInfo, LeagueMemberListInfo, LeagueSimpleInfo } from "../../../domain/gvgField/returnData";
import { getAllServerName, getServerName } from "../../../services/redisService";
import { GVG } from "../../../pubUtils/dicParam";
import { RoleModel } from "../../../db/Role";
import { GVGUserDataModel } from "../../../db/GVGUserData";
import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from "../../../services/pushService";
import { GVGLeaguePrepareModel } from "../../../db/GVGLeaguePrepare";
export default function (app: Application) {
new HandlerService(app, {});
return new GVGManageHandler(app);
}
export class GVGManageHandler {
channelService: ChannelService;
constructor(private app: Application) {
this.channelService = app.get('channelService');
}
// 创建新联军
async createLeague(msg: { name: string, icon: number, notice: string }, session: BackendSession) {
const roleId = session.get('roleId');
const guildCode = session.get('guildCode');
const { name, icon, notice } = msg;
const checkNameResult = await GVGLeagueModel.checkName(name);
if (checkNameResult) return resResult(STATUS.LEAGUE_NAME_DUP);
let { period } = getGVGPeriodData();
if(period != GVG_PERIOD.TEAM) return resResult(STATUS.GVG_NOT_TEAM_PERIOD);
const guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
const checkGuildResult = await checkGuildLeader(guildCode, roleId, guild);
if(checkGuildResult.code != 0) return checkGuildResult;
const league = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(league) return resResult(STATUS.GVG_LEAGUE_HAS_EXIST);
const newLeague = await createLeague(guild, { name, icon, notice });
return resResult(STATUS.SUCCESS, {
leagueCode: newLeague.leagueCode,
hasLeague: true
} );
}
// 获取联军列表
async getLeagues(msg: { page: number, name: string }, session: BackendSession) {
const roleId = session.get('roleId');
const guildCode = session.get('guildCode');
const serverId = session.get('serverId');
const { page, name } = msg;
let serverType = await getGVGServerType(serverId);
if(serverType == GVG_SERVER_TYPE.NO) return resResult(STATUS.GVG_NO_SERVER_TYPE);
const serverNames = await getAllServerName();
let serverIds = await getServersOfSameGroup(serverType, serverId);
const leagues = await GVGLeagueModel.findByCondition(serverType, serverIds, page, name);
const applies = await GVGLeagueApplyModel.findApplyFromGuild(guildCode);
let result: LeagueListInfo[] = [];
for(let league of leagues) {
let data = new LeagueListInfo(league, serverNames);
let hasApply = !!applies.find(cur => cur.leagueCode == league.leagueCode);
data.setHasApply(hasApply);
result.push(data);
}
return resResult(STATUS.SUCCESS, {
leagues: result
} );
}
// 未加入成员查看联军信息
async getLeagueInfo(msg: { leagueCode: string }, session: BackendSession) {
const { leagueCode } = msg;
const guildCode = session.get('guildCode');
const serverNames = await getAllServerName();
const league = await GVGLeagueModel.findByCode(leagueCode);
let result = new LeagueSimpleInfo(league, serverNames)
let hasApply = await GVGLeagueApplyModel.checkApply(leagueCode, guildCode, GVG_APPLY_TYPE.APPLY);
result.setHasApply(hasApply);
// TODO 占领城池
return resResult(STATUS.SUCCESS, {
league: result
} );
}
// 申请加入联军
async applyLeague(msg: { leagueCodes: string[] }, session: BackendSession) {
const roleId = session.get('roleId');
const guildCode = session.get('guildCode');
const serverId = session.get('serverId');
const { leagueCodes } = msg;
// 检查时间
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
const guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
const checkGuildResult = await checkGuildLeader(guildCode, roleId, guild);
if(checkGuildResult.code != 0) return checkGuildResult;
const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(myLeague) return resResult(STATUS.GVG_LEAGUE_HAS_EXIST);
const serverNames = await getAllServerName();
const leagues = await GVGLeagueModel.findByCodes(leagueCodes);
let result: LeagueListInfo[] = [];
for(let league of leagues) {
if(league.guildCnt > GVG.GVG_LEAGUE_COMPOSE) continue;
await GVGLeagueApplyModel.createApply(league, guild, GVG_APPLY_TYPE.APPLY);
let data = new LeagueListInfo(league, serverNames);
data.setHasApply(true);
result.push(data);
}
// 返回
return resResult(STATUS.SUCCESS, { leagues: result });
}
// 获取申请列表
async getApplies(msg: {}, session: BackendSession) {
const guildCode = session.get('guildCode');
const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
const serverNames = await getAllServerName();
const applies = await GVGLeagueApplyModel.findApplyFromLeague(myLeague.leagueCode);
const invitations = await GVGLeagueApplyModel.findInviteFromLeague(myLeague.leagueCode);
let result = applies.map(apply => getLeagueApplyData(apply, serverNames, invitations));
// 返回
return resResult(STATUS.SUCCESS, { guilds: result });
}
// 处理申请
async handleApply(msg: { guildCode: string, isReceive: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { guildCode: targetGuildCode, isReceive } = msg;
// 检查时间
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
// 权限
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.HANDLE_APPLY);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
if(isReceive) {
let result = await joinGuildToLeague(myLeague, targetGuildCode);
if(result.code == 0) {
myLeague = <GVGLeagueType>result.data;
await GVGLeagueApplyModel.deleteAllGuildApply(targetGuildCode);
} else {
await GVGLeagueApplyModel.deleteApply(targetGuildCode, myLeague.leagueCode);
return result;
}
} else { // 不同意，删除申请
await GVGLeagueApplyModel.deleteApply(targetGuildCode, myLeague.leagueCode);
}
// 返回
return resResult(STATUS.SUCCESS, {
guildCnt: myLeague.guildCnt,
memberCnt: myLeague.memberCnt,
leagueCe: myLeague.leagueCe
});
}
// 获取可以邀请的军团
async getInviteGuilds(msg: { page: number, name: string }, session: BackendSession) {
const guildCode = session.get('guildCode');
const serverId = session.get('serverId');
const { page, name } = msg;
// 检查时间
const serverType = await getGVGServerType(serverId);
const checkResult = await checkCanManage(serverId, serverType);
if(checkResult.code != 0) return checkResult;
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
const invitations = await GVGLeagueApplyModel.findInviteFromLeague(myLeague.leagueCode);
const serverIds = await getServersOfSameGroup(serverType, serverId);
const serverNames = await getAllServerName();
const guilds = await GuildModel.findGuildsForGVG(page, name, serverIds);
let result = guilds.map(guild => {
let data = new LeagueGuildInfo(guild, serverNames);
let hasInvited = !!invitations.find(cur => cur.guildCode == guild.code);
data.setHasInvited(hasInvited);
return data
});
// 返回
return resResult(STATUS.SUCCESS, {
guilds: result
});
}
// 邀请加入联军
async inviteGuild(msg: { guildCodes: string[] }, session: BackendSession) {
const roleId = session.get('roleId');
const guildCode = session.get('guildCode');
const serverId = session.get('serverId');
const { guildCodes } = msg;
// 必须跨服玩法
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
// 权限
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.INVITE);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
const guilds = await GuildModel.findByCodes(guildCodes);
const serverNames = await getAllServerName();
let result: LeagueGuildInfo[] = [];
for(let guild of guilds) {
await GVGLeagueApplyModel.createApply(myLeague, guild, GVG_APPLY_TYPE.INVITE);
let data = new LeagueGuildInfo(guild, serverNames);
data.setHasInvited(true);
result.push(data);
}
// 返回
return resResult(STATUS.SUCCESS, { guilds: result });
}
// 获取邀请我们军团的联军
async getLeagueInvitations(msg: {}, session: BackendSession) {
const guildCode = session.get('guildCode');
const serverNames = await getAllServerName();
const invitations = await GVGLeagueApplyModel.findInviteFromGuild(guildCode);
const applies = await GVGLeagueApplyModel.findApplyFromGuild(guildCode);
let result: LeagueListInfo[] = invitations.map(apply => getLeagueInviteData(apply, serverNames, applies));
// 返回
return resResult(STATUS.SUCCESS, { leagues: result });
}
// 处理邀请
async handleInvitation(msg: { leagueCode: string, isReceive: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { leagueCode: targetLeagueCode, isReceive } = msg;
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
// 军团权限
const checkGuildResult = await checkGuildLeader(guildCode, roleId);
if(checkGuildResult.code != 0) return checkGuildResult;
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(myLeague) return resResult(STATUS.GVG_LEAGUE_HAS_EXIST);
const league = await GVGLeagueModel.findByCode(targetLeagueCode);
if(!league) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
let hasLeague = false;
if(isReceive) {
let result = await joinGuildToLeague(league, guildCode);
if(result.code == 0) {
hasLeague = true;
await GVGLeagueApplyModel.deleteAllGuildApply(guildCode);
} else {
await GVGLeagueApplyModel.deleteInvite(guildCode, league.leagueCode);
return result;
}
} else { // 不同意，删除申请
await GVGLeagueApplyModel.deleteInvite(guildCode, league.leagueCode);
}
// 返回
return resResult(STATUS.SUCCESS, {
leagueCode: targetLeagueCode,
isReceive,
hasLeague
});
}
// 获取组成的所有军团列表
async getGuilds(msg: { leagueCode: string }, session: BackendSession) {
const { leagueCode: targetLeagueCode } = msg;
const league = await GVGLeagueModel.findByCode(targetLeagueCode);
if(!league) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
const guilds = await GuildModel.findByCodes(league.guildCodes);
const serverNames = await getAllServerName();
const result = guilds.map(guild => {
return new LeagueGuildInfo(guild, serverNames)
});
// 返回
return resResult(STATUS.SUCCESS, {
guilds: result
});
}
// 获取组成的所有玩家列表
async getMembers(msg: { leagueCode: string }, session: BackendSession) {
const { leagueCode: targetLeagueCode } = msg;
const league = await GVGLeagueModel.findByCode(targetLeagueCode);
if(!league) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
let { configId } = getGVGPeriodData();
const members = league.members||[];
let roleIds = members.map(member => member.roleId);
const roles = await RoleModel.findByRoleIds(roleIds);
const serverNames = await getAllServerName();
const userdatas = await GVGUserDataModel.findByRoles(configId, targetLeagueCode, roleIds);
const result = roles.map(role => {
let obj = new LeagueMemberListInfo(role, serverNames);
let userdata = userdatas.find(userdata => userdata.roleId == role.roleId);
if(userdata) obj.setByUserData(userdata);
let member = members.find(cur => cur.roleId == role.roleId);
if(member) obj.setAuth(member.auth);
return obj;
});
// 返回
return resResult(STATUS.SUCCESS, {
members: result
});
}
// 踢掉某个军团
async kick(msg: { guildCode: string }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { guildCode: targetGuildCode } = msg;
// 不能踢自己的军团
if(guildCode == targetGuildCode) return resResult(STATUS.GVG_CANNOUT_KICK_SELF_GUILD);
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
// 权限
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.KICK);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
// 更新对方军团信息
const guild = await GuildModel.quitFromLeague(targetGuildCode, myLeague.leagueCode, '+members');
if(!guild) return resResult(STATUS.GUILD_HAS_QUIT);
// 更新联军信息
myLeague = await GVGLeagueModel.quitGuild(myLeague.leagueCode, guild);
// 发送消息
await sendMessageToGuildWithSuc(targetGuildCode, PUSH_ROUTE.LEAGUE_KICK, { leagueCode: myLeague.leagueCode })
// 返回
return resResult(STATUS.SUCCESS, {
guildCnt: myLeague.guildCnt,
memberCnt: myLeague.memberCnt,
leagueCe: myLeague.leagueCe,
});
}
// 军团退出
async quit(msg: { guildCode: string }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { guildCode: targetGuildCode } = msg;
// 检查是否是自己军团
if(guildCode != targetGuildCode) return resResult(STATUS.GVG_CANNOUT_KICK_SELF_GUILD);
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
// 只能团长退出
let guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
const checkGuildResult = await checkGuildLeader(guildCode, roleId, guild);
if(checkGuildResult.code != 0) return checkGuildResult;
// 联军盟主不能退出
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.QUIT);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
// 更新对方军团信息
guild = await GuildModel.quitFromLeague(guild.code, myLeague.leagueCode, '+members');
// 更新联军信息
myLeague = await GVGLeagueModel.quitGuild(myLeague.leagueCode, guild);
// 发送消息
await sendMessageToGuildWithSuc(targetGuildCode, PUSH_ROUTE.LEAGUE_KICK, { leagueCode: myLeague.leagueCode })
// 返回
return resResult(STATUS.SUCCESS, {
hasLeague: !!guild.leagueCode
});
}
// 解散联军
async dismiss(msg: { leagueCode: string }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { leagueCode: targetLeagueCode } = msg;
const checkResult = await checkCanManage(serverId);
if(checkResult.code != 0) return checkResult;
// 权限
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
if(myLeague.leagueCode != targetLeagueCode) return resResult(STATUS.LEAGUE_CODE_ERR);
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.DISSMISS);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
// 更新对方军团信息
await GuildModel.dissmissLeague(targetLeagueCode);
// 更新联军信息
await GVGLeagueModel.dismiss(myLeague.leagueCode);
// 发送消息
for(let guildCode of myLeague.guildCodes) {
await sendMessageToGuildWithSuc(guildCode, PUSH_ROUTE.LEAGUE_DISSMISS, { leagueCode: myLeague.leagueCode })
}
// 返回
return resResult(STATUS.SUCCESS, {
hasLeague: false
});
}
// 获取可转让的人的列表
async getCandidate(msg: { leagueCode: string }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { leagueCode: targetLeagueCode } = msg;
// 权限
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
if(myLeague.leagueCode != targetLeagueCode) return resResult(STATUS.LEAGUE_CODE_ERR);
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.ABDICATE);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
let { configId } = getGVGPeriodData();
const members = myLeague.members||[];
const candidates = members.filter(cur => cur.auth == LEAGUE_AUTH.SUB_LEADER);
let roleIds = candidates.map(member => member.roleId);
const roles = await RoleModel.findByRoleIds(roleIds);
const serverNames = await getAllServerName();
const userdatas = await GVGUserDataModel.findByRoles(configId, targetLeagueCode, roleIds);
const result = roles.map(role => {
let obj = new LeagueMemberListInfo(role, serverNames);
let userdata = userdatas.find(userdata => userdata.roleId == role.roleId);
if(userdata) obj.setByUserData(userdata);
let member = members.find(cur => cur.roleId == role.roleId);
if(member) obj.setAuth(member.auth);
return obj;
});
const leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, targetLeagueCode);
const { producerCnt, fighterCnt } = leaguePrepare||{ producerCnt: 0, fighterCnt: 0 }
// 返回
return resResult(STATUS.SUCCESS, {
producerCnt, fighterCnt,
members: result
});
}
// 获取可转让的人的列表
async abdicate(msg: { roleId: string }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const { roleId: targetRoleId } = msg;
// 权限
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.ABDICATE);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
const checkHisAuth = await checkLeagueAuth(targetRoleId, myLeague, LEAGUE_MANAGE_TYPE.BE_ABDICATED);
if(!checkHisAuth) return resResult(STATUS.GVG_HE_HAS_NO_AUTH);
const targetRole = await RoleModel.findByRoleId(targetRoleId, '_id roleName serverId');
let targetRoleServerName = await getServerName(targetRole.serverId);
// 修改联军数据 members，leader
myLeague = await GVGLeagueModel.abdicate(myLeague.leagueCode, roleId, targetRoleId, targetRole._id);
// 推送
await sendMessageToUserWithSuc(targetRoleId, PUSH_ROUTE.LEAGUE_ABDICATE, { leagueCode: myLeague.leagueCode })
let myAuth = getMyAuth(myLeague, roleId);
// 返回
return resResult(STATUS.SUCCESS, {
auth: myAuth,
leader: {
name: targetRole.roleName,
serverId: targetRole.serverId,
serverName: targetRoleServerName
},
});
}
// 设置联军信息
async setLeagueInfo(msg: { leagueCode: string, name: string, notice: string, icon: number }, session: BackendSession) {
const roleId = session.get('roleId');
const guildCode = session.get('guildCode');
const { leagueCode: targetLeagueCode, name, notice, icon } = msg;
// 检查名字是否重
if(name != undefined) {
const checkNameResult = await GVGLeagueModel.checkName(name);
if (checkNameResult) return resResult(STATUS.LEAGUE_NAME_DUP);
}
// 权限
let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
if(myLeague.leagueCode != targetLeagueCode) return resResult(STATUS.WRONG_PARMS);
const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.SET_INFO);
if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);
// 修改联军数据
myLeague = await GVGLeagueModel.setInfo(targetLeagueCode, name, notice, icon);
// 返回
return resResult(STATUS.SUCCESS, {
leagueCode: myLeague.leagueCode,
name: myLeague.name,
notice: myLeague.notice,
icon: myLeague.icon,
});
}
}

26
game-server/app/servers/guild/remote/guildRemote.ts
View File

@@ -6,6 +6,8 @@ import { errlogger } from '../../../util/logger';
import { setApiIsClose } from '../../../services/chatService';
import { setHiddenData } from '../../../services/dataService';
import { setKvToMemory } from '../../../services/pushService';
import { getGVGConfig, setGVGConfig, setGVGServerGroup } from '../../../services/gvg/gvgService';
import { GVGConfigType } from '../../../db/GVGConfig';
export default function (app: Application) {
new HandlerService(app, {});
@@ -92,4 +94,28 @@ export class GuildRemote {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGVGConfig(config: GVGConfigType) {
try {
setGVGConfig(config);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async getGVGConfig() {
try {
return getGVGConfig();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async setGVGServerGroup() {
try {
return setGVGServerGroup();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

10
game-server/app/servers/systimer/remote/systimerRemote.ts
View File

@@ -1,5 +1,5 @@
import { Application, ChannelService } from 'pinus';
import { guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule, initMaintenance, stopMaintenance, initAutoCreateServer, addMailsToSchedule, updateTimeLimitRank, setLadderCountDown, cancelLadderCountDown, initSumSchedule, setPvpSeasonSchedule } from '../../../services/timeTaskService';
import { guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule, initMaintenance, stopMaintenance, initAutoCreateServer, addMailsToSchedule, updateTimeLimitRank, setLadderCountDown, cancelLadderCountDown, initSumSchedule, setPvpSeasonSchedule, initGVGConfigSchedule } from '../../../services/timeTaskService';
import PvpDefenseType from '../../../db/PvpDefense';
import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
import { reloadResources } from '../../../pubUtils/data';
@@ -250,4 +250,12 @@ export class SystimerRemote {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public async initGVGConfigSchedule() {
try {
await initGVGConfigSchedule();
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

7
game-server/app/services/checkParam.ts
View File

@@ -1602,6 +1602,13 @@ export function checkRouteParam(route: string, msg: any) {
if(!checkNaturalNumbers(msg.stage)) return false;
break;
}
case "battle.ladderHandler.getRec":
{
if(!checkNaturalStrings(msg.name)) return false;
if(!checkStringIfExist(msg.notice)) return false;
if(!checkNaturalNumbers(msg.icon)) return false;
break;
}
case "role.heroHandler.addItem":
{
if(!isDevelopEnv() && !checkNaturalNumbers(msg.id, msg.count)) return false;

4
game-server/app/services/gmService.ts
View File

@@ -414,4 +414,8 @@ export function getPastTime() {
export function getFutureTime() {
return moment('2100-01-01').unix();
}
export function initServerZone() {
}

5
game-server/app/services/guildService.ts
View File

@@ -27,6 +27,8 @@ import { RewardInter } from "../pubUtils/interface";
import { getGuildFundByRefTime } from "./donateService";
import { BattleRecordModel } from "../db/BattleRecord";
import { BossInstanceModel } from "../db/BossInstance";
import { pick } from "underscore";
import { memberJoinGuildToLeague } from "./gvg/gvgTeamService";
export async function getMyGuildInfo(roleId: string, sid: string, userGuild: UserGuildType, guild: GuildType, serverId: number, session: FrontendOrBackendSession) {
@@ -51,7 +53,7 @@ export async function getMyGuildInfo(roleId: string, sid: string, userGuild: Use
let guildActive = await getTodayGuildActive(guild.code);
// 返回
return { hasGuild: true, guildMemberMax, ...guild, activeDaily: guildActive, leader: { ...leader, isOnline: leaderIsOnline }, rank, myInfo: { ...userGuild } };
return { hasGuild: true, guildMemberMax, ...guild, activeDaily: guildActive, leader: { ...pick(leader, ['ce', 'lv', 'quitTime', 'roleId', 'roleName', 'head', 'frame', 'spine', 'title', 'isOnline']), isOnline: leaderIsOnline }, rank, myInfo: { ...userGuild } };
}
/**
@@ -116,6 +118,7 @@ export async function joinGuild(code: string, guildName: string, lv: number, rol
return { status: -1, resResult: resResult(STATUS.GUILD_HAS_JOIN) };
}
await updateUserInfo(REDIS_KEY.USER_INFO, roleId, [{ field: 'guildName', value: guildName }]);
await memberJoinGuildToLeague(guild, role);
const userGuild = await UserGuildModel.createUserGuild(guild.code, role, false);
if (!userGuild) {

179
game-server/app/services/gvg/gvgService.ts Normal file
View File

@@ -0,0 +1,179 @@
import { pinus } from "pinus";
import { GVGConfigModel, GVGConfigType } from "../../db/GVGConfig";
import { getTimeFun, getZeroPoint, getZeroPointOfTime, nowSeconds, WEEK_TO_SECOND } from "../../pubUtils/timeUtil";
import { getAllServerCreateTime, getServerCreateTime } from "../redisService";
import { GVG_PERIOD, GVG_SERVER_TYPE, SHOP_REFRESH_TYPE } from "../../consts";
import { GVGLeagueModel } from "../../db/GVGLeague";
import { GVGLeaguePrepareModel } from "../../db/GVGLeaguePrepare";
import { GVGServerGroupModel } from "../../db/GVGServerGroup";
import { gameData } from "../../pubUtils/data";
import { getRandSingleEelm } from "../../pubUtils/util";
import { GVG } from "../../pubUtils/dicParam";
import { ServerlistModel } from "../../db/Serverlist";
import { GuildType } from "../../db/Guild";
// 定时器相关
export async function createNewGVGConfig() {
let { teamTime, prepareTime, battleTime, scheduleTime } = getPeriodTime();
const config = await GVGConfigModel.createNewConfig(teamTime, prepareTime, battleTime, scheduleTime);
setGVGConfigToRemote(config);
// TODO 每周自动解散一些联军
await pinus.app.rpc.guild.guildRemote.setGVGServerGroup.broadcast();
return config;
}
// 获取各个周期的时间，大约每周日5点的时候刷的
export function getPeriodTime() {
let now = new Date();
let curDay = now.getDay(); // 今天星期几
let teamConfig = gameData.gvgPeriod.get(GVG_PERIOD.TEAM);
let prepareConfig = gameData.gvgPeriod.get(GVG_PERIOD.PREPARE);
let battleConfig = gameData.gvgPeriod.get(GVG_PERIOD.BATTLE);
// 如果现在是周日，那么就是本周期的组队开始时间，如果是其他日子（启动初始化），就是下周期的组队开始时间
let _teamTime = <number>getTimeFun().getTimeWithWeek(teamConfig.startDay, teamConfig.startHour, teamConfig.startMinute, teamConfig.startSecond);
let _prepareTime = <number>getTimeFun().getTimeWithWeek(prepareConfig.startDay, prepareConfig.startHour, prepareConfig.startMinute, prepareConfig.startSecond);
let _battleTime = <number>getTimeFun().getTimeWithWeek(battleConfig.startDay, battleConfig.startHour, battleConfig.startMinute, battleConfig.startSecond);
console.log('_teamTime: ', _teamTime);
let teamTime = curDay == 0? _teamTime: _teamTime - 7 * 86400;
let prepareTime = curDay == 0? _prepareTime + 7 * 86400: _prepareTime;
let battleTime = curDay == 0? _battleTime + 7 * 86400: _battleTime;
let scheduleTime = teamTime + 7 * 86400;
return { teamTime, prepareTime, battleTime, scheduleTime }
}
export async function getGVGConfigFromRemote() {
let guildServers = pinus.app.getServersByType('guild');
let server = getRandSingleEelm(guildServers);
return await pinus.app.rpc.guild.guildRemote.getGVGConfig.toServer(server.id);
}
export function setGVGConfigToRemote(config: GVGConfigType) {
if(!config) return null
pinus.app.rpc.guild.guildRemote.setGVGConfig.broadcast(config);
}
export function setGVGConfig(config: GVGConfigType) {
if(!config) return null
pinus.app.set('gvgConfigId', config.configId);
pinus.app.set('gvgTeamTime', config.teamTime);
pinus.app.set('gvgPrepareTime', config.prepareTime);
pinus.app.set('gvgBattleTime', config.battleTime);
pinus.app.set('gvgScheduleTime', config.scheduleTime);
}
export function getGVGConfig() {
let configId = pinus.app.get('gvgConfigId');
let teamTime = pinus.app.get('gvgTeamTime');
let prepareTime = pinus.app.get('gvgPrepareTime');
let battleTime = pinus.app.get('gvgBattleTime');
let scheduleTime = pinus.app.get('gvgScheduleTime');
return { configId, teamTime, prepareTime, battleTime, scheduleTime }
}
function getServerTypeByTime(openTime: number) {
let today = nowSeconds();
if(today - openTime < WEEK_TO_SECOND) return GVG_SERVER_TYPE.NO;
let toWeek = getCurrentTeamTime(today);
let openWeek = getCurrentTeamTime(openTime);
let n = Math.floor((toWeek - openWeek) / WEEK_TO_SECOND);
return n <= GVG.GVG_CROSS_SERVICE_STARTTIME? GVG_SERVER_TYPE.SINGLE: GVG_SERVER_TYPE.MULTI;
}
function getCurrentTeamTime(time: number) {
let teamConfig = gameData.gvgPeriod.get(GVG_PERIOD.TEAM);
// 本周日
let _teamTime = <number>getTimeFun(time).getTimeWithWeek(teamConfig.startDay, teamConfig.startHour, teamConfig.startMinute, teamConfig.startSecond);
return _teamTime > time? _teamTime - WEEK_TO_SECOND: _teamTime;
}
export async function getGVGServerType(serverId: number) {
console.log('#### serverId', serverId)
let openTime = await getServerCreateTime(serverId);
return getServerTypeByTime(openTime)
}
export function getGVGPeriodData() {
let { configId, teamTime, prepareTime, battleTime, scheduleTime } = getGVGConfig();
let period = getCurPeriod();
let countdownTime = teamTime;
switch(period) {
case GVG_PERIOD.TEAM: {
countdownTime = prepareTime; break;
}
case GVG_PERIOD.PREPARE: {
countdownTime = battleTime; break;
}
case GVG_PERIOD.BATTLE: {
countdownTime = scheduleTime; break;
}
}
return { configId, period, countdownTime };
}
export function getCurPeriod() {
let { teamTime, prepareTime, battleTime } = getGVGConfig();
let now = nowSeconds();
if(now >= teamTime && now < prepareTime) {
return GVG_PERIOD.TEAM;
} else if (now >= prepareTime && now < battleTime) {
return GVG_PERIOD.PREPARE;
} else {
return GVG_PERIOD.BATTLE;
}
}
export async function initLeaguePrepare() {
const { configId } = getGVGConfig();
const leagues = await GVGLeagueModel.findAllLeague();
for(let { leagueCode, memberCnt } of leagues) {
await GVGLeaguePrepareModel.initData(configId, leagueCode, memberCnt);
}
}
export async function setGVGServerGroup() {
const servers = await ServerlistModel.findByEnv(pinus.app.get('env'));
const serverGroups = await GVGServerGroupModel.findByTime(nowSeconds());
pinus.app.set('gvgServerGroup', servers.map(obj => {
let server = serverGroups.find(cur => cur.serverId == obj.serverId);
return { serverId: obj.id, groupId: server? server.groupId: obj.groupId }
}));
}
// 查询本小区所在的战区
// gvgServerGroup: id-小区唯一id serverId-小区在大区下的id
export async function getGroupIdOfServer(id: number) {
let arr: { serverId: number; groupId: number }[] = pinus.app.get('gvgServerGroup')||[];
let obj = arr.find(cur => cur.serverId == id);
return obj?.groupId||0;
}
// 查询当前和本小区同一个战区的其他小区
export async function getServersOfSameGroup(type: GVG_SERVER_TYPE, id: number) {
if(type == GVG_SERVER_TYPE.SINGLE) return [id];
let groupId = await getGroupIdOfServer(id);
let arr: { serverId: number; groupId: number }[] = pinus.app.get('gvgServerGroup')||[];
let serverCreateTimes = await getAllServerCreateTime();
return arr.filter(obj => {
let openTime = parseInt(serverCreateTimes[obj.serverId]);
return obj.groupId == groupId && getServerTypeByTime(openTime) == type;
}).map(obj => obj.serverId);
}
export async function getGVGInfoInGuild(guild: GuildType) {
let hasLeague = !!guild.leagueCode;
let serverId = guild.serverId;
let { configId, period, countdownTime } = getGVGPeriodData();
let type = await getGVGServerType(serverId);
return {
hasLeague,
configId, period, countdownTime,
type
}
}

228
game-server/app/services/gvg/gvgTeamService.ts Normal file
View File

@@ -0,0 +1,228 @@
// 和gvg组建期相关的方法
import { GUILD_AUTH, GVG_APPLY_TYPE, GVG_PERIOD, GVG_SERVER_TYPE, LEAGUE_AUTH, LEAGUE_MANAGE_TYPE, PUSH_ROUTE, STATUS } from "../../consts";
import { GuildModel, GuildType } from "../../db/Guild";
import { GVGLeagueModel, GVGLeagueType, GVGLeagueUpdate } from "../../db/GVGLeague";
import { GVGLeagueApplyModel, GVGLeagueApplyType } from "../../db/GVGLeagueApply";
import { GVGLeaguePrepareModel, GVGLeaguePrepareType } from "../../db/GVGLeaguePrepare";
import { RoleType } from "../../db/Role";
import { UserGuildModel } from "../../db/UserGuild";
import { LeagueGuildInfo, LeagueListInfo } from "../../domain/gvgField/returnData";
import { GVG } from "../../pubUtils/dicParam";
import { getZeroPointD } from "../../pubUtils/timeUtil";
import { resResult } from "../../pubUtils/util";
import { sendMessageToUserWithSuc } from "../pushService";
import { getCurPeriod, getGVGConfig, getGVGPeriodData, getGVGServerType } from "./gvgService";
/**
* 自动创建联军
* @param guildCode 创建联军的那个军团
* @returns GVGLeagueType
*/
export async function autoCreateLeague(guildCode: string) {
let guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
if(!guild || guild.lv < GVG.GVG_ARMY_LEAGUE_TIME) return;
let period = getCurPeriod();
if(period == GVG_PERIOD.PREPARE || period == GVG_PERIOD.BATTLE) {
return await createLeague(guild, {});
}
}
/**
* 创建联军
* @param guild 创建联军的那个军团
* @param params 联军的一些初始数据
* @returns
*/
export async function createLeague(guild: GuildType, params: GVGLeagueUpdate) {
let serverType = await getGVGServerType(guild.serverId);
params.type = serverType;
params.serverId = guild.serverId;
const league = await GVGLeagueModel.createLeague(guild, params);
await GuildModel.joinLeague(guild.code, league.leagueCode);
return league;
}
/**
* 获取在联军中的职位
* @param league
* @param roleId
* @returns
*/
export function getMyAuth(league: GVGLeagueType, roleId: string) {
let members = league.members;
let member = members.find(cur => cur.roleId == roleId);
return member?.auth?? LEAGUE_AUTH.MEMBER;
}
/**
* 加入联军的当天如果是在准备期，这天不能去参加内政
* @param roleId
* @returns
*/
export async function checkCanPrepare(roleId: string) {
let userGuild = await UserGuildModel.getMyGuild(roleId, 'createdAt');
let today = getZeroPointD();
return userGuild.createdAt < today;
}
/**
* 是否可以选择职能，如果选择的人数超过了就不可以选
* @param myJob
* @param league
* @returns
*/
export function checkCanChooseJob(myJob: number, league: GVGLeaguePrepareType) {
if(myJob > 0) return false;
if(!league) return false;
let { producerCnt, fighterCnt, maxMemberCnt } = league;
return producerCnt + fighterCnt <= maxMemberCnt;
}
/**
* 获取申请数据
* @param apply 本条申请原数据
* @param serverNames 全服务器的名字from redis
* @param invitations 本联军向其他军团发出的邀请
* @returns
*/
export function getLeagueApplyData(apply: GVGLeagueApplyType, serverNames: any, invitations: GVGLeagueApplyType[] ) {
let data = new LeagueGuildInfo(<GuildType>apply.guild, serverNames);
let hasInvited = !!invitations.find(cur => cur.guildCode == apply.guildCode);
data.setHasInvited(hasInvited);
return data;
}
/**
* 获取邀请数据
* @param invite 本条邀请原数据
* @param serverNames 全服务器的名字from redis
* @param applies 本军团向其他联军发出的申请
* @returns
*/
export function getLeagueInviteData(invite: GVGLeagueApplyType, serverNames: any, applies: GVGLeagueApplyType[]) {
let data = new LeagueListInfo(<GVGLeagueType>invite.league, serverNames);
let hasApply = !!applies.find(cur => cur.leagueCode == invite.guildCode);
data.setHasApply(hasApply);
return data;
}
/**
* 联军加入军团
* @param myLeague
* @param targetGuildCode
* @returns
*/
export async function joinGuildToLeague(league: GVGLeagueType, targetGuildCode: string) {
const hasApply = await GVGLeagueApplyModel.checkApply(league.leagueCode, targetGuildCode, GVG_APPLY_TYPE.ALL);
if(!hasApply) {
return resResult(STATUS.GUILD_NOT_APPLY);
}
if(league.guildCnt >= GVG.GVG_LEAGUE_COMPOSE) {
return resResult(STATUS.LEAGUE_IS_GUILD_MAX);
}
let hisLeague = await GVGLeagueModel.findLeagueByGuild(targetGuildCode);
if(hisLeague) {
await GVGLeagueApplyModel.deleteApply(targetGuildCode, league.leagueCode);
return resResult(STATUS.TARGET_GUILD_HAS_LEAGUE);
}
const targetGuild = await GuildModel.findByCode(targetGuildCode, null, '+members');
if(!targetGuild) return resResult(STATUS.TARGET_GUILD_NOT_FOUND);
if(targetGuild.lv < GVG.GVG_ARMY_LEAGUE_TIME) return resResult(STATUS.GUILD_LV_NOT_ENOUGH);
league = await GVGLeagueModel.joinGuild(league.leagueCode, targetGuild);
await GuildModel.joinLeague(targetGuildCode, league.leagueCode);
return resResult(STATUS.SUCCESS, league);
}
/**
* 检查是否可以进行组建联军等操作
* @param serverId
* @param serverType
* @returns
*/
export async function checkCanManage(serverId: number, serverType?: number) {
if(!serverType) serverType = await getGVGServerType(serverId);
if(serverType != GVG_SERVER_TYPE.MULTI) return resResult(STATUS.GVG_TEAM_SERVER_TYPE_ERR);
let { period } = getGVGPeriodData();
if(period != GVG_PERIOD.TEAM) return resResult(STATUS.GVG_NOT_TEAM_PERIOD);
return resResult(STATUS.SUCCESS);
}
/**
* 一些操作只能由军团的团长才能操作
* @param guildCode
* @param roleId
* @param guild
* @returns
*/
export async function checkGuildLeader(guildCode: string, roleId: string, guild?: GuildType) {
if(!guild) guild = await GuildModel.findByCode(guildCode, null, '+members +serverId');
if(!guild) return resResult(STATUS.GVG_HAS_NO_AUTH);
if(guild.lv < GVG.GVG_ARMY_LEAGUE_TIME) return resResult(STATUS.GUILD_LV_NOT_ENOUGH);
const userGuild = await UserGuildModel.getMyGuild(roleId, 'auth');
if(!userGuild || userGuild.auth != GUILD_AUTH.LEADER) return resResult(STATUS.GVG_HAS_NO_AUTH);
return resResult(STATUS.SUCCESS);
}
/**
* 检查联军的操作
* @param roleId
* @param myLeague
* @param type
* @returns
*/
export async function checkLeagueAuth(roleId: string, myLeague: GVGLeagueType, type: LEAGUE_MANAGE_TYPE) {
const auth = getMyAuth(myLeague, roleId);
const needAuth = getAuthFromManageType(type);
return needAuth.indexOf(auth) > -1
}
function getAuthFromManageType(type: LEAGUE_MANAGE_TYPE) {
switch(type) {
case LEAGUE_MANAGE_TYPE.HANDLE_APPLY:
case LEAGUE_MANAGE_TYPE.INVITE:
case LEAGUE_MANAGE_TYPE.KICK:
case LEAGUE_MANAGE_TYPE.DISSMISS:
case LEAGUE_MANAGE_TYPE.ABDICATE:
return [LEAGUE_AUTH.LEADER];
case LEAGUE_MANAGE_TYPE.QUIT:
case LEAGUE_MANAGE_TYPE.BE_ABDICATED:
return [LEAGUE_AUTH.SUB_LEADER];
case LEAGUE_MANAGE_TYPE.SET_INFO:
return [LEAGUE_AUTH.LEADER, LEAGUE_AUTH.SUB_LEADER];
}
}
export async function memberJoinGuildToLeague(guild: GuildType, role: RoleType) {
if(!guild.leagueCode) return;
let league = await GVGLeagueModel.joinMember(guild.leagueCode, role.roleId, role.ce);
// TODO redis联军更新
console.log(league);
}
export async function memberQuitGuildToLeague(guild: GuildType, role: RoleType) {
if(!guild.leagueCode) return;
let league = await GVGLeagueModel.quitMember(guild.leagueCode, role.roleId, role.ce);
// TODO redis联军更新
console.log(league);
}
export async function guildDismissToLeague(guild: GuildType) {
if(!guild.leagueCode) return;
let league = await GVGLeagueModel.quitGuild(guild.leagueCode, guild);
// TODO redis联军更新
console.log(league);
}
export async function guildAbdicateToLeague(guild: GuildType, fromRoleId: string, toRole: RoleType) {
if(!guild.leagueCode) return;
let league = await GVGLeagueModel.abdicateGuild(guild.leagueCode, fromRoleId, toRole.roleId, toRole._id);
// TODO redis联军更新
console.log(league);
}

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

@@ -20,6 +20,7 @@ import { sendMessageToUserWithSuc } from './pushService';
import { SkinType } from '../db/Skin';
import { LadderMatchModel } from '../db/LadderMatch';
import { ArtifactModelType } from '../db/Artifact';
import { GVGLeagueModel } from '../db/GVGLeague';
interface Param {
isInitRole?: boolean,
@@ -454,6 +455,7 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
roleCe = await RoleCeModel.updateRoleCe(roleId, roleCeUpdate);
let role = await RoleModel.incRoleInfo(roleId, { ...roleIncUpdate, ce: roleInc }, { ...roleUpdate, topLineup, topLineupCe });
let guild = await GuildModel.updateCe(roleId, roleInc); // 公会更新战力
let league = await GVGLeagueModel.updateCe(roleId, roleInc); // 联军更新战力
saveCeChangeLog(role, roleInc, role.ce, type, ceChangeTxt);
updateRank(roleId, serverId, topLineupCe, role, pushHeros, guild);
@@ -461,6 +463,9 @@ export async function calculateCes(type: HERO_SYSTEM_TYPE, roleId: string, serve
if(hasTopCeChange) await updateRoleOnlineInfo(roleId, { topLineupCe });
if(guild) {
await updateUserInfo(REDIS_KEY.GUILD_INFO, guild.code, [{ field: 'guildCe', value: guild.guildCe }]);
}
if(league) { // TODO 联军排行榜需要更新数据
}
return { heroes, curRole: role }
}

9
game-server/app/services/redisService.ts
View File

@@ -513,7 +513,7 @@ async function setServerList() {
await redisClient().delAsync(REDIS_KEY.SERVER);
await redisClient().delAsync(REDIS_KEY.SERVER_OPEN_TIME);
for(let { id, name, openTime, env } of serverList) {
for(let { id, serverId, name, openTime, env } of serverList) {
if(env == pinus.app.get('env')) {
// console.log(roleId);
await redisClient().hsetAsync(REDIS_KEY.SERVER, `${id}`, `${name}`);
@@ -536,7 +536,7 @@ export async function getAllServers() {
}
export async function getAllServerName() {
let servers = await redisClient().hgetallAsync(REDIS_KEY.SERVER);
let servers = await redisClient().hgetallAsync(REDIS_KEY.SERVER);
return servers;
}
@@ -550,6 +550,11 @@ export async function getServerCreateTime(serverId: number) {
return parseInt(time);
}
export async function getAllServerCreateTime() {
let servers = await redisClient().hgetallAsync(REDIS_KEY.SERVER_OPEN_TIME);
return servers;
}
export function redisClient() {
const client: Redis.RedisClient = pinus.app.get('redis');
return client;

29
game-server/app/services/timeTaskService.ts
View File

@@ -42,6 +42,8 @@ import { LadderMatchModel } from '../db/LadderMatch';
import { getGroupShopTimers, refundGroupShop, setGroupShopToSetSum } from './activity/groupShopService';
import { HiddenDataModel, HiddenDataModelType } from '../db/HiddenData';
import { setHiddenData, setHiddenDataToMemory } from './dataService';
import { GVGConfigModel } from '../db/GVGConfig';
import { createNewGVGConfig, initLeaguePrepare, setGVGConfigToRemote } from './gvg/gvgService';
const PER_SECOND = 1 * 1000;
const PER_DAY = 24 * 60 * 60;
@@ -106,6 +108,9 @@ export async function init() {
// 隐藏数据定时器
initHiddenDataSchedule(true);
// gvg每周日
initGVGConfigSchedule();
}
// 每日刷新
@@ -889,4 +894,26 @@ export async function initHiddenDataSchedule(isInit: boolean, data?: HiddenDataM
});
}
}
// —————————————— 配表兼容 end —————————————— //
// —————————————— 配表兼容 end —————————————— //
// —————————————— gvg start —————————————— //
export async function initGVGConfigSchedule() {
let config = await GVGConfigModel.findConfig();
if(!config) {
config = await createNewGVGConfig();
}
setGVGConfigToRemote(config);
if(nowSeconds() > config.scheduleTime) {
config = await createNewGVGConfig();
} else {
scheduleJob(`gvgConfig`, config.scheduleTime * 1000, createNewGVGConfig);
}
if(nowSeconds() > config.prepareTime) {
initLeaguePrepare();
} else {
scheduleJob(`gvgPrepare`, config.prepareTime * 1000, initLeaguePrepare);
}
}
// —————————————— gvg end —————————————— //