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

军团优化：军团上次排行榜

Browse Source
This commit is contained in:
luying
2022-07-22 09:41:54 +08:00
parent 1f045bd11d
commit a3af186161
17 changed files with 259 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -315,14 +315,6 @@ export class GmHandler {
await pinus.app.rpc.guild.guildActivityRemote.guildActivityEnd.broadcast(aid);
await pinus.app.rpc.guild.guildActivityRemote.clearActivityObj.broadcast();
// 清空旧数据
if (day <= 2) {
await GuildActivityCityModel.clearGuardAndStartNext();
await GuildActivityCityDeclareModel.clearDeclare();
}
if(aid != 0) await delGuildActivityRank(aid);
await GuildActivityRecordModel.updateTodayInfo({ status: 2 });
// 开启定时器
await pinus.app.rpc.systimer.systimerRemote.setAuctionSchedule.broadcast();
await pinus.app.rpc.systimer.systimerRemote.setGuildActivitySchedule.broadcast();

89
game-server/app/servers/guild/handler/cityActivityHandler.ts
View File

@@ -1,16 +1,15 @@
import { Application, ChannelService, BackendSession, pinus, HandlerService, } from "pinus";
import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, GUILD_POINT_WAYS, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { GUILD_ACTIVITY_TYPE, STATUS, REDIS_KEY, CITY_STATUS, TASK_TYPE, ITEM_CHANGE_REASON, PUSH_ROUTE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { resResult } from "../../../pubUtils/util";
import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, getPreDayActiveData, sendGuildCityDeclare, declareCity, autoDeclareMyCity } from "../../../services/guildActivity/guildActivityService";
import { getGuildActivityStatus, getCityActivityObj, getCityStatus as pubGetCityStatus, getCities, getCityActivityRank, sendSingleCityActEndMsg, getPreDayActiveData, declareCity, autoDeclareMyCity, getGAIndexInPinus, getDeclareIndex } from "../../../services/guildActivity/guildActivityService";
import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
import { gameData } from "../../../pubUtils/data";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
import { leaveCityChannel, addRoleToCityChannel, getCityChannelSid } from "../../../services/chatService";
import { leaveCityChannel, addRoleToCityChannel } from "../../../services/chatService";
import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { nowSeconds, getTimeFun } from "../../../pubUtils/timeUtil";
import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
import { getGoldObject, handleCost } from "../../../services/role/rewardService";
import { addActive } from "../../../services/guildService";
import { Rank } from "../../../services/rankService";
import { checkTask } from "../../../services/task/taskService";
import { guildInter } from "../../../pubUtils/interface";
@@ -36,22 +35,28 @@ export class CityActivityHandler {
// 进入诸侯混战
async getCityActivity(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
// const roleName = session.get('roleName');
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(statusResult.status == GUILD_ACTIVITY_STATUS.START) {
await autoDeclareMyCity(serverId, roleId, guildCode);
let obj = getCityActivityObj();
if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) {
await autoDeclareMyCity(serverId, roleId, guildCode, declareIndex);
}
const dbCities = await GuildActivityCityModel.getAllCities(serverId);
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cities = getCities(guildCode, dbCities);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
let ranks = await getCityActivityRank(guildCode, serverId, guildActivityRec?.challengeCityId, roleId, roleName);
return resResult(STATUS.SUCCESS, {
...statusResult,
cities
cities,
...ranks
});
}
@@ -65,6 +70,8 @@ export class CityActivityHandler {
let sid = session.get('sid');
const { cityId } = msg;
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
@@ -74,7 +81,7 @@ export class CityActivityHandler {
let obj = getCityActivityObj();
let {gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let myGuildActivityRec = await UserGuildActivityRecModel.findByRoleId(roleId, guildActivityRec.code);
@@ -83,7 +90,7 @@ export class CityActivityHandler {
challengeTime = myGuildActivityRec.challengeTime;
}
const dbCities = await GuildActivityCityModel.getAllCities(serverId);
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
if (cityStatus == CITY_STATUS.DECLARED) {
obj.pushGuild(guildCode, serverId, cityId);
@@ -120,17 +127,18 @@ export class CityActivityHandler {
let dicCity = gameData.cityActivity.get(cityId);
if (dicCity.preCity.length > 0) return resResult(STATUS.CAN_NOT_DECLARE);
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode);
let declareIndex = getDeclareIndex();
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if (!!checkResult) return resResult(STATUS.HAS_DECLARED);
let curCity = await GuildActivityCityModel.getCity(serverId, cityId);
let curCity = await GuildActivityCityModel.getCity(serverId, cityId, declareIndex);
if (curCity && curCity.guardGuildCode) {
return resResult(STATUS.CITY_IS_GUARD);
}
let declareResult = await declareCity(serverId, roleId, guildCode, cityId, false);
let declareResult = await declareCity(serverId, roleId, guildCode, cityId, false, declareIndex);
if(!declareResult) return resResult(STATUS.HAS_DECLARED);
const dbCities = await GuildActivityCityModel.getAllCities(serverId);
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cities = getCities(guildCode, dbCities);
return resResult(STATUS.SUCCESS, { cities });
}
@@ -145,10 +153,12 @@ export class CityActivityHandler {
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
let declareIndex = getDeclareIndex();
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode);
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if (!checkResult) return resResult(STATUS.HAS_NOT_DECLARED);
let obj = getCityActivityObj();
@@ -162,7 +172,7 @@ export class CityActivityHandler {
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index, [], cityId);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
@@ -180,10 +190,10 @@ export class CityActivityHandler {
obj.pushMembers(guildCode, roleId, userGuild.job, myGuildActivityRec.code);
// 返回当前军团总军功
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
const dbCities = await GuildActivityCityModel.getAllCities(serverId);
const dbCities = await GuildActivityCityModel.getAllCities(serverId, declareIndex);
let cityStatus = pubGetCityStatus(guildCode, cityId, dicCity, dbCities);
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
@@ -212,10 +222,11 @@ export class CityActivityHandler {
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
@@ -261,18 +272,27 @@ export class CityActivityHandler {
})
}
let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage });
let challengeTime = nowSeconds() + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
if(isDebugTime()) {
let guilds = pinus.app.getServersByType('guild');
let guild = dispatch(roleId, guilds, 'guild');
let currentTime = await pinus.app.rpc.guild.guildActivityRemote.getCurrentTime.toServer(guild.id);
challengeTime = Math.floor(currentTime/1000) + GUILDACTIVITY.CITYACTIVITY_CHALLENGE_CD;
}
let pushResult = await UserGuildActivityRecModel.pushCityRecord(code, { round, hid, damage }, challengeTime);
if (!pushResult) return resResult(STATUS.WRONG_PARMS);
let tomorrow = <number>getTimeFun().getAfterDayWithHour();
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
// 更新redis数据
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.setRankWithRoleInfo(roleId, damage, obj.getTimeGap(), null, true);
await myR.setExpire(tomorrow);
await myR.setExpire(nextWeek);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.setRankWithGuildInfo(guildCode, damage, obj.getTimeGap(), null, true);
await r.setExpire(tomorrow);
await r.setExpire(nextWeek);
({gateHp, maxHp} = await obj.getGateHpAndInc(serverId, cityId, -1 * damage));
if (gateHp <= 0) {
@@ -322,9 +342,10 @@ export class CityActivityHandler {
if (!myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);
// 返回当前军团总军功
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.getMyScore({ roleId });
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
let { gateHp, maxHp } = await obj.getGateHpAndInc(serverId, cityId);
@@ -339,16 +360,4 @@ export class CityActivityHandler {
challengeTime: myGuildActivityRec.challengeTime
});
}
// ! 测试接口
async debugResetCity(msg: { }, session: BackendSession) {
let guildCode = session.get('guildCode');
await GuildActivityCityDeclareModel.clearDeclare();
await GuildActivityCityModel.findOneAndUpdate(
{ declareGuilds: { $in: [guildCode] } },
{ $set: { guardGuildCode: "", guardGuildName: "", declareCount: 0, declareGuilds: [] } },
{ new: true }).lean();
return resResult(STATUS.SUCCESS);
}
}

31
game-server/app/servers/guild/handler/gateActivityHandler.ts
View File

@@ -1,5 +1,5 @@
import { Application, BackendSession, ChannelService, pinus, HandlerService, } from "pinus";
import { getGuildActivityStatus, getRecordScore, getGateActivityObj, participants, getGateActivityRank, getCityActivityObj } from "../../../services/guildActivity/guildActivityService";
import { getGuildActivityStatus, getRecordScore, getGateActivityObj, participants, getGateActivityRank, getCityActivityObj, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
import { resResult } from "../../../pubUtils/util";
import { STATUS, GUILD_ACTIVITY_TYPE, GUILD_POINT_WAYS, ENEMIES_TYPE, GET_POINT_WAYS, TASK_TYPE, GUILD_ACTIVITY_STATUS } from "../../../consts";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -36,12 +36,13 @@ export class GateActivityHandler {
const roleName = session.get('roleName');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let index = getGAIndexInPinus(this.aid);
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
let { code: sourceCode } = guildActivityRec;
@@ -69,12 +70,13 @@ export class GateActivityHandler {
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let obj = getGateActivityObj();
let index = getGAIndexInPinus(this.aid);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
let { code: sourceCode } = guildActivityRec;
@@ -89,7 +91,7 @@ export class GateActivityHandler {
obj.pushMembers(guildCode, serverId, roleId, userGuild.job, code);
// 返回当前军团总军功
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let guildScore = await r.getMyScore({ guildCode });
// 全服活跃统计
await ServerRecordModel.addActiveGuild(serverId, roleId, guildCode);
@@ -132,15 +134,17 @@ export class GateActivityHandler {
let { score, newRecords, memberRecord: newMemberRecord } = scoreResult;
obj.setMemberRecord(code, newMemberRecord);
let tomorrow = <number>getTimeFun().getAfterDayWithHour();
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
console.log('####### nextWeek', nextWeek)
let index = getGAIndexInPinus(this.aid);
// 更新redis数据
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let myScore = await myR.setRankWithRoleInfo(roleId, score, obj.getTimeGap(), null, true);
await myR.setExpire(tomorrow);
await myR.setExpire(nextWeek);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let guildScore = await r.setRankWithGuildInfo(guildCode, score, obj.getTimeGap(), null, true);
await r.setExpire(tomorrow);
await r.setExpire(nextWeek);
// 更新数据库
let rec = await UserGuildActivityRecModel.pushRecord(code, newRecords, round);
@@ -183,7 +187,8 @@ export class GateActivityHandler {
}
}
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
let index = getGAIndexInPinus(this.aid);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
if (isSuccess && statusResult.status == GUILD_ACTIVITY_STATUS.START) {
let obj = getGateActivityObj();
@@ -263,7 +268,6 @@ export class GateActivityHandler {
for (let server of guildServers) {
pinus.app.rpc.guild.guildActivityRemote.updateGuildActivityData.toServer(server.id, aid, true);
}
await GuildActivityRecordModel.updateTodayInfo({ status: 2 });
return resResult(STATUS.SUCCESS);
}
@@ -317,9 +321,10 @@ export class GateActivityHandler {
if (!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
let serverId = session.get('serverId');
let { aid } = msg;
await GuildActivityRecordModel.getRecord(guildCode, serverId, aid);
let index = getGAIndexInPinus(aid);
await GuildActivityRecordModel.getRecord(guildCode, serverId, aid, index);
let userGuild = await UserGuildModel.getMyGuild(roleId);
let result = await GuildActivityRecordModel.updateInfo(guildCode, aid, { memberCnt: 1, members: [{ roleId, job: userGuild.job, code: '' }], auctionType: aid + 1 });
let result = await GuildActivityRecordModel.updateInfo(guildCode, aid, index, { memberCnt: 1, members: [{ roleId, job: userGuild.job, code: '' }], auctionType: aid + 1 });
return resResult(STATUS.SUCCESS, {
sourceType: result.auctionType,

15
game-server/app/servers/guild/handler/raceActivityHandler.ts
View File

@@ -1,7 +1,7 @@
import { Application, ChannelService, BackendSession, HandlerService, } from "pinus";
import { GUILD_ACTIVITY_TYPE, STATUS, GUILD_ACTIVITY_STATUS, GUILD_POINT_WAYS, REDIS_KEY, TASK_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS, DEBUG_MAGIC_WORD } from "../../../consts";
import { genCode, resResult } from "../../../pubUtils/util";
import { getGuildActivityStatus, getRaceActivityObj, getWoodenHorseList, calWoodenHorseAndSend, raceActivitySettleReward } from "../../../services/guildActivity/guildActivityService";
import { getGuildActivityStatus, getRaceActivityObj, getWoodenHorseList, calWoodenHorseAndSend, raceActivitySettleReward, getGAIndexInPinus } from "../../../services/guildActivity/guildActivityService";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
@@ -51,7 +51,8 @@ export class RaceActivityHandler {
if(obj.status == RACE_ACTIVITY_STATUS.START) {
ranks = await obj.getRanks(serverId, guildCode);
} else {
let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
let index = getGAIndexInPinus(this.aid);
let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId, index });
r.setGenerFieldsFun(function (param: GuildRankInfo) {
let { rank, code, name, num, num1, num2 } = param;
return { rank, code, name, num, time: Math.floor(num1/1000), durability: num2 };
@@ -80,6 +81,7 @@ export class RaceActivityHandler {
const guildCode = session.get('guildCode');
const sid = session.get('sid');
if (!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
let index = getGAIndexInPinus(this.aid);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
@@ -92,7 +94,7 @@ export class RaceActivityHandler {
}
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, obj.getEvents(guildCode, 0));
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index, obj.getEvents(guildCode, 0));
if (!guildActivityRec) return resResult(STATUS.WRONG_PARMS);
let { code: sourceCode } = guildActivityRec;
@@ -160,6 +162,7 @@ export class RaceActivityHandler {
let serverId = session.get('serverId');
let guildCode = session.get('guildCode');
let sid = session.get('sid');
let index = getGAIndexInPinus(this.aid);
let { id, count, toGuild } = msg;
if (!count || count < 0) return resResult(STATUS.WRONG_PARMS);
@@ -170,7 +173,7 @@ export class RaceActivityHandler {
let event = await obj.useItem(serverId, roleId, sid, guildCode, toGuild, id, count);
if (!event) return resResult(STATUS.BATTLE_CONSUMES_NOT_ENOUGH);
await GuildActivityRecordModel.pushEvent(guildCode, this.aid, event);
await GuildActivityRecordModel.pushEvent(guildCode, this.aid, index, event);
return resResult(STATUS.SUCCESS, {
timestamp: Date.now(),
@@ -183,14 +186,14 @@ export class RaceActivityHandler {
let guildCode = session.get('guildCode');
let serverId = session.get('serverId');
let { code, isSuccess } = msg;
let index = getGAIndexInPinus(this.aid);
let statusResult = getGuildActivityStatus(this.aid);
if (!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
// 更新userGuildActivityRecord
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid, index);
let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true });
if (!guildActivityRec || !myGuildActivityRec) return resResult(STATUS.WRONG_PARMS);

19
game-server/app/servers/guild/remote/guildActivityRemote.ts
View File

@@ -1,5 +1,5 @@
import { Application, ChannelService, HandlerService, } from 'pinus';
import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, gateActivityStart, cityActivityStart, clearActivityObj } from '../../../services/guildActivity/guildActivityService';
import { sendAllGuildRanks, calWoodenHorseAndSend, sendRaceStartMsg, setDicGuildActivity, setDicAuctionTime, settleGuildActivityReward, clearActivityObj, getGAPinusName, getCurGuildActivityIndexByDb, initGuildActivityIndexInPinus, setGuildActivityIndexInPinus, guildActivityStart } from '../../../services/guildActivity/guildActivityService';
import { gameData } from '../../../pubUtils/data';
import { setWeek } from '../../../pubUtils/timeUtil';
import { sendUngotDividend } from '../../../services/auctionService';
@@ -15,6 +15,7 @@ export class GuildActivityRemote {
constructor(private app: Application) {
this.app = app;
initGuildActivityIndexInPinus();
}
private currentTime: number = Date.now();
@@ -61,13 +62,9 @@ export class GuildActivityRemote {
/**
* 诸侯混战和蛮夷入侵开始
*/
async gateAndCityActivityStart(aid: number) {
async guildActivityStart(aid: number) {
try {
if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
await gateActivityStart();
} else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
await cityActivityStart();
}
await guildActivityStart(aid);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
@@ -184,4 +181,12 @@ export class GuildActivityRemote {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
async setGuildActivityIndex(aid: number, index: number) {
try {
setGuildActivityIndexInPinus(aid, index);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
}

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

@@ -4,7 +4,7 @@ import PvpDefenseType from '../../../db/PvpDefense';
import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
import { reloadResources } from '../../../pubUtils/data';
import { setMarquee, cancelMarquee } from '../../../services/gmService';
import { setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivity/guildActivityService';
import { initGuildActivityIndexInPinus, setDicAuctionTime, setDicGuildActivity } from '../../../services/guildActivity/guildActivityService';
import { setWeek } from '../../../pubUtils/timeUtil';
import { ServerlistType } from '../../../db/Serverlist';
import { MarqueeType } from '../../../db/Marquee';
@@ -15,7 +15,7 @@ import { MailType } from '../../../db/Mail';
import { GroupMailType } from '../../../db/GroupMail';
import { ServerMailType } from '../../../db/ServerMail';
import { ActivityModelType } from '../../../db/Activity';
import { LADDER_STATUS } from '../../../consts';
import { GUILD_ACTIVITY_TYPE, LADDER_STATUS } from '../../../consts';
export default function (app: Application) {
return new SystimerRemote(app);
@@ -26,6 +26,7 @@ export class SystimerRemote {
constructor(private app: Application) {
this.app = app;
this.channelService = app.get('channelService');
initGuildActivityIndexInPinus();
}
private channelService: ChannelService;

7
game-server/app/services/guildActivity/cityActivityObj.ts
View File

@@ -1,10 +1,12 @@
// 军团活动蛮夷入侵城门血量等数据存储
import { GUILD_ACTIVITY_STATUS } from "../../consts";
import { Member } from "../../domain/battleField/guildActivity";
import { getCityActivityGateHp } from "./guildActivityService";
// 军团诸侯混战等数据
export class CityActivityObject {
public guildActivityStatus = GUILD_ACTIVITY_STATUS.WAITING; // 活动状态 0-未开始 1-已开始 2-已结束
private gateHp: Map<string, number> = new Map(); // 城门血条，每个cityId有一条血条 serverId&cityId => gateHp
private maxHp: Map<string, number> = new Map(); // 城门血条，每个cityId最大城门血量 serverId&cityId => gateHp
private members: Map<string, Array<Member>> = new Map(); // 每个军团参与的成员 guildCode => [{roleId, job}]
@@ -39,6 +41,11 @@ export class CityActivityObject {
public startActivity() {
this.startTime = Date.now();
this.guildActivityStatus = GUILD_ACTIVITY_STATUS.START;
}
public endActivity() {
this.guildActivityStatus = GUILD_ACTIVITY_STATUS.END;
}
public getTimeGap() {

139
game-server/app/services/guildActivity/guildActivityService.ts
View File

@@ -3,7 +3,7 @@ import { RoleModel } from "../../db/Role";
import { GUILDACTIVITY } from "../../pubUtils/dicParam";
import { gameData, getGuildAuctionRewards, getCityActivityRewards, getGuildAuctionBasicNum } from "../../pubUtils/data";
import { getCurDay, nowSeconds, getTimeFun, getZeroPoint } from "../../pubUtils/timeUtil";
import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS, DEBUG_MAGIC_WORD, GUILD_POINT_WAYS, TASK_TYPE, AUCTION_TIME, CITY_ACTIVITY_DOOR, ABI_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS, SHOP_REFRESH_TYPE } from "../../consts";
import { GUILD_ACTIVITY_STATUS, GET_POINT_WAYS, GUILD_ACTIVITY_TYPE, REDIS_KEY, AUCTION_SOURCE, MAIL_TYPE, CITY_STATUS, DEBUG_MAGIC_WORD, GUILD_POINT_WAYS, TASK_TYPE, AUCTION_TIME, CITY_ACTIVITY_DOOR, ABI_TYPE, PUSH_ROUTE, RACE_ACTIVITY_STATUS, SHOP_REFRESH_TYPE, COUNTER } from "../../consts";
import { Record, UserGuildActivityRecModel } from "../../db/UserGuildActivityRec";
import { GateMembersRec, CityParam, Member, WoodenHorse, RaceActivityRankParam } from "../../domain/battleField/guildActivity";
import { DicGuildActivity } from "../../pubUtils/dictionary/DicGuildActivity";
@@ -29,6 +29,7 @@ import { sendMessageToCityWithSuc, sendMessageToGuildWithSuc, sendMessageToServe
import { saveGuildGateHpLog } from "../../pubUtils/logUtil";
import { GuildActivityCityDeclareModel } from "../../db/GuildActivityCityDeclare";
import { getRandSingleEelm } from "../../pubUtils/util";
import { CounterModel } from "../../db/Counter";
let gateActivityObj: GateActivityObject;
let cityActivityObj: CityActivityObject;
@@ -116,10 +117,11 @@ export function getGuildActivityStatus(id: number) {
export async function getAllGuildActivityStatus(guildCode: string, serverId: number) {
let guildActivities: { aid: number, status: number, time: number, isOpen: boolean, isCompleted?: boolean }[] = [];
for(let [ aid, dicGuildActivity ] of gameData.guildActivity) {
let index = getGAIndexInPinus(aid);
let res = getGuildActivityByDic(dicGuildActivity);
let isCompleted = res.isOpen;
if(res.status == GUILD_ACTIVITY_STATUS.START && guildCode) {
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, aid);
let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, aid, index);
if(guildActivityRec) isCompleted = guildActivityRec.isCompleted;
}
guildActivities.push({aid, ...res, isCompleted});
@@ -193,14 +195,15 @@ export function getRecordScore(aid: number, round: number, record: { round: numb
export async function getGateActivityRank(guildCode: string, serverId: number, roleId?: string, roleName?: string) {
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
r.setGenerFieldsFun(generGuildActivityRankField);
let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
if (!myGuildRank) {
myGuildRank = await r.generMyRankWithGuild(guildCode, 0, 0);
}
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
myR.setGenerFieldsFun(generGuildActivityMemberRankField);
let { ranks: memberRank, myRank: myMemberRank } = await myR.getRankListWithMyRank({ roleId });
if (roleName && !myMemberRank) {
@@ -212,14 +215,18 @@ export async function getGateActivityRank(guildCode: string, serverId: number, r
export async function getCityActivityRank(guildCode: string, serverId: number, cityId: number, roleId?: string, roleName?: string) {
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
if(!cityId) {
return { guildRank: [], myGuildRank: undefined, memberRank: [], myMemberRank: undefined }
}
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
r.setGenerFieldsFun(generGuildActivityRankField);
let { ranks: guildRank, myRank: myGuildRank } = await r.getRankListWithMyRank({ guildCode });
if (!myGuildRank) {
myGuildRank = await r.generMyRankWithGuild(guildCode, 0, 0);
}
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
myR.setGenerFieldsFun(generGuildActivityMemberRankField);
let { ranks: memberRank, myRank: myMemberRank } = await myR.getRankListWithMyRank({ roleId });
if (roleName && !myMemberRank) {
@@ -306,6 +313,7 @@ export async function settleGuildActivityReward(aid: number) {
}
} else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
let obj = getCityActivityObj();
obj.endActivity();
let { cities } = obj.getAllCities();
for (let { serverId, cityId } of cities) {
await cityActivitySettleReward(cityId, serverId);
@@ -376,7 +384,8 @@ export async function gateActivitySettleReward(guildCode: string, serverId: numb
let { members } = obj.getObj(guildCode, serverId);
// console.log('***** gateHp', gateHp, 'members', members);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId }, true);
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
let r = new Rank(REDIS_KEY.GATE_ACTIVITY, { serverId, index }, true);
let rank = await r.getMyRank({ guildCode });
let guildScore = await r.getMyScore({ guildCode });
// console.log('****** ranks', rank, 'guildScore', guildScore);
@@ -384,7 +393,7 @@ export async function gateActivitySettleReward(guildCode: string, serverId: numb
let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, rank);
// console.log('***** rewards', JSON.stringify(rewards));
let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, {
let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.GATE_ACTIVITY, index, {
isSuccess: true,
isCompleted: true,
rank, score: guildScore,
@@ -395,7 +404,7 @@ export async function gateActivitySettleReward(guildCode: string, serverId: numb
// 结算功勋等奖励
let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.GATE_ACTIVITY);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode }, true);
let myR = new Rank(REDIS_KEY.USER_GATE_ACTIVITY, { serverId, guildCode, index }, true);
let hasSentMember: string[] = [];
let ranks = <RoleRankInfo[]>await myR.getRankByRange();
@@ -444,21 +453,23 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
let {gateHp} = await obj.getGateHpAndInc(serverId, cityId);
let isSuccess = gateHp <= 0; // 血条未击破则没有占领军团
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId }, true);
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
let r = new Rank(REDIS_KEY.CITY_ACTIVITY, { serverId, cityId, index }, true);
let ranks = <GuildRankInfo[]>await r.getRankByRange();
console.log('###### cityActivitySettleReward', ranks)
for (let { rank: guildRank, code: guildCode, name, num } of ranks) {
if (guildRank == 1) {
if (isSuccess) {
await GuildActivityCityModel.guard(serverId, cityId, guildCode, name); // 占领
await declareCity(serverId, "", guildCode, dicCity.nextCity, true);
await GuildActivityCityModel.guard(serverId, cityId, guildCode, name, index + 1); // 占领
await declareCity(serverId, "", guildCode, dicCity.nextCity, true, index + 1);
} else {
await GuildActivityCityModel.guard(serverId, cityId, "", ""); // 无人能占领
await GuildActivityCityModel.guard(serverId, cityId, "", "", index + 1); // 无人能占领
}
}
let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, guildRank, cityId);
let members = obj.getMembersOfGuild(guildCode);
let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, {
let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.CITY_ACTIVITY, index, {
memberCnt: members.length, members,
isSuccess, isCompleted: true,
rank: guildRank, damage: num, remainGateHp: gateHp,
@@ -470,7 +481,7 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
await genAuction(guildCode, AUCTION_SOURCE.CITY, rec.code, serverId, rewards);
let dic = gameData.guildActivity.get(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode }, true);
let myR = new Rank(REDIS_KEY.USER_CITY_ACTIVITY, { serverId, guildCode, index }, true);
let ranks = <RoleRankInfo[]>await myR.getRankByRange();
let userRank = 0;
let hasSentMember: string[] = [];
@@ -496,12 +507,7 @@ export async function cityActivitySettleReward(cityId: number, serverId: number)
obj.delCityRecord(cityId, serverId);
}
/**
* 清空完declareGuilds之后，做下一次活动的自动宣战
*/
export async function autoDeclare(serverId: number) {
await GuildActivityCityModel.clearGuardAndStartNext(serverId);
await GuildActivityCityDeclareModel.clearDeclare(serverId);
for(let [ cityId ] of gameData.cityActivity) {
let msg = { cityId, declareGuildCode: "", declareCount: 0 };
await sendMessageToCityWithSuc(cityId, PUSH_ROUTE.GUILD_CITY_DECLARE, msg);
@@ -533,7 +539,7 @@ export async function participants(guildCode: string, sourceType: number, source
let rec = await GuildActivityRecordModel.findBySourceCode(guildCode, sourceType, sourceCode);
if (!rec) return [];
let baseNum = getGuildAuctionBasicNum(rec.aid, rec.rank, rec.cityId);
let baseNum = getGuildAuctionBasicNum(rec.aid, rec.rank, rec.challengeCityId);
let members = rec.members || [];
return members.map(cur => {
return { roleId: cur.roleId, job: cur.job, baseNum }
@@ -594,7 +600,7 @@ export function getCityStatus(guildCode: string, cityId: number, dic: DicCityAct
if (curCity) {
if (curCity.guardGuildCode == guildCode) {
status = CITY_STATUS.GUARD;
} else if (curCity.declareGuilds.includes(guildCode)) {
} else if (curCity.declareGuilds?.includes(guildCode)) {
status = CITY_STATUS.DECLARED;
}
}
@@ -640,14 +646,15 @@ export async function sendRaceStartMsg(serverId: number) {
await calWoodenHorseAndSend(serverId);
}
export async function cityActivityStart() {
let obj = getCityActivityObj();
obj.startActivity();
}
export async function gateActivityStart() {
let obj = getGateActivityObj();
obj.startActivity();
export async function guildActivityStart(aid: number) {
if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
let obj = getGateActivityObj();
obj.startActivity();
} else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
let obj = getCityActivityObj();
obj.startActivity();
} else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
}
}
/**
@@ -663,16 +670,17 @@ export async function raceActivitySettleReward(guildCode: string, woodenHorse: W
let { guildRank, myGuildRank } = await obj.getRanks(serverId, guildCode);
let rank = myGuildRank?.rank||0;
let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId });
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY);
let r = new Rank(REDIS_KEY.RACE_ACTIVITY, { serverId, index });
await r.setRankWithGuildInfo2(guildCode, myGuildRank.num, myGuildRank.sortTime, myGuildRank.durability);
let tomorrow = <number>getTimeFun().getAfterDayWithHour();
await r.setExpire(tomorrow);
let nextWeek = <number>getTimeFun().getAfterDayWithHour(7);
await r.setExpire(nextWeek);
let isSuccess = distance >= GUILDACTIVITY.RACEACTIVITY_LENGTH; // 血条未击破则没有占领军团
let members = obj.getMembersOfGuild(guildCode);
let rewards = getGuildAuctionRewards(GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, rank);
let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, {
let rec = await GuildActivityRecordModel.updateInfo(guildCode, GUILD_ACTIVITY_TYPE.RACE_ACTIVITY, index, {
memberCnt: members.length, members,
isSuccess, isCompleted: true, rank,
rewards: rewards.map(cur => cur.goods),
@@ -788,11 +796,11 @@ export async function getCityActivityGateHp(serverId: number, cityId: number) {
return gateHp;
}
export async function declareCity(serverId: number, roleId: string, guildCode: string, cityId: number, isAutoDeclare: boolean) {
export async function declareCity(serverId: number, roleId: string, guildCode: string, cityId: number, isAutoDeclare: boolean, declareIndex: number) {
let declareTime = Date.now();
let declareInfo = await GuildActivityCityDeclareModel.declareIfNot(serverId, guildCode, cityId, roleId, declareTime, isAutoDeclare);
let declareInfo = await GuildActivityCityDeclareModel.declareIfNot(serverId, guildCode, cityId, roleId, declareTime, isAutoDeclare, declareIndex);
if(!!declareInfo && declareInfo.declareTime == declareTime) { // 确实没有人宣战过，自己是第一个
let cityRec = await GuildActivityCityModel.declare(serverId, cityId, guildCode);
let cityRec = await GuildActivityCityModel.declare(serverId, cityId, guildCode, declareIndex);
await sendGuildCityDeclare(cityId, guildCode, cityRec.declareCount);
return true;
}
@@ -800,17 +808,66 @@ export async function declareCity(serverId: number, roleId: string, guildCode: s
}
// 非军团长的团员自动宣战
export async function autoDeclareMyCity(serverId: number, roleId: string, guildCode: string) {
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode);
export async function autoDeclareMyCity(serverId: number, roleId: string, guildCode: string, declareIndex: number) {
let checkResult = await GuildActivityCityDeclareModel.checkDeclartion(serverId, guildCode, declareIndex);
if(checkResult) return false
let cityIds = gameData.juniorCities;
let cities = await GuildActivityCityModel.findMinDeclareCountCity(serverId, cityIds);
let cities = await GuildActivityCityModel.findMinDeclareCountCity(serverId, cityIds, declareIndex);
let notDeclaredCitites = cityIds.filter(curCityId => {
return cities.findIndex(city => city.cityId == curCityId) == -1;
});
let cityId = notDeclaredCitites.length > 0? getRandSingleEelm(notDeclaredCitites): cities[0].cityId;
if(!cityId) return false;
return declareCity(serverId, roleId, guildCode, cityId, true);
return declareCity(serverId, roleId, guildCode, cityId, true, declareIndex);
}
function getCounterName(aid: GUILD_ACTIVITY_TYPE) {
switch(aid) {
case GUILD_ACTIVITY_TYPE.GATE_ACTIVITY:
return COUNTER.GATE_ACTIVITY;
case GUILD_ACTIVITY_TYPE.CITY_ACTIVITY:
return COUNTER.CITY_ACTIVITY;
case GUILD_ACTIVITY_TYPE.RACE_ACTIVITY:
return COUNTER.RACE_ACTIVITY;
}
}
export async function incCurGuildActivityIndex(aid: number) {
let name = getCounterName(aid);
let index = await CounterModel.getNewCounter(name);
setGuildActivityIndexInPinus(aid, index); // systime
pinus.app.rpc.guild.guildActivityRemote.setGuildActivityIndex.broadcast(aid, index);
}
export async function initGuildActivityIndexInPinus() {
for(let aid = GUILD_ACTIVITY_TYPE.GATE_ACTIVITY; aid <= GUILD_ACTIVITY_TYPE.RACE_ACTIVITY; aid++){
let index = await getCurGuildActivityIndexByDb(aid);
setGuildActivityIndexInPinus(aid, index);
}
}
export async function getCurGuildActivityIndexByDb(aid: number) {
let name = getCounterName(aid);
return await CounterModel.getCounter(name);
}
export function getGAPinusName(aid: number) {
return `guildact${aid}`;
}
export function setGuildActivityIndexInPinus(aid: number, index: number) {
pinus.app.set(getGAPinusName(aid), index);
}
export function getGAIndexInPinus(aid: number) {
return pinus.app.get(getGAPinusName(aid));
}
export function getDeclareIndex() {
let index = getGAIndexInPinus(GUILD_ACTIVITY_TYPE.CITY_ACTIVITY);
let obj = getCityActivityObj();
if(obj.guildActivityStatus == GUILD_ACTIVITY_STATUS.START) return index;
return index + 1;
}

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

@@ -9,7 +9,7 @@ import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE,
import { pinus } from 'pinus';
import { settleGuildWeekly } from './guildService';
import { SendMailFun, sendMailsByGmMail, } from './mailService';
import { sendEndMsgToAllServer, autoDeclare, sendGuildActivityStatus, setPreDayActiveData } from './guildActivity/guildActivityService';
import { sendEndMsgToAllServer, autoDeclare, sendGuildActivityStatus, setPreDayActiveData, incCurGuildActivityIndex } from './guildActivity/guildActivityService';
import { sendUngotDividendJob, startGuildAuction, startWorldAuction, stopAuction } from './auctionService';
import { DicGuildActivity } from '../pubUtils/dictionary/DicGuildActivity';
import { dispatch } from '../pubUtils/dispatcher';
@@ -246,8 +246,6 @@ export async function guildActivitySchedule() {
}
let dicGuildActivity = getTodayGuildActivity();
await delGuildActivityRank(dicGuildActivity.id);
// console.log(dicGuildActivity)
guildActStartJobId = scheduleJob('guildActivityStart', `${dicGuildActivity.startSeconds} ${dicGuildActivity.startMinute} ${dicGuildActivity.startTime} * * ?`, guildActivityStartSchedule);
@@ -274,17 +272,20 @@ export async function guildActivityStart(dicGuildActivity?: DicGuildActivity) {
guildActEndJobId.cancel();
guildActEndJobId = undefined;
}
if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
await pinus.app.rpc.guild.guildActivityRemote.gateAndCityActivityStart.broadcast(dicGuildActivity.id);
let aid = dicGuildActivity.id;
await incCurGuildActivityIndex(aid);
await pinus.app.rpc.guild.guildActivityRemote.guildActivityStart.broadcast(aid);
if (aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', gateActivitySeconds);
// 结束时间
guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, gateActivityEnd);
} else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
await pinus.app.rpc.guild.guildActivityRemote.gateAndCityActivityStart.broadcast(dicGuildActivity.id);
} else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
guildActSecondsJobId = scheduleJob('guildActivitySeconds', '*/10 * * * * *', cityActivitySeconds);
// 结束时间
guildActEndJobId = scheduleJob('guildActivityEnd', Date.now() + dicGuildActivity.duringTime * 1000, cityActivityEnd);
} else if (dicGuildActivity.id == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
} else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
// 开始活动
let guildServers = pinus.app.getServersByType('guild');

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

@@ -48,7 +48,10 @@ export const COUNTER = {
NOTICE: { name: 'notice', def: 1 },
GIFT_CODE: { name: 'giftCode', def: 1 },
PVP_SEASON_NUM: { name: 'pvpSeason', def: 1 },
REGION: { name: 'region', def: 1 }
REGION: { name: 'region', def: 1 },
GATE_ACTIVITY: { name: 'guildAct', def: 1 },
CITY_ACTIVITY: { name: 'cityAct', def: 1 },
RACE_ACTIVITY: { name: 'raceAct', def: 1 }
};
export const DEFAULT_HEROES = [19, 53,];

4
shared/db/Counter.ts
View File

@@ -23,9 +23,9 @@ export default class Counter extends BaseModel {
}
public static async getCounter(param:{name: string, def: number}, lean = true) {
let {name, def:defaultVal} = param;
let {name} = param;
let counter: CounterType = await CounterModel.findOne({ name }).lean(lean);
return counter?.seq||defaultVal;
return counter?.seq||0;
}
}

37
shared/db/GuildActivityCity.ts
View File

@@ -10,6 +10,9 @@ export default class GuildActivityCity extends BaseModel {
@prop({ required: true })
cityId: number; // 城池id
@prop({ required: true })
declareIndex: number; // 城池id
@prop({ required: true, type: String, default: [] })
declareGuilds: string[]; // 宣战的公会的code
@@ -29,28 +32,27 @@ export default class GuildActivityCity extends BaseModel {
status: number; // 0-过去的 1-现在的 2-未来的
// 每天宣战一次
public static async getAllCities(serverId: number) {
let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, status: 1 }).lean();
public static async getAllCities(serverId: number, declareIndex: number) {
let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, status: 1, declareIndex }).lean();
return rec;
}
public static async findMinDeclareCountCity(serverId: number, cityIds: number[]) {
let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, cityId: { $in: cityIds }, status: 1 }).sort({ declareCount: 1 }).lean();
public static async findMinDeclareCountCity(serverId: number, cityIds: number[], declareIndex: number) {
let rec: GuildActivityCityType[] = await GuildActivityCityModel.find({ serverId, cityId: { $in: cityIds }, status: 1, declareIndex }).sort({ declareCount: 1 }).lean();
return rec;
}
public static async getCity(serverId: number, cityId: number) {
let rec: GuildActivityCityType = await GuildActivityCityModel.findOne({ serverId, cityId, status: 1}).lean();
public static async getCity(serverId: number, cityId: number, declareIndex: number) {
let rec: GuildActivityCityType = await GuildActivityCityModel.findOne({ serverId, cityId, status: 1, declareIndex }).lean();
return rec;
}
// 宣言
public static async declare(serverId: number, cityId: number, guildCode: string) {
public static async declare(serverId: number, cityId: number, guildCode: string, declareIndex: number) {
let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
{ serverId, cityId, status: 1 },
{ serverId, cityId, status: 1, declareIndex },
{ $push: { declareGuilds: guildCode }, $inc: {declareCount: 1 } },
{new: true, upsert: true}).lean();
@@ -58,24 +60,13 @@ export default class GuildActivityCity extends BaseModel {
}
// 占领
public static async guard(serverId: number, cityId: number, guildCode: string, guildName: string) {
public static async guard(serverId: number, cityId: number, guildCode: string, guildName: string, declareIndex: number) {
let rec: GuildActivityCityType = await GuildActivityCityModel.findOneAndUpdate(
{ serverId, cityId, status: 1 },
{ serverId, cityId, status: 1, declareIndex },
{ $set: { guardGuildCode: guildCode, guardGuildName: guildName, guardTime: new Date()} },
{ new: true }).lean();
{ new: true, upsert: true }).lean();
return rec;
}
// 活动结束后需要清空占领情况
public static async clearGuardAndStartNext(serverId?: number) {
if(serverId) {
await GuildActivityCityModel.updateMany({ serverId, status: 1 }, { $set: { status: 0 } });
await GuildActivityCityModel.updateMany({ serverId, status: 2 }, { $set: { status: 1 } });
} else {
await GuildActivityCityModel.updateMany({ status: 1 }, { $set: { status: 0 } });
await GuildActivityCityModel.updateMany({ status: 2 }, { $set: { status: 1 } });
}
}
}
export const GuildActivityCityModel = getModelForClass(GuildActivityCity);

20
shared/db/GuildActivityCityDeclare.ts
View File

@@ -10,6 +10,9 @@ export default class GuildActivityCityDeclare extends BaseModel {
@prop({ required: true })
cityId: number; // 城池id
@prop({ required: true })
declareIndex: number; // 城池id
@prop({ required: true })
guildCode: string; // 宣战的公会的code
@@ -26,25 +29,16 @@ export default class GuildActivityCityDeclare extends BaseModel {
status: number; // 状态 1-当前 0-失效，当活动结束时定时任务设为0
// 宣战
public static async declareIfNot(serverId: number, guildCode: string, cityId: number, roleId: string, declareTime: number, isAutoDeclare: boolean) {
let rec: GuildActivityCityDeclareType = await GuildActivityCityDeclareModel.findOneAndUpdate({ serverId, guildCode, status: 1 }, { $setOnInsert: { cityId, declareMember: roleId, declareTime, isAutoDeclare } }, { new: true, upsert: true }).lean();
public static async declareIfNot(serverId: number, guildCode: string, cityId: number, roleId: string, declareTime: number, isAutoDeclare: boolean, declareIndex: number) {
let rec: GuildActivityCityDeclareType = await GuildActivityCityDeclareModel.findOneAndUpdate({ serverId, guildCode, cityId, status: 1, declareIndex }, { $setOnInsert: { declareMember: roleId, declareTime, isAutoDeclare } }, { new: true, upsert: true }).lean();
return rec;
}
// 检查是否宣战过
public static async checkDeclartion(serverId: number, guildCode: string) {
let rec = await GuildActivityCityDeclareModel.exists({ serverId, status: 1, guildCode});
public static async checkDeclartion(serverId: number, guildCode: string, declareIndex: number) {
let rec = await GuildActivityCityDeclareModel.exists({ serverId, status: 1, guildCode, declareIndex});
return rec;
}
// 清空今天的宣战
public static async clearDeclare(serverId?: number) {
if(serverId) {
await GuildActivityCityDeclareModel.updateMany({ serverId, status: 1}, { status: 0 });
} else {
await GuildActivityCityDeclareModel.updateMany({ status: 1}, { status: 0 });
}
}
}
export const GuildActivityCityDeclareModel = getModelForClass(GuildActivityCityDeclare);

43
shared/db/GuildActivityRec.ts
View File

@@ -1,7 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { ItemReward } from '../domain/dbGeneral';
import { getZeroPointD } from '../pubUtils/timeUtil';
import { genCode } from '../pubUtils/util';
import { Member, WoodenHorse, Event } from '../domain/battleField/guildActivity'
@@ -11,7 +10,7 @@ export default class GuildActivityRecord extends BaseModel {
@prop({ required: true })
code: string; // 本次记录唯一值
@prop({ required: true })
guildCode: string; // 军团code
@@ -24,6 +23,9 @@ export default class GuildActivityRecord extends BaseModel {
@prop({ required: true })
aid: number; // 军团活动id
@prop({ required: true })
index: number; // 第几次这个类型的军团活动
@prop({ required: true })
auctionType: number; // 转为拍卖行的类型
@@ -51,6 +53,9 @@ export default class GuildActivityRecord extends BaseModel {
@prop({ required: true })
remainGateHp: number; // 城门剩余血量
@prop({ required: true })
challengeCityId: number; // 诸侯混战占领了的城池
@prop({ required: true })
cityId: number; // 诸侯混战占领了的城池
@@ -64,42 +69,30 @@ export default class GuildActivityRecord extends BaseModel {
events: Event[]; // 粮草先行木马
// 每天一条记录
public static async getRecord(guildCode: string, serverId: number, aid: number, events?: Event[]) {
let today = getZeroPointD();
public static async getRecord(guildCode: string, serverId: number, aid: number, index: number, events?: Event[], cityId?: number) {
let docs = new GuildActivityRecordModel();
let code = genCode(10);
let update = Object.assign(docs, { code, guildCode, serverId, aid, createdAt: new Date(), auctionType: aid + 1 });
if(events) update = Object.assign(update, { events });
let insert = Object.assign(docs, { code, guildCode, serverId, aid, createdAt: new Date(), auctionType: aid + 1 });
if(events) insert = Object.assign(insert, { events });
let update: GuildActivityRecordUpdateParam = {};
if(cityId) update = Object.assign(update, { challengeCityId: cityId });
let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
{ aid, guildCode, createdAt: { $gte: today }, status: 1},
{ $setOnInsert: update },
{ aid, guildCode, index, status: 1},
{ $setOnInsert: insert, $set: update },
{new: true, upsert: true}).lean();
return rec;
}
public static async updateInfo(guildCode: string, aid: number, update: GuildActivityRecordUpdateParam) {
let today = getZeroPointD();
public static async updateInfo(guildCode: string, aid: number, index: number, update: GuildActivityRecordUpdateParam) {
let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
{ guildCode, aid, createdAt: { $gte: today }, status: 1 },
{ guildCode, aid, index, status: 1 },
{ $set: update }, { new: true }).lean();
return rec;
}
public static async updateTodayInfo(update: GuildActivityRecordUpdateParam) {
let today = getZeroPointD();
let rec = await GuildActivityRecordModel.updateMany(
{ createdAt: { $gte: today } },
{ $set: update }, { new: true }).lean();
return rec;
}
public static async pushEvent(guildCode: string, aid: number, event: Event) {
let today = getZeroPointD();
public static async pushEvent(guildCode: string, aid: number, index: number, event: Event) {
let rec: GuildActivityRecordType = await GuildActivityRecordModel.findOneAndUpdate(
{ guildCode, createdAt: { $gte: today }, aid, status: 1 },
{ guildCode, index, aid, status: 1 },
{ $push: { events: event } }, { new: true }).lean();
return rec;
}

4
shared/db/UserGuildActivityRec.ts
View File

@@ -129,10 +129,10 @@ export default class UserGuildActivityRec extends BaseModel {
return rec;
}
public static async pushCityRecord(code: string, damageRecord: DamageRecord) {
public static async pushCityRecord(code: string, damageRecord: DamageRecord, challengeTime: number) {
let rec: UserGuildActivityRecType = await UserGuildActivityRecModel.findOneAndUpdate(
{ code },
{ $push: { damageRecord }},
{ $push: { damageRecord }, $set: { challengeTime }},
{ new: true }
).lean();
return rec;

11
shared/domain/rank.ts
View File

@@ -289,6 +289,7 @@ export class KeyName {
hid?: number;
seasonNum?: number;
activityId?: number;
index?: number; // 军团活动第几期
constructor(key: string, param: KeyNameParam) {
this.key = key;
@@ -298,6 +299,7 @@ export class KeyName {
if(param.hid) this.hid = param.hid;
if(param.seasonNum) this.seasonNum = param.seasonNum;
if(param.activityId) this.activityId = param.activityId;
if(param.index) this.index = param.index;
}
public getName() {
@@ -311,8 +313,6 @@ export class KeyName {
case REDIS_KEY.MAIN_ELITE_RANK:
case REDIS_KEY.GUILD_LV_RANK:
case REDIS_KEY.GUILD_ACTIVE_RANK:
case REDIS_KEY.GATE_ACTIVITY:
case REDIS_KEY.RACE_ACTIVITY:
case REDIS_KEY.TOWER_RANK:
case REDIS_KEY.LADDER:
return `${this.key}:${this.serverId}`;
@@ -320,11 +320,14 @@ export class KeyName {
return `${this.key}:${this.serverId}:${this.hid}`;
case REDIS_KEY.PVP_RANK:
return `${this.key}:${this.seasonNum}`;
case REDIS_KEY.GATE_ACTIVITY:
case REDIS_KEY.RACE_ACTIVITY:
return `${this.key}:${this.serverId}:${this.index}`;
case REDIS_KEY.CITY_ACTIVITY:
return `${this.key}:${this.serverId}:${this.cityId}`;
return `${this.key}:${this.serverId}:${this.index}:${this.cityId}`;
case REDIS_KEY.USER_CITY_ACTIVITY:
case REDIS_KEY.USER_GATE_ACTIVITY:
return `${this.key}:${this.serverId}:${this.guildCode}`;
return `${this.key}:${this.serverId}:${this.index}:${this.guildCode}`;
case REDIS_KEY.GUILD_FUND:
case REDIS_KEY.SUM_CE_SNAPSHOT:
return `${this.key}:${this.serverId}:${this.activityId}`;

1
shared/pubUtils/data.ts
View File

@@ -662,7 +662,6 @@ export function getGuildAuctionRewards(aid: number, rank: number, cityId: number
}
export function getGuildAuctionBasicNum(aid: number, rank: number, cityId: number = 0) {
console.log('###### getGuildAuctionBasicNum', aid, rank, cityId)
let dic = getGuildAuction(aid, rank, cityId);
return dic?.basicDividend||0;
}